libamxp  1.4.0
Patterns C Implementation
test_signal_slots_global.c
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** SPDX-License-Identifier: BSD-2-Clause-Patent
4 **
5 ** SPDX-FileCopyrightText: Copyright (c) 2023 SoftAtHome
6 **
7 ** Redistribution and use in source and binary forms, with or without modification,
8 ** are permitted provided that the following conditions are met:
9 **
10 ** 1. Redistributions of source code must retain the above copyright notice,
11 ** this list of conditions and the following disclaimer.
12 **
13 ** 2. Redistributions in binary form must reproduce the above copyright notice,
14 ** this list of conditions and the following disclaimer in the documentation
15 ** and/or other materials provided with the distribution.
16 **
17 ** Subject to the terms and conditions of this license, each copyright holder
18 ** and contributor hereby grants to those receiving rights under this license
19 ** a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
20 ** (except for failure to satisfy the conditions of this license) patent license
21 ** to make, have made, use, offer to sell, sell, import, and otherwise transfer
22 ** this software, where such license applies only to those patent claims, already
23 ** acquired or hereafter acquired, licensable by such copyright holder or contributor
24 ** that are necessarily infringed by:
25 **
26 ** (a) their Contribution(s) (the licensed copyrights of copyright holders and
27 ** non-copyrightable additions of contributors, in source or binary form) alone;
28 ** or
29 **
30 ** (b) combination of their Contribution(s) with the work of authorship to which
31 ** such Contribution(s) was added by such copyright holder or contributor, if,
32 ** at the time the Contribution is added, such addition causes such combination
33 ** to be necessarily infringed. The patent license shall not apply to any other
34 ** combinations which include the Contribution.
35 **
36 ** Except as expressly stated above, no rights or licenses from any copyright
37 ** holder or contributor is granted under this license, whether expressly, by
38 ** implication, estoppel or otherwise.
39 **
40 ** DISCLAIMER
41 **
42 ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
43 ** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45 ** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
46 ** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47 ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
48 ** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
49 ** CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
50 ** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
51 ** USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
52 **
53 ****************************************************************************/
54 
55 #include <stdlib.h>
56 #include <stdio.h>
57 #include <stdarg.h>
58 #include <stddef.h>
59 #include <setjmp.h>
60 #include <fcntl.h>
61 #include <unistd.h>
62 #include <cmocka.h>
63 
64 #include <amxc/amxc_variant.h>
65 #include <amxc/amxc_lqueue.h>
66 
67 #include <amxp/amxp_signal.h>
68 #include <amxp/amxp_slot.h>
69 #include <amxp_signal_priv.h>
70 
71 #include "test_signal_slots_global.h"
72 
73 static const char* expected_sig_name = NULL;
74 static int count1 = 0;
75 static int count2 = 0;
76 
77 #include <amxc/amxc_macros.h>
78 static void test_slot1(const char* const sig_name,
79  const amxc_var_t* const data,
80  UNUSED void* const priv) {
81  if(expected_sig_name != NULL) {
82  assert_ptr_not_equal(data, NULL);
83  const char* txt = amxc_var_constcast(cstring_t, data);
84  assert_int_equal(amxc_var_type_of(data), AMXC_VAR_ID_CSTRING);
85  assert_ptr_not_equal(txt, NULL);
86  assert_string_equal(sig_name, expected_sig_name);
87  assert_string_equal(txt, expected_sig_name);
88  } else {
89  if(data != NULL) {
90  assert_true(amxc_var_is_null(data));
91  }
92  }
93  count1++;
94 }
95 
96 static void test_slot2(const char* const sig_name,
97  const amxc_var_t* const data,
98  UNUSED void* const priv) {
99  if(expected_sig_name != NULL) {
100  assert_ptr_not_equal(data, NULL);
101  const char* txt = amxc_var_constcast(cstring_t, data);
102  assert_int_equal(amxc_var_type_of(data), AMXC_VAR_ID_CSTRING);
103  assert_ptr_not_equal(txt, NULL);
104  assert_string_equal(sig_name, expected_sig_name);
105  assert_string_equal(txt, expected_sig_name);
106  } else {
107  if(data != NULL) {
108  assert_true(amxc_var_is_null(data));
109  }
110  }
111 
112  count2++;
113 }
114 
115 void test_signal_new(UNUSED void** state) {
116  const amxc_htable_t* sigs = amxp_get_signals(NULL);
117  amxp_signal_t* sig1 = NULL;
118  amxp_signal_t* sig2 = NULL;
119  amxp_signal_t* sig3 = NULL;
120  assert_ptr_not_equal(sigs, NULL);
121  size_t nr_sigs = amxc_htable_size(sigs);
122 
123  assert_int_not_equal(amxp_signal_new(NULL, NULL, NULL), 0);
124  assert_int_not_equal(amxp_signal_new(NULL, &sig1, NULL), 0);
125  assert_int_not_equal(amxp_signal_new(NULL, NULL, "test:dummy"), 0);
126  assert_int_not_equal(amxp_signal_new(NULL, &sig1, ""), 0);
127  assert_int_equal(amxc_htable_size(sigs), nr_sigs + 0);
128 
129  assert_int_equal(amxp_signal_new(NULL, &sig1, "test:signal1"), 0);
130  assert_int_equal(amxc_htable_size(sigs), nr_sigs + 1);
131 
132  assert_int_not_equal(amxp_signal_new(NULL, &sig1, "test:signal2"), 0);
133  assert_int_equal(amxc_htable_size(sigs), nr_sigs + 1);
134 
135  assert_int_not_equal(amxp_signal_new(NULL, &sig2, "test:signal1"), 0);
136  assert_int_equal(amxc_htable_size(sigs), nr_sigs + 1);
137 
138  assert_int_equal(amxp_signal_new(NULL, &sig2, "test:signal2"), 0);
139  assert_int_equal(amxc_htable_size(sigs), nr_sigs + 2);
140 
141  assert_int_equal(amxp_signal_new(NULL, &sig3, "test:signal3"), 0);
142  assert_int_equal(amxc_htable_size(sigs), nr_sigs + 3);
143 
144  amxp_signal_delete(&sig1);
145  amxp_signal_delete(&sig2);
146  amxp_signal_delete(&sig3);
147 
148  assert_int_equal(amxc_htable_size(sigs), nr_sigs + 0);
149 }
150 
151 void test_signal_delete(UNUSED void** state) {
152  const amxc_htable_t* sigs = amxp_get_signals(NULL);
153  amxp_signal_t* sig1 = NULL;
154  amxp_signal_t* sig2 = NULL;
155  amxp_signal_t* sig3 = NULL;
156  assert_ptr_not_equal(sigs, NULL);
157  size_t nr_sigs = amxc_htable_size(sigs);
158 
159  assert_int_equal(amxp_signal_new(NULL, &sig1, "test:signal1"), 0);
160  assert_int_equal(amxp_signal_new(NULL, &sig2, "test:signal2"), 0);
161  assert_int_equal(amxp_signal_new(NULL, &sig3, "test:signal3"), 0);
162  assert_int_equal(amxc_htable_size(sigs), nr_sigs + 3);
163 
164  assert_int_not_equal(amxp_signal_delete(NULL), 0);
165  assert_int_equal(amxc_htable_size(sigs), nr_sigs + 3);
166  assert_int_equal(amxp_signal_delete(&sig1), 0);
167  assert_int_equal(amxc_htable_size(sigs), nr_sigs + 2);
168  assert_int_not_equal(amxp_signal_delete(&sig1), 0);
169  assert_int_equal(amxc_htable_size(sigs), nr_sigs + 2);
170 
171  amxp_signal_delete(&sig2);
172  assert_int_equal(amxc_htable_size(sigs), nr_sigs + 1);
173  amxp_signal_delete(&sig3);
174  assert_int_equal(amxc_htable_size(sigs), nr_sigs + 0);
175 
176 }
177 
178 void test_slot_connect(UNUSED void** state) {
179  const amxc_htable_t* sigs = amxp_get_signals(NULL);
180  amxp_signal_t* sig1 = NULL;
181  amxp_signal_t* sig3 = NULL;
182  assert_ptr_not_equal(sigs, NULL);
183 
184  assert_int_equal(amxp_signal_new(NULL, &sig1, "test:signal1"), 0);
185  assert_int_equal(amxp_signal_new(NULL, &sig3, "test:signal3"), 0);
186 
187  assert_int_not_equal(amxp_slot_connect(NULL, "not_existing", NULL, test_slot1, NULL), 0);
188  assert_int_not_equal(amxp_slot_connect(NULL, NULL, NULL, test_slot1, NULL), 0);
189  assert_int_not_equal(amxp_slot_connect(NULL, "", NULL, test_slot1, NULL), 0);
190  assert_int_not_equal(amxp_slot_connect(NULL, "test:signal1", NULL, NULL, NULL), 0);
191 
192  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot1, NULL), 0);
193  assert_int_equal(amxc_llist_size(&sig1->slots), 1);
194  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot1, NULL), 0);
195  assert_int_equal(amxc_llist_size(&sig1->slots), 1);
196  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot2, NULL), 0);
197  assert_int_equal(amxc_llist_size(&sig1->slots), 2);
198  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot2, NULL), 0);
199  assert_int_equal(amxc_llist_size(&sig1->slots), 2);
200 
201  assert_int_equal(amxc_llist_size(&sig3->slots), 0);
202  assert_int_equal(amxp_slot_connect(NULL, "test:signal3", NULL, test_slot1, NULL), 0);
203  assert_int_equal(amxc_llist_size(&sig3->slots), 1);
204  assert_int_equal(amxp_slot_connect(NULL, "test:signal3", NULL, test_slot2, NULL), 0);
205  assert_int_equal(amxc_llist_size(&sig3->slots), 2);
206  assert_int_equal(amxc_llist_size(&sig1->slots), 2);
207 
208  amxp_signal_delete(&sig1);
209  amxp_signal_delete(&sig3);
210 }
211 
212 void test_slot_connect_all(UNUSED void** state) {
213  const amxc_htable_t* sigs = amxp_get_signals(NULL);
214  amxp_signal_t* sig1 = NULL;
215  amxp_signal_t* sig2 = NULL;
216  amxp_signal_t* sig3 = NULL;
217  assert_ptr_not_equal(sigs, NULL);
218 
219  assert_int_equal(amxp_signal_new(NULL, &sig1, "test:signal1"), 0);
220  assert_int_equal(amxp_signal_new(NULL, &sig2, "test:signal2"), 0);
221 
222  assert_int_not_equal(amxp_slot_connect_all(NULL, NULL, NULL, NULL), 0);
223  assert_int_equal(amxp_slot_connect_all(NULL, NULL, test_slot1, NULL), 0);
224  assert_int_equal(amxc_llist_size(&sig1->slots), 1);
225  assert_int_equal(amxc_llist_size(&sig2->slots), 1);
226 
227  assert_int_equal(amxp_signal_new(NULL, &sig3, "test:signal3"), 0);
228  assert_int_equal(amxc_llist_size(&sig3->slots), 1);
229 
230  assert_int_equal(amxp_slot_connect_all(NULL, NULL, test_slot2, NULL), 0);
231  assert_int_equal(amxc_llist_size(&sig1->slots), 2);
232  assert_int_equal(amxc_llist_size(&sig2->slots), 2);
233  assert_int_equal(amxc_llist_size(&sig3->slots), 2);
234  amxp_signal_delete(&sig3);
235  assert_int_equal(amxc_llist_size(&sig1->slots), 2);
236  assert_int_equal(amxc_llist_size(&sig2->slots), 2);
237  assert_int_equal(amxp_signal_new(NULL, &sig3, "test:signal3"), 0);
238  assert_int_equal(amxc_llist_size(&sig3->slots), 2);
239 
240  amxp_slot_disconnect_all(test_slot1);
241  amxp_slot_disconnect_all(test_slot2);
242 
243  amxp_signal_trigger(sig1, NULL);
244  amxp_signal_trigger(sig2, NULL);
245  amxp_signal_trigger(sig3, NULL);
246  assert_int_equal(amxc_llist_size(&sig1->slots), 0);
247  assert_int_equal(amxc_llist_size(&sig2->slots), 0);
248 
249  assert_int_equal(amxp_slot_connect(NULL, "*", NULL, test_slot1, NULL), 0);
250  assert_int_equal(amxc_llist_size(&sig1->slots), 1);
251  assert_int_equal(amxc_llist_size(&sig2->slots), 1);
252  assert_int_equal(amxc_llist_size(&sig3->slots), 1);
253 
254  amxp_slot_disconnect_all(test_slot1);
255 
256  amxp_signal_delete(&sig1);
257  amxp_signal_delete(&sig2);
258  amxp_signal_delete(&sig3);
259 }
260 
261 void test_signal_trigger(UNUSED void** state) {
262  amxc_var_t var;
263  const amxc_htable_t* sigs = amxp_get_signals(NULL);
264  amxp_signal_t* sig1 = NULL;
265  amxp_signal_t* sig2 = NULL;
266  amxp_signal_t* sig3 = NULL;
267 
268  amxc_var_init(&var);
269 
270  assert_ptr_not_equal(sigs, NULL);
271 
272  assert_int_equal(amxp_signal_new(NULL, &sig1, "test:signal1"), 0);
273  assert_int_equal(amxp_signal_new(NULL, &sig2, "test:signal2"), 0);
274  assert_int_equal(amxp_signal_new(NULL, &sig3, "test:signal3"), 0);
275 
276  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot1, NULL), 0);
277  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot2, NULL), 0);
278  assert_int_equal(amxp_slot_connect(NULL, "test:signal2", NULL, test_slot1, NULL), 0);
279  assert_int_equal(amxp_slot_connect(NULL, "test:signal3", NULL, test_slot2, NULL), 0);
280 
281  count1 = 0;
282  count2 = 0;
283 
284  amxp_signal_trigger(NULL, NULL);
285  assert_int_equal(count1, 0);
286  assert_int_equal(count2, 0);
287 
288  expected_sig_name = NULL;
289  amxp_signal_trigger(sig1, NULL);
290  assert_int_equal(count1, 1);
291  assert_int_equal(count2, 1);
292 
293  expected_sig_name = amxp_signal_name(sig1);
294  amxc_var_set_cstring_t(&var, expected_sig_name);
295  amxp_signal_trigger(sig1, &var);
296  assert_int_equal(count1, 2);
297  assert_int_equal(count2, 2);
298 
299  expected_sig_name = amxp_signal_name(sig2);
300  amxc_var_set_cstring_t(&var, expected_sig_name);
301  amxp_signal_trigger(sig2, &var);
302  assert_int_equal(count1, 3);
303  assert_int_equal(count2, 2);
304 
305  expected_sig_name = amxp_signal_name(sig3);
306  amxc_var_set_cstring_t(&var, expected_sig_name);
307  amxp_signal_trigger(sig3, &var);
308  assert_int_equal(count1, 3);
309  assert_int_equal(count2, 3);
310 
311  amxp_signal_delete(&sig1);
312  amxp_signal_delete(&sig2);
313  amxp_signal_delete(&sig3);
314 
315  amxp_signal_trigger(sig3, &var);
316  assert_int_equal(count1, 3);
317  assert_int_equal(count2, 3);
318 
319  amxc_var_clean(&var);
320 }
321 
322 void test_signal_emit(UNUSED void** state) {
323  amxc_var_t var;
324  amxp_signal_t* sig1 = NULL;
325  amxp_signal_t* sig2 = NULL;
326  amxp_signal_t* sig3 = NULL;
327 
328  amxc_var_init(&var);
329 
330  assert_int_equal(amxp_signal_new(NULL, &sig1, "test:signal1"), 0);
331  assert_int_equal(amxp_signal_new(NULL, &sig2, "test:signal2"), 0);
332  assert_int_equal(amxp_signal_new(NULL, &sig3, "test:signal3"), 0);
333 
334  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot1, NULL), 0);
335  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot2, NULL), 0);
336  assert_int_equal(amxp_slot_connect(NULL, "test:signal2", NULL, test_slot1, NULL), 0);
337  assert_int_equal(amxp_slot_connect(NULL, "test:signal3", NULL, test_slot2, NULL), 0);
338 
339  count1 = 0;
340  count2 = 0;
341 
342  assert_int_not_equal(amxp_signal_fd(), -1);
343 
344  assert_int_not_equal(amxp_signal_emit(NULL, NULL), 0);
345  assert_int_equal(count1, 0);
346  assert_int_equal(count2, 0);
347 
348  expected_sig_name = NULL;
349  assert_int_equal(amxp_signal_emit(sig1, NULL), 0);
350  assert_int_equal(count1, 0);
351  assert_int_equal(count2, 0);
352  assert_int_equal(amxp_signal_read(), 0);
353  assert_int_equal(count1, 1);
354  assert_int_equal(count2, 1);
355 
356  expected_sig_name = amxp_signal_name(sig1);
357  amxc_var_set_cstring_t(&var, expected_sig_name);
358  assert_int_equal(amxp_signal_emit(sig1, &var), 0);
359  assert_int_equal(count1, 1);
360  assert_int_equal(count2, 1);
361  assert_int_equal(amxp_signal_read(), 0);
362  assert_int_equal(count1, 2);
363  assert_int_equal(count2, 2);
364 
365  expected_sig_name = amxp_signal_name(sig2);
366  amxc_var_set_cstring_t(&var, expected_sig_name);
367  assert_int_equal(amxp_signal_emit(sig2, &var), 0);
368  assert_int_equal(count1, 2);
369  assert_int_equal(count2, 2);
370  assert_int_equal(amxp_signal_read(), 0);
371  assert_int_equal(count1, 3);
372  assert_int_equal(count2, 2);
373 
374  expected_sig_name = amxp_signal_name(sig3);
375  amxc_var_set_cstring_t(&var, expected_sig_name);
376  assert_int_equal(amxp_signal_emit(sig3, &var), 0);
377  assert_int_equal(count1, 3);
378  assert_int_equal(count2, 2);
379  assert_int_equal(amxp_signal_read(), 0);
380  assert_int_equal(count1, 3);
381  assert_int_equal(count2, 3);
382 
383  assert_int_equal(amxp_signal_emit(sig3, &var), 0);
384  assert_int_equal(amxp_signal_emit(sig3, &var), 0);
385  assert_int_equal(count1, 3);
386  assert_int_equal(count2, 3);
387  assert_int_equal(amxp_signal_read(), 0);
388  assert_int_equal(amxp_signal_read(), 0);
389  assert_int_equal(count1, 3);
390  assert_int_equal(count2, 5);
391 
392  amxp_signal_delete(&sig1);
393  amxp_signal_delete(&sig2);
394  amxp_signal_delete(&sig3);
395 
396  assert_int_not_equal(amxp_signal_emit(sig3, &var), 0);
397  assert_int_equal(count1, 3);
398  assert_int_equal(count2, 5);
399 
400  amxc_var_clean(&var);
401 }
402 
403 void test_slot_disconnect(UNUSED void** state) {
404  amxc_var_t var;
405  amxp_signal_t* sig1 = NULL;
406 
407  amxc_var_init(&var);
408 
409  assert_int_equal(amxp_signal_new(NULL, &sig1, "test:signal1"), 0);
410 
411  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot1, NULL), 0);
412  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot2, NULL), 0);
413  assert_true(amxp_signal_has_slots(sig1));
414 
415  expected_sig_name = NULL;
416  count1 = 0;
417  count2 = 0;
418 
419  expected_sig_name = amxp_signal_name(sig1);
420  amxc_var_set_cstring_t(&var, expected_sig_name);
421  amxp_signal_trigger(sig1, &var);
422  assert_int_equal(count1, 1);
423  assert_int_equal(count2, 1);
424 
425  assert_int_equal(amxp_slot_disconnect(NULL, "test:signal1", test_slot1), 0);
426  assert_true(amxp_signal_has_slots(sig1));
427  amxp_signal_trigger(sig1, &var);
428  assert_int_equal(count1, 1);
429  assert_int_equal(count2, 2);
430 
431  assert_int_not_equal(amxp_slot_disconnect(NULL, "test:signal1", test_slot1), 0);
432  amxp_signal_trigger(sig1, &var);
433  assert_int_equal(count1, 1);
434  assert_int_equal(count2, 3);
435 
436  assert_int_equal(amxp_slot_disconnect(NULL, "test:signal1", test_slot2), 0);
437  assert_false(amxp_signal_has_slots(sig1));
438  amxp_signal_trigger(sig1, &var);
439  assert_int_equal(count1, 1);
440  assert_int_equal(count2, 3);
441 
442  assert_int_not_equal(amxp_slot_disconnect(NULL, "not_existing", test_slot2), 0);
443  assert_int_not_equal(amxp_slot_disconnect(NULL, NULL, test_slot2), 0);
444  assert_int_not_equal(amxp_slot_disconnect(NULL, "", test_slot2), 0);
445  assert_int_not_equal(amxp_slot_disconnect(NULL, "test:signal1", NULL), 0);
446 
447  amxp_signal_delete(&sig1);
448 
449  amxc_var_clean(&var);
450 }
451 
452 void test_signal_disconnect_all(UNUSED void** state) {
453  amxc_var_t var;
454  amxp_signal_t* sig1 = NULL;
455  amxp_signal_t* sig2 = NULL;
456 
457  amxc_var_init(&var);
458 
459  assert_int_equal(amxp_signal_new(NULL, &sig1, "test:signal1"), 0);
460  assert_int_equal(amxp_signal_new(NULL, &sig2, "test:signal2"), 0);
461 
462  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot1, NULL), 0);
463  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot2, NULL), 0);
464  assert_int_equal(amxp_slot_connect(NULL, "test:signal2", NULL, test_slot1, NULL), 0);
465 
466  expected_sig_name = NULL;
467  count1 = 0;
468  count2 = 0;
469 
470  expected_sig_name = amxp_signal_name(sig1);
471  amxc_var_set_cstring_t(&var, expected_sig_name);
472  amxp_signal_trigger(sig1, &var);
473  assert_int_equal(count1, 1);
474  assert_int_equal(count2, 1);
475 
476  assert_int_equal(amxp_signal_disconnect_all(sig1), 0);
477 
478  amxp_signal_trigger(sig1, &var);
479  assert_int_equal(count1, 1);
480  assert_int_equal(count2, 1);
481 
482  expected_sig_name = amxp_signal_name(sig2);
483  amxc_var_set_cstring_t(&var, expected_sig_name);
484  amxp_signal_trigger(sig2, &var);
485  assert_int_equal(count1, 2);
486  assert_int_equal(count2, 1);
487 
488  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot1, NULL), 0);
489  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot2, NULL), 0);
490  assert_int_equal(amxp_slot_connect(NULL, "test:signal2", NULL, test_slot1, NULL), 0);
491 
492  assert_int_not_equal(amxp_signal_disconnect_all(NULL), 0);
493 
494  amxp_signal_delete(&sig1);
495  amxp_signal_delete(&sig2);
496 
497  amxc_var_clean(&var);
498 }
499 
500 void test_slot_disconnect_all(UNUSED void** state) {
501  amxc_var_t var;
502  amxp_signal_t* sig1 = NULL;
503  amxp_signal_t* sig2 = NULL;
504 
505  amxc_var_init(&var);
506 
507  assert_int_equal(amxp_signal_new(NULL, &sig1, "test:signal1"), 0);
508  assert_int_equal(amxp_signal_new(NULL, &sig2, "test:signal2"), 0);
509 
510  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot1, NULL), 0);
511  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot2, NULL), 0);
512  assert_int_equal(amxp_slot_connect(NULL, "test:signal2", NULL, test_slot1, NULL), 0);
513 
514  expected_sig_name = NULL;
515  count1 = 0;
516  count2 = 0;
517 
518  expected_sig_name = amxp_signal_name(sig1);
519  amxc_var_set_cstring_t(&var, expected_sig_name);
520  amxp_signal_trigger(sig1, &var);
521  assert_int_equal(count1, 1);
522  assert_int_equal(count2, 1);
523 
524  expected_sig_name = amxp_signal_name(sig2);
525  amxc_var_set_cstring_t(&var, expected_sig_name);
526  amxp_signal_trigger(sig2, &var);
527  assert_int_equal(count1, 2);
528  assert_int_equal(count2, 1);
529 
530  amxp_slot_disconnect_all(test_slot1);
531 
532  expected_sig_name = amxp_signal_name(sig1);
533  amxc_var_set_cstring_t(&var, expected_sig_name);
534  amxp_signal_trigger(sig1, &var);
535  assert_int_equal(count1, 2);
536  assert_int_equal(count2, 2);
537 
538  expected_sig_name = amxp_signal_name(sig2);
539  amxc_var_set_cstring_t(&var, expected_sig_name);
540  amxp_signal_trigger(sig2, &var);
541  assert_int_equal(count1, 2);
542  assert_int_equal(count2, 2);
543 
544  amxp_signal_delete(&sig1);
545  amxp_signal_delete(&sig2);
546 
547  amxc_var_clean(&var);
548 }
549 
550 void test_slot_disconnect_all2(UNUSED void** state) {
551  amxc_var_t var;
552  amxp_signal_t* sig1 = NULL;
553  amxp_signal_t* sig2 = NULL;
554 
555  amxc_var_init(&var);
556 
557  assert_int_equal(amxp_signal_new(NULL, &sig1, "test:signal1"), 0);
558  assert_int_equal(amxp_signal_new(NULL, &sig2, "test:signal2"), 0);
559 
560  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot1, NULL), 0);
561  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot2, NULL), 0);
562  assert_int_equal(amxp_slot_connect(NULL, "test:signal2", NULL, test_slot1, NULL), 0);
563 
564  expected_sig_name = NULL;
565  count1 = 0;
566  count2 = 0;
567 
568  expected_sig_name = amxp_signal_name(sig1);
569  amxc_var_set_cstring_t(&var, expected_sig_name);
570  amxp_signal_trigger(sig1, &var);
571  assert_int_equal(count1, 1);
572  assert_int_equal(count2, 1);
573 
574  expected_sig_name = amxp_signal_name(sig2);
575  amxc_var_set_cstring_t(&var, expected_sig_name);
576  amxp_signal_trigger(sig2, &var);
577  assert_int_equal(count1, 2);
578  assert_int_equal(count2, 1);
579 
580  amxp_slot_disconnect(NULL, "*", test_slot1);
581 
582  expected_sig_name = amxp_signal_name(sig1);
583  amxc_var_set_cstring_t(&var, expected_sig_name);
584  amxp_signal_trigger(sig1, &var);
585  assert_int_equal(count1, 2);
586  assert_int_equal(count2, 2);
587 
588  expected_sig_name = amxp_signal_name(sig2);
589  amxc_var_set_cstring_t(&var, expected_sig_name);
590  amxp_signal_trigger(sig2, &var);
591  assert_int_equal(count1, 2);
592  assert_int_equal(count2, 2);
593 
594  amxp_signal_delete(&sig1);
595  amxp_signal_delete(&sig2);
596 
597  amxc_var_clean(&var);
598 }
599 
600 // make sure this is the last test
601 void test_signal_slot_verify_cleanup(UNUSED void** state) {
602  amxp_signal_t* sig1 = NULL;
603  amxp_signal_t* sig2 = NULL;
604  assert_int_equal(amxp_signal_new(NULL, &sig1, "test:signal1"), 0);
605  assert_int_equal(amxp_signal_new(NULL, &sig2, "test:signal2"), 0);
606  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot1, NULL), 0);
607  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_slot2, NULL), 0);
608  assert_int_equal(amxp_slot_connect(NULL, "test:signal2", NULL, test_slot1, NULL), 0);
609 
610  assert_int_equal(amxp_signal_emit(sig1, NULL), 0);
611  assert_int_equal(amxp_signal_emit(sig2, NULL), 0);
612  assert_int_equal(amxp_signal_emit(sig1, NULL), 0);
613 }
amxp_signal.h
Ambiorix signal manager and signal API header file.
amxp_signal_priv.h
amxp_get_signals
const amxc_htable_t PRIVATE * amxp_get_signals(const amxp_signal_mngr_t *sig_mngr)
Definition: amxp_signal.c:325
amxp_slot.h
Ambiorix slot API header file.
UNUSED
#define UNUSED
Definition: main.c:68
amxp_signal_has_slots
bool amxp_signal_has_slots(const amxp_signal_t *const signal)
Checks if the signal has slots conencted.
Definition: amxp_signal.c:821
amxp_signal_read
int amxp_signal_read(void)
Reads from the amxp signal file descriptor.
Definition: amxp_signal.c:769
amxp_signal_name
const char * amxp_signal_name(const amxp_signal_t *const signal)
Gets the name of the signal.
Definition: amxp_signal.c:817
amxp_signal_new
int amxp_signal_new(amxp_signal_mngr_t *sig_mngr, amxp_signal_t **signal, const char *name)
Constructor function, creates a new signal.
Definition: amxp_signal.c:620
amxp_signal_trigger
void amxp_signal_trigger(amxp_signal_t *const signal, const amxc_var_t *const data)
Triggers a signal.
Definition: amxp_signal.c:691
amxp_signal_emit
int amxp_signal_emit(const amxp_signal_t *const signal, const amxc_var_t *const data)
Emits a signal.
Definition: amxp_signal.c:742
amxp_signal_fd
int amxp_signal_fd(void)
Gets the amxp signal file descriptor.
Definition: amxp_signal.c:841
amxp_signal_disconnect_all
int amxp_signal_disconnect_all(amxp_signal_t *const signal)
Disconnects all slots from the signal.
Definition: amxp_signal.c:806
amxp_signal_delete
int amxp_signal_delete(amxp_signal_t **signal)
Destructor function, deletes a signal.
Definition: amxp_signal.c:669
amxp_slot_disconnect_all
void amxp_slot_disconnect_all(amxp_slot_fn_t fn)
Disconnects a slot from all signals it was connected to.
Definition: amxp_slot.c:459
amxp_slot_connect_all
int amxp_slot_connect_all(const char *const sig_reg_exp, const char *const expression, amxp_slot_fn_t fn, void *const priv)
Connects a slot to all existing and future signals.
Definition: amxp_slot.c:353
amxp_slot_disconnect
int amxp_slot_disconnect(amxp_signal_mngr_t *const sig_mngr, const char *const sig_name, amxp_slot_fn_t fn)
Disconnects a slot from (a) signal(s).
Definition: amxp_slot.c:380
amxp_slot_connect
int amxp_slot_connect(amxp_signal_mngr_t *const sig_mngr, const char *const sig_name, const char *const expression, amxp_slot_fn_t fn, void *const priv)
Connects a slot (function) to a named signal of a signal manager.
Definition: amxp_slot.c:300
_amxp_signal
Structure containing the signal information.
Definition: amxp_signal.h:119
_amxp_signal::slots
amxc_llist_t slots
Definition: amxp_signal.h:121
test_slot_disconnect
void test_slot_disconnect(UNUSED void **state)
Definition: test_signal_slots_global.c:403
test_slot2
static void test_slot2(const char *const sig_name, const amxc_var_t *const data, UNUSED void *const priv)
Definition: test_signal_slots_global.c:96
test_slot_connect_all
void test_slot_connect_all(UNUSED void **state)
Definition: test_signal_slots_global.c:212
count2
static int count2
Definition: test_signal_slots_global.c:75
expected_sig_name
static const char * expected_sig_name
Definition: test_signal_slots_global.c:73
test_signal_delete
void test_signal_delete(UNUSED void **state)
Definition: test_signal_slots_global.c:151
test_slot_connect
void test_slot_connect(UNUSED void **state)
Definition: test_signal_slots_global.c:178
test_signal_slot_verify_cleanup
void test_signal_slot_verify_cleanup(UNUSED void **state)
Definition: test_signal_slots_global.c:601
test_signal_disconnect_all
void test_signal_disconnect_all(UNUSED void **state)
Definition: test_signal_slots_global.c:452
count1
static int count1
Definition: test_signal_slots_global.c:74
test_slot1
static void test_slot1(const char *const sig_name, const amxc_var_t *const data, UNUSED void *const priv)
Definition: test_signal_slots_global.c:78
test_slot_disconnect_all2
void test_slot_disconnect_all2(UNUSED void **state)
Definition: test_signal_slots_global.c:550
test_signal_trigger
void test_signal_trigger(UNUSED void **state)
Definition: test_signal_slots_global.c:261
test_slot_disconnect_all
void test_slot_disconnect_all(UNUSED void **state)
Definition: test_signal_slots_global.c:500
test_signal_new
void test_signal_new(UNUSED void **state)
Definition: test_signal_slots_global.c:115
test_signal_emit
void test_signal_emit(UNUSED void **state)
Definition: test_signal_slots_global.c:322
test_signal_slots_global.h
sig2
static amxp_signal_t * sig2
Definition: test_signal_slots_recursive.c:75
sig1
static amxp_signal_t * sig1
Definition: test_signal_slots_recursive.c:74