~townsend/unity/fix-lp1301394-trusty : contents of tests/test_connection

~townsend/unity/fix-lp1301394-trusty : (revision 3821)

// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
/*
 * Copyright (C) 2013 Canonical Ltd
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Authored by: Marco Trevisan (Treviño) <marco.trevisan@canonical.com>
 */

#include <gmock/gmock.h>
#include <UnityCore/ConnectionManager.h>
#include <glib.h>

using namespace unity;

namespace
{
connection::handle global_handle = 0;

struct SignalerObject
{
  sigc::signal<void> awesome_signal;
};

// connection::Wrapper tests

TEST(TestConnectionWrapper, InitializationEmpty)
{
  connection::Wrapper wrapper;
  EXPECT_FALSE(wrapper.Get().connected());
}

TEST(TestConnectionWrapper, InitializationFromConnection)
{
  SignalerObject signaler;
  sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});

  connection::Wrapper wrapper(conn);
  EXPECT_TRUE(conn.connected());
}

TEST(TestConnectionWrapper, Get)
{
  SignalerObject signaler;
  sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});

  connection::Wrapper wrapper(conn);
  EXPECT_TRUE(wrapper.Get().connected());
}

TEST(TestConnectionWrapper, DisconnectOnDestruction)
{
  SignalerObject signaler;
  sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});

  {
    connection::Wrapper wrapper(conn);
    ASSERT_TRUE(conn.connected());
  }

  EXPECT_FALSE(conn.connected());
}

TEST(TestConnectionWrapper, CastToConnection)
{
  SignalerObject signaler;
  sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});

  connection::Wrapper wrapper(conn);
  conn.block(true);

  sigc::connection conn2 = wrapper;
  EXPECT_TRUE(conn2.blocked());
}

TEST(TestConnectionWrapper, CastToBool)
{
  SignalerObject signaler;

  connection::Wrapper wrapper;
  EXPECT_FALSE(wrapper);

  sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
  wrapper = conn;
  EXPECT_TRUE(wrapper);
}

TEST(TestConnectionWrapper, PointerConstOperator)
{
  SignalerObject signaler;
  sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});

  connection::Wrapper wrapper(conn);
  conn.block(true);

  EXPECT_TRUE(wrapper->blocked());
  EXPECT_TRUE(wrapper->connected());
}

TEST(TestConnectionWrapper, PointerOperator)
{
  SignalerObject signaler;
  sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
  connection::Wrapper wrapper(conn);

  wrapper->disconnect();
  EXPECT_FALSE(conn.connected());
}

TEST(TestConnectionWrapper, StarConstOperator)
{
  SignalerObject signaler;
  sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});

  connection::Wrapper wrapper(conn);
  conn.block(true);

  EXPECT_TRUE((*wrapper).blocked());
  EXPECT_TRUE((*wrapper).connected());
}

TEST(TestConnectionWrapper, StarOperator)
{
  SignalerObject signaler;
  sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});

  connection::Wrapper wrapper(conn);

  (*wrapper).disconnect();
  EXPECT_FALSE(conn.connected());
}

TEST(TestConnectionWrapper, AssignmentOperator)
{
  SignalerObject signaler;
  sigc::connection conn1 = signaler.awesome_signal.connect([] {/* Awesome callback! */});

  connection::Wrapper wrapper(conn1);
  conn1.block(true);

  ASSERT_TRUE(conn1.connected());

  sigc::connection conn2 = signaler.awesome_signal.connect([] {/* Awesome callback! */});
  wrapper = conn2;

  EXPECT_FALSE(conn1.connected());
  EXPECT_TRUE(conn2.connected());
}

// connection::Manager tests

TEST(TestConnectionManager, Initialization)
{
  connection::Manager manager;
  EXPECT_TRUE(manager.Empty());
  EXPECT_EQ(manager.Size(), 0);
}

