1 #include <signals/connection.hpp>
2 #include <signals/shared_connection_block.hpp>
3 #include <signals/signal.hpp>
4 #include <signals/slot.hpp>
5
6 #include <gtest/gtest.h>
7
8 using sig::Connection;
9 using sig::Shared_connection_block;
10 using sig::Signal;
11 using sig::Slot;
12
TEST(SharedConnectionBlockTest,DefaultConstructor)13 TEST(SharedConnectionBlockTest, DefaultConstructor) {
14 Shared_connection_block scb1{};
15 EXPECT_FALSE(scb1.blocking());
16
17 Signal<int(char)> sig1;
18 Slot<int(char)> slot_1 = [](char) { return 3; };
19 auto conn = sig1.connect(slot_1);
20
21 EXPECT_FALSE(conn.blocked());
22
23 Shared_connection_block scb2(conn);
24
25 EXPECT_TRUE(conn.blocked());
26 EXPECT_TRUE(scb2.blocking());
27 EXPECT_FALSE(bool(sig1('g')));
28
29 Signal<int(char)> sig2;
30 Slot<int(char)> slot_2 = [](char) { return 3; };
31 auto conn2 = sig2.connect(slot_2);
32
33 EXPECT_FALSE(conn2.blocked());
34
35 Shared_connection_block scb3(conn2, false);
36 EXPECT_FALSE(conn2.blocked());
37 EXPECT_FALSE(scb3.blocking());
38
39 scb3.block();
40 EXPECT_TRUE(conn2.blocked());
41 EXPECT_TRUE(scb3.blocking());
42 }
43
TEST(SharedConnectionBlockTest,CopyConstructor)44 TEST(SharedConnectionBlockTest, CopyConstructor) {
45 Signal<int(char)> sig1;
46 Slot<int(char)> slot_1 = [](char) { return 3; };
47 auto conn1 = sig1.connect(slot_1);
48 Shared_connection_block scb1(conn1);
49
50 EXPECT_TRUE(scb1.blocking());
51
52 Shared_connection_block scb1_copy(scb1);
53
54 EXPECT_TRUE(scb1_copy.blocking());
55 EXPECT_TRUE(conn1.blocked());
56
57 scb1.unblock();
58 EXPECT_FALSE(scb1.blocking());
59 EXPECT_TRUE(scb1_copy.blocking());
60 EXPECT_TRUE(conn1.blocked());
61
62 scb1_copy.block();
63 EXPECT_TRUE(scb1_copy.blocking());
64 EXPECT_FALSE(scb1.blocking());
65 EXPECT_TRUE(conn1.blocked());
66
67 scb1_copy.unblock();
68 EXPECT_FALSE(scb1.blocking());
69 EXPECT_FALSE(conn1.blocked());
70 }
71
TEST(SharedConnectionBlockTest,CopyAssignmentOperator)72 TEST(SharedConnectionBlockTest, CopyAssignmentOperator) {
73 Signal<int()> sig1;
74 Slot<int()> slot_1 = []() { return 4; };
75 auto conn1 = sig1.connect(slot_1);
76
77 Shared_connection_block scb1{conn1};
78 Shared_connection_block scb2;
79 scb2 = scb1;
80
81 EXPECT_TRUE(conn1.blocked());
82 EXPECT_TRUE(scb2.blocking());
83
84 scb1.unblock();
85
86 EXPECT_TRUE(scb2.blocking());
87 EXPECT_FALSE(scb1.blocking());
88 EXPECT_TRUE(conn1.blocked());
89
90 scb2.unblock();
91
92 EXPECT_FALSE(scb1.blocking());
93 EXPECT_FALSE(scb2.blocking());
94 EXPECT_FALSE(conn1.blocked());
95
96 scb1.block();
97
98 EXPECT_TRUE(scb1.blocking());
99 EXPECT_FALSE(scb2.blocking());
100 EXPECT_TRUE(conn1.blocked());
101
102 Signal<int(double)> sig2;
103 Slot<int(double)> slot_2 = [](double) { return 4; };
104 auto conn2 = sig2.connect(slot_2);
105 Slot<int(const Connection&, double)> slot_ext = [](const Connection&,
106 double) { return 5; };
107 auto conn3 = sig2.connect_extended(1, slot_ext);
108
109 Shared_connection_block scb4{conn2};
110 Shared_connection_block scb3{conn3};
111
112 EXPECT_TRUE(conn2.blocked());
113 EXPECT_TRUE(conn3.blocked());
114 EXPECT_FALSE(bool(sig2(5.4)));
115
116 scb3 = scb4;
117
118 EXPECT_TRUE(conn2.blocked());
119 EXPECT_FALSE(conn3.blocked());
120 EXPECT_TRUE(scb4.blocking());
121 EXPECT_TRUE(scb3.blocking());
122 ASSERT_TRUE(bool(sig2(5.4)));
123 EXPECT_EQ(5, *sig2(5.4));
124
125 scb4.unblock();
126 EXPECT_TRUE(conn2.blocked());
127 EXPECT_FALSE(conn3.blocked());
128 EXPECT_FALSE(scb4.blocking());
129 EXPECT_TRUE(scb3.blocking());
130 ASSERT_TRUE(bool(sig2(5.4)));
131 EXPECT_EQ(5, *sig2(5.4));
132
133 scb3.unblock();
134 EXPECT_FALSE(conn2.blocked());
135 EXPECT_FALSE(conn3.blocked());
136 EXPECT_FALSE(scb4.blocking());
137 EXPECT_FALSE(scb3.blocking());
138 ASSERT_TRUE(bool(sig2(5.4)));
139 EXPECT_EQ(4, *sig2(5.4));
140 }
141
TEST(SharedConnectionBlockTest,Destructor)142 TEST(SharedConnectionBlockTest, Destructor) {
143 Signal<int(double)> sig1;
144 Slot<int(double)> slot_1;
145 auto conn1 = sig1.connect(slot_1);
146
147 auto scb_ptr = std::make_shared<Shared_connection_block>(conn1);
148
149 EXPECT_TRUE(scb_ptr->blocking());
150 EXPECT_TRUE(conn1.blocked());
151
152 scb_ptr.reset();
153
154 EXPECT_FALSE(conn1.blocked());
155 }
156
TEST(SharedConnectionBlockTest,Block)157 TEST(SharedConnectionBlockTest, Block) {
158 Signal<int()> sig;
159 Slot<int()> slot_1;
160 auto conn1 = sig.connect(slot_1);
161
162 Shared_connection_block scb{conn1, false};
163 EXPECT_FALSE(conn1.blocked());
164 EXPECT_FALSE(scb.blocking());
165
166 scb.block();
167 EXPECT_TRUE(conn1.blocked());
168 EXPECT_TRUE(scb.blocking());
169
170 scb.block();
171 EXPECT_TRUE(conn1.blocked());
172 EXPECT_TRUE(scb.blocking());
173
174 scb.block();
175 scb.block();
176 scb.block();
177 EXPECT_TRUE(conn1.blocked());
178 EXPECT_TRUE(scb.blocking());
179
180 scb.unblock();
181 EXPECT_FALSE(conn1.blocked());
182 EXPECT_FALSE(scb.blocking());
183
184 Shared_connection_block scb2{conn1};
185 scb.block();
186 EXPECT_TRUE(conn1.blocked());
187 EXPECT_TRUE(scb.blocking());
188 EXPECT_TRUE(scb2.blocking());
189 scb.block();
190 scb2.block();
191 EXPECT_TRUE(conn1.blocked());
192 EXPECT_TRUE(scb.blocking());
193 EXPECT_TRUE(scb2.blocking());
194 scb.unblock();
195 EXPECT_TRUE(conn1.blocked());
196 EXPECT_FALSE(scb.blocking());
197 EXPECT_TRUE(scb2.blocking());
198 scb2.unblock();
199 EXPECT_FALSE(conn1.blocked());
200 EXPECT_FALSE(scb.blocking());
201 EXPECT_FALSE(scb2.blocking());
202 }
203
TEST(SharedConnectionBlockTest,UnBlock)204 TEST(SharedConnectionBlockTest, UnBlock) {
205 Signal<void(int)> sig;
206 Slot<void(int)> slot_1 = [](int) { return; };
207 auto conn1 = sig.connect(slot_1);
208
209 Shared_connection_block scb{conn1, true};
210 EXPECT_TRUE(conn1.blocked());
211 EXPECT_TRUE(scb.blocking());
212
213 scb.unblock();
214 scb.unblock();
215 scb.unblock();
216 scb.unblock();
217 scb.unblock();
218 scb.unblock();
219
220 EXPECT_FALSE(conn1.blocked());
221 EXPECT_FALSE(scb.blocking());
222 }
223
TEST(SharedConnectionBlockTest,Blocking)224 TEST(SharedConnectionBlockTest, Blocking) {
225 Shared_connection_block scb1;
226 EXPECT_FALSE(scb1.blocking());
227
228 Signal<int()> sig;
229 Slot<int()> slot_1 = []() { return 2; };
230 auto conn1 = sig.connect(slot_1);
231
232 Shared_connection_block scb2{conn1};
233 Shared_connection_block scb3{conn1, false};
234
235 EXPECT_TRUE(scb2.blocking());
236 EXPECT_FALSE(scb3.blocking());
237
238 scb3.block();
239 EXPECT_TRUE(scb3.blocking());
240
241 scb2.unblock();
242 EXPECT_FALSE(scb2.blocking());
243 }
244
TEST(SharedConnectionBlockTest,Connection)245 TEST(SharedConnectionBlockTest, Connection) {
246 Signal<int()> sig;
247 Slot<int()> slot_1 = []() { return 2; };
248 auto conn1 = sig.connect(slot_1);
249
250 Shared_connection_block scb2{conn1};
251
252 EXPECT_TRUE(conn1.connected());
253 scb2.connection().disconnect();
254 EXPECT_FALSE(conn1.connected());
255
256 Shared_connection_block scb_empty;
257 EXPECT_FALSE(scb_empty.connection().connected());
258 }
259