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