TEST(TestConnectionManager, AddEmpty)
{
  connection::Manager manager;
  sigc::connection empty_connection;
  ASSERT_TRUE(empty_connection.empty());

  connection::handle handle = manager.Add(empty_connection);

  EXPECT_EQ(handle, global_handle);
  EXPECT_TRUE(manager.Empty());
  EXPECT_EQ(manager.Size(), 0);
}

TEST(TestConnectionManager, AddSignal)
{
  connection::Manager manager;
  SignalerObject signaler;

  sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
  ASSERT_TRUE(conn.connected());

  connection::handle handle = manager.Add(conn);

  ++global_handle;
  EXPECT_EQ(handle, global_handle);
  EXPECT_FALSE(manager.Empty());
  EXPECT_EQ(manager.Size(), 1);
}

TEST(TestConnectionManager, AddMultipleSignals)
{
  connection::Manager manager;
  SignalerObject signaler;

  for (int i = 1; i <= 10; ++i)
  {
    auto const& conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
    auto handle = manager.Add(conn);
    EXPECT_EQ(handle, ++global_handle);
    EXPECT_EQ(manager.Size(), i);
  }
}

TEST(TestConnectionManager, RemoveAvailable)
{
  connection::Manager manager;
  SignalerObject signaler;

  sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
  auto handle = manager.Add(conn);
  ASSERT_TRUE(conn.connected());
  ASSERT_FALSE(manager.Empty());

  EXPECT_TRUE(manager.Remove(handle));
  EXPECT_FALSE(conn.connected());
  EXPECT_TRUE(manager.Empty());
}

TEST(TestConnectionManager, RemoveAndClearAvailable)
{
  connection::Manager manager;
  SignalerObject signaler;

  sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
  auto handle = manager.Add(conn);
  ASSERT_TRUE(conn.connected());
  ASSERT_FALSE(manager.Empty());

  EXPECT_TRUE(manager.RemoveAndClear(&handle));
  EXPECT_FALSE(conn.connected());
  EXPECT_TRUE(manager.Empty());
  EXPECT_EQ(handle, 0);
}

TEST(TestConnectionManager, RemoveUnavailable)
{
  connection::Manager manager;

  connection::handle handle = 5;
  EXPECT_FALSE(manager.RemoveAndClear(&handle));
  EXPECT_TRUE(manager.Empty());
  EXPECT_EQ(handle, 5);
}

TEST(TestConnectionManager, ReplaceOnEmpty)
{
  connection::Manager manager;
  SignalerObject signaler;

  auto const& conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
  EXPECT_GT(manager.Replace(0, conn), 0);
  EXPECT_FALSE(manager.Empty());
}

TEST(TestConnectionManager, ReplaceUnavailable)
{
  connection::Manager manager;
  SignalerObject signaler;

  auto const& conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
  manager.Add(conn);
  ASSERT_FALSE(manager.Empty());

  EXPECT_GT(manager.Replace(0, conn), 0);
  EXPECT_EQ(manager.Size(), 2);
}

TEST(TestConnectionManager, ReplaceAvailable)
{
  connection::Manager manager;
  SignalerObject signaler;

  sigc::connection first_conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
  auto first_handle = manager.Add(first_conn);
  ASSERT_FALSE(manager.Empty());

  sigc::connection second_conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
  auto second_handle = manager.Replace(first_handle, second_conn);
  EXPECT_EQ(manager.Size(), 1);
  EXPECT_EQ(first_handle, second_handle);

  EXPECT_FALSE(first_conn.connected());
  EXPECT_TRUE(second_conn.connected());
}

TEST(TestConnectionManager, GetAvailable)
{
  connection::Manager manager;
  SignalerObject signaler;

  sigc::connection first_conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
  auto handle = manager.Add(first_conn);
  ASSERT_FALSE(manager.Empty());

  auto second_conn = manager.Get(handle);
  EXPECT_TRUE(second_conn.connected());

  second_conn.disconnect();
  EXPECT_FALSE(first_conn.connected());
}

TEST(TestConnectionManager, GetUnavailable)
{
  connection::Manager manager;

  auto conn = manager.Get(0);
  EXPECT_FALSE(conn.connected());
  EXPECT_TRUE(conn.empty());

  conn = manager.Get(g_random_int());
  EXPECT_FALSE(conn.connected());
  EXPECT_TRUE(conn.empty());
}

TEST(TestConnectionManager, Clear)
{
  SignalerObject signaler;
  std::vector<sigc::connection> connections;
  connection::Manager manager;

  for (int i = 1; i <= 10; ++i)
  {
    auto const& conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
    connections.push_back(conn);
    ASSERT_TRUE(connections.back().connected());
    manager.Add(conn);
  }

  ASSERT_FALSE(manager.Empty());
  ASSERT_EQ(manager.Size(), connections.size());

  manager.Clear();

  for (auto const& conn : connections)
    ASSERT_FALSE(conn.connected());

  EXPECT_TRUE(manager.Empty());
}

TEST(TestConnectionManager, DisconnectOnDestruction)
{
  SignalerObject signaler;
  std::vector<sigc::connection> connections;

  for (int i = 1; i <= 10; ++i)
  {
    auto const& conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
    connections.push_back(conn);
    ASSERT_TRUE(connections.back().connected());
  }

  {
    connection::Manager manager;

    for (auto const& conn : connections)
      manager.Add(conn);

    ASSERT_FALSE(manager.Empty());
    ASSERT_EQ(manager.Size(), connections.size());
  }

  for (auto const& conn : connections)
    ASSERT_FALSE(conn.connected());
}

TEST(TestConnectionManager, DestructWithDisconnected)
{
  SignalerObject signaler;
  std::vector<sigc::connection> connections;

  {
    connection::Manager manager;

    for (int i = 1; i <= 10; ++i)
    {
      auto const& conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
      connections.push_back(conn);
      manager.Add(conn);
    }

    ASSERT_FALSE(manager.Empty());
    ASSERT_EQ(manager.Size(), connections.size());

    for (auto& conn : connections)
      conn.disconnect();

    EXPECT_EQ(manager.Size(), connections.size());
  }

  // At this point the manager has been destructed
}

} // Namespace

3387.3.2 by Marco Trevisan (Treviño) TestConnectionManager: add tests for unity::connection::Manager	1	// -- Mode: C++; indent-tabs-mode: nil; tab-width: 2 --
	2	/*
	3	* Copyright (C) 2013 Canonical Ltd
	4	*
	5	* This program is free software: you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 3 as
	7	* published by the Free Software Foundation.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	16	*
	17	* Authored by: Marco Trevisan (Treviño) <marco.trevisan@canonical.com>
	18	*/
	19
	20	#include <gmock/gmock.h>
	21	#include <UnityCore/ConnectionManager.h>
	22	#include <glib.h>
	23
	24	using namespace unity;
	25
	26	namespace
	27	{
	28	connection::handle global_handle = 0;
	29
	30	struct SignalerObject
	31	{
	32	sigc::signal<void> awesome_signal;
	33	};
	34
3387.3.14 by Marco Trevisan (Treviño) TestConnectionWrapper: add tests for connection::Wrapper	35	// connection::Wrapper tests
	36
	37	TEST(TestConnectionWrapper, InitializationEmpty)
	38	{
	39	connection::Wrapper wrapper;
	40	EXPECT_FALSE(wrapper.Get().connected());
	41	}
	42
	43	TEST(TestConnectionWrapper, InitializationFromConnection)
	44	{
	45	SignalerObject signaler;
	46	sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	47
	48	connection::Wrapper wrapper(conn);
	49	EXPECT_TRUE(conn.connected());
	50	}
	51
	52	TEST(TestConnectionWrapper, Get)
	53	{
	54	SignalerObject signaler;
	55	sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	56
	57	connection::Wrapper wrapper(conn);
	58	EXPECT_TRUE(wrapper.Get().connected());
	59	}
	60
	61	TEST(TestConnectionWrapper, DisconnectOnDestruction)
	62	{
	63	SignalerObject signaler;
	64	sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	65
	66	{
	67	connection::Wrapper wrapper(conn);
	68	ASSERT_TRUE(conn.connected());
	69	}
	70
	71	EXPECT_FALSE(conn.connected());
	72	}
	73
	74	TEST(TestConnectionWrapper, CastToConnection)
	75	{
	76	SignalerObject signaler;
	77	sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	78
	79	connection::Wrapper wrapper(conn);
	80	conn.block(true);
	81
	82	sigc::connection conn2 = wrapper;
	83	EXPECT_TRUE(conn2.blocked());
	84	}
	85
	86	TEST(TestConnectionWrapper, CastToBool)
	87	{
	88	SignalerObject signaler;
	89
	90	connection::Wrapper wrapper;
	91	EXPECT_FALSE(wrapper);
	92
	93	sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	94	wrapper = conn;
	95	EXPECT_TRUE(wrapper);
	96	}
	97
	98	TEST(TestConnectionWrapper, PointerConstOperator)
99	{
100	SignalerObject signaler;
101	sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
102
103	connection::Wrapper wrapper(conn);
104	conn.block(true);
105
106	EXPECT_TRUE(wrapper->blocked());
107	EXPECT_TRUE(wrapper->connected());
108	}
109
110	TEST(TestConnectionWrapper, PointerOperator)
111	{
112	SignalerObject signaler;
113	sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
114	connection::Wrapper wrapper(conn);
115
116	wrapper->disconnect();
117	EXPECT_FALSE(conn.connected());
118	}
119
120	TEST(TestConnectionWrapper, StarConstOperator)
121	{
122	SignalerObject signaler;
123	sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
124
125	connection::Wrapper wrapper(conn);
126	conn.block(true);
127
128	EXPECT_TRUE((*wrapper).blocked());
129	EXPECT_TRUE((*wrapper).connected());
130	}
131
132	TEST(TestConnectionWrapper, StarOperator)
133	{
134	SignalerObject signaler;
135	sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
136
137	connection::Wrapper wrapper(conn);
138
139	(*wrapper).disconnect();
140	EXPECT_FALSE(conn.connected());
141	}
142
143	TEST(TestConnectionWrapper, AssignmentOperator)
144	{
145	SignalerObject signaler;
146	sigc::connection conn1 = signaler.awesome_signal.connect([] {/* Awesome callback! */});
147
148	connection::Wrapper wrapper(conn1);
149	conn1.block(true);
150
151	ASSERT_TRUE(conn1.connected());
152
153	sigc::connection conn2 = signaler.awesome_signal.connect([] {/* Awesome callback! */});
154	wrapper = conn2;
155
156	EXPECT_FALSE(conn1.connected());
157	EXPECT_TRUE(conn2.connected());
158	}
159
160	// connection::Manager tests
161
3387.3.2 by Marco Trevisan (Treviño) TestConnectionManager: add tests for unity::connection::Manager	162	TEST(TestConnectionManager, Initialization)
	163	{
	164	connection::Manager manager;
	165	EXPECT_TRUE(manager.Empty());
	166	EXPECT_EQ(manager.Size(), 0);
	167	}
	168
	169	TEST(TestConnectionManager, AddEmpty)
	170	{
	171	connection::Manager manager;
	172	sigc::connection empty_connection;
	173	ASSERT_TRUE(empty_connection.empty());
	174
	175	connection::handle handle = manager.Add(empty_connection);
	176
	177	EXPECT_EQ(handle, global_handle);
	178	EXPECT_TRUE(manager.Empty());
	179	EXPECT_EQ(manager.Size(), 0);
	180	}
	181
	182	TEST(TestConnectionManager, AddSignal)
	183	{
	184	connection::Manager manager;
	185	SignalerObject signaler;
	186
	187	sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	188	ASSERT_TRUE(conn.connected());
	189
	190	connection::handle handle = manager.Add(conn);
	191
	192	++global_handle;
	193	EXPECT_EQ(handle, global_handle);
	194	EXPECT_FALSE(manager.Empty());
	195	EXPECT_EQ(manager.Size(), 1);
	196	}
	197
	198	TEST(TestConnectionManager, AddMultipleSignals)
	199	{
	200	connection::Manager manager;
	201	SignalerObject signaler;
	202
	203	for (int i = 1; i <= 10; ++i)
	204	{
	205	auto const& conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	206	auto handle = manager.Add(conn);
	207	EXPECT_EQ(handle, ++global_handle);
	208	EXPECT_EQ(manager.Size(), i);
	209	}
	210	}
	211
	212	TEST(TestConnectionManager, RemoveAvailable)
	213	{
	214	connection::Manager manager;
	215	SignalerObject signaler;
	216
	217	sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	218	auto handle = manager.Add(conn);
	219	ASSERT_TRUE(conn.connected());
	220	ASSERT_FALSE(manager.Empty());
	221
	222	EXPECT_TRUE(manager.Remove(handle));
	223	EXPECT_FALSE(conn.connected());
	224	EXPECT_TRUE(manager.Empty());
	225	}
226
3387.3.4 by Marco Trevisan (Treviño) TestConnectionManager: test RemoveAndClear method	227	TEST(TestConnectionManager, RemoveAndClearAvailable)
	228	{
	229	connection::Manager manager;
	230	SignalerObject signaler;
	231
	232	sigc::connection conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	233	auto handle = manager.Add(conn);
	234	ASSERT_TRUE(conn.connected());
	235	ASSERT_FALSE(manager.Empty());
	236
	237	EXPECT_TRUE(manager.RemoveAndClear(&handle));
	238	EXPECT_FALSE(conn.connected());
	239	EXPECT_TRUE(manager.Empty());
	240	EXPECT_EQ(handle, 0);
	241	}
	242
3387.3.2 by Marco Trevisan (Treviño) TestConnectionManager: add tests for unity::connection::Manager	243	TEST(TestConnectionManager, RemoveUnavailable)
	244	{
	245	connection::Manager manager;
	246
3387.3.4 by Marco Trevisan (Treviño) TestConnectionManager: test RemoveAndClear method	247	connection::handle handle = 5;
	248	EXPECT_FALSE(manager.RemoveAndClear(&handle));
3387.3.2 by Marco Trevisan (Treviño) TestConnectionManager: add tests for unity::connection::Manager	249	EXPECT_TRUE(manager.Empty());
3387.3.4 by Marco Trevisan (Treviño) TestConnectionManager: test RemoveAndClear method	250	EXPECT_EQ(handle, 5);
3387.3.2 by Marco Trevisan (Treviño) TestConnectionManager: add tests for unity::connection::Manager	251	}
	252
	253	TEST(TestConnectionManager, ReplaceOnEmpty)
	254	{
	255	connection::Manager manager;
	256	SignalerObject signaler;
	257
	258	auto const& conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	259	EXPECT_GT(manager.Replace(0, conn), 0);
	260	EXPECT_FALSE(manager.Empty());
	261	}
	262
	263	TEST(TestConnectionManager, ReplaceUnavailable)
	264	{
	265	connection::Manager manager;
	266	SignalerObject signaler;
	267
	268	auto const& conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	269	manager.Add(conn);
	270	ASSERT_FALSE(manager.Empty());
	271
	272	EXPECT_GT(manager.Replace(0, conn), 0);
	273	EXPECT_EQ(manager.Size(), 2);
	274	}
	275
	276	TEST(TestConnectionManager, ReplaceAvailable)
	277	{
	278	connection::Manager manager;
	279	SignalerObject signaler;
	280
	281	sigc::connection first_conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	282	auto first_handle = manager.Add(first_conn);
	283	ASSERT_FALSE(manager.Empty());
	284
	285	sigc::connection second_conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	286	auto second_handle = manager.Replace(first_handle, second_conn);
	287	EXPECT_EQ(manager.Size(), 1);
	288	EXPECT_EQ(first_handle, second_handle);
	289
	290	EXPECT_FALSE(first_conn.connected());
	291	EXPECT_TRUE(second_conn.connected());
	292	}
	293
3387.3.6 by Marco Trevisan (Treviño) TestConnectionManager: test Get method	294	TEST(TestConnectionManager, GetAvailable)
	295	{
	296	connection::Manager manager;
	297	SignalerObject signaler;
	298
	299	sigc::connection first_conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	300	auto handle = manager.Add(first_conn);
	301	ASSERT_FALSE(manager.Empty());
	302
	303	auto second_conn = manager.Get(handle);
	304	EXPECT_TRUE(second_conn.connected());
	305
	306	second_conn.disconnect();
	307	EXPECT_FALSE(first_conn.connected());
	308	}
	309
	310	TEST(TestConnectionManager, GetUnavailable)
	311	{
	312	connection::Manager manager;
	313
	314	auto conn = manager.Get(0);
	315	EXPECT_FALSE(conn.connected());
	316	EXPECT_TRUE(conn.empty());
	317
	318	conn = manager.Get(g_random_int());
	319	EXPECT_FALSE(conn.connected());
	320	EXPECT_TRUE(conn.empty());
	321	}
	322
3387.3.12 by Marco Trevisan (Treviño) TestConnectionManager: test Clear method	323	TEST(TestConnectionManager, Clear)
	324	{
	325	SignalerObject signaler;
	326	std::vector<sigc::connection> connections;
	327	connection::Manager manager;
	328
	329	for (int i = 1; i <= 10; ++i)
	330	{
	331	auto const& conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	332	connections.push_back(conn);
	333	ASSERT_TRUE(connections.back().connected());
	334	manager.Add(conn);
	335	}
	336
	337	ASSERT_FALSE(manager.Empty());
	338	ASSERT_EQ(manager.Size(), connections.size());
	339
	340	manager.Clear();
	341
	342	for (auto const& conn : connections)
	343	ASSERT_FALSE(conn.connected());
	344
	345	EXPECT_TRUE(manager.Empty());
	346	}
	347
3387.3.2 by Marco Trevisan (Treviño) TestConnectionManager: add tests for unity::connection::Manager	348	TEST(TestConnectionManager, DisconnectOnDestruction)
	349	{
	350	SignalerObject signaler;
	351	std::vector<sigc::connection> connections;
	352
	353	for (int i = 1; i <= 10; ++i)
	354	{
	355	auto const& conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	356	connections.push_back(conn);
	357	ASSERT_TRUE(connections.back().connected());
	358	}
	359
	360	{
	361	connection::Manager manager;
	362
	363	for (auto const& conn : connections)
	364	manager.Add(conn);
	365
	366	ASSERT_FALSE(manager.Empty());
	367	ASSERT_EQ(manager.Size(), connections.size());
	368	}
	369
	370	for (auto const& conn : connections)
	371	ASSERT_FALSE(conn.connected());
	372	}
	373
	374	TEST(TestConnectionManager, DestructWithDisconnected)
	375	{
	376	SignalerObject signaler;
	377	std::vector<sigc::connection> connections;
	378
	379	{
	380	connection::Manager manager;
	381
	382	for (int i = 1; i <= 10; ++i)
	383	{
	384	auto const& conn = signaler.awesome_signal.connect([] {/* Awesome callback! */});
	385	connections.push_back(conn);
	386	manager.Add(conn);
	387	}
	388
	389	ASSERT_FALSE(manager.Empty());
	390	ASSERT_EQ(manager.Size(), connections.size());
	391
	392	for (auto& conn : connections)
	393	conn.disconnect();
	394
	395	EXPECT_EQ(manager.Size(), connections.size());
	396	}
	397
	398	// At this point the manager has been destructed
	399	}
	400
	401	} // Namespace