libamxp  1.4.0
Patterns C Implementation
test_signal_slots_sigmngr.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 <string.h>
58 #include <stdarg.h>
59 #include <stddef.h>
60 #include <setjmp.h>
61 #include <fcntl.h>
62 #include <unistd.h>
63 #include <signal.h>
64 #include <cmocka.h>
65 
66 #include <amxc/amxc_variant.h>
67 #include <amxc/amxc_lqueue.h>
68 
69 #include <amxp/amxp_signal.h>
70 #include <amxp/amxp_syssig.h>
71 #include <amxp/amxp_slot.h>
72 #include <amxp_signal_priv.h>
73 
74 #include "test_signal_slots_sigmngr.h"
75 
76 #include <amxc/amxc_macros.h>
77 static const char* expected_sig_name = NULL;
78 static int count1 = 0;
79 static int count2 = 0;
80 
81 amxp_signal_mngr_t* my_sigmngr = NULL;
82 
83 static void test_slot_delete_sigmngr(UNUSED const char* const sig_name,
84  UNUSED const amxc_var_t* const data,
85  UNUSED void* const priv) {
86  amxp_sigmngr_delete(&my_sigmngr);
87 }
88 
89 static void test_delete_sigmngr_and_trigger_slot(UNUSED const char* const sig_name,
90  UNUSED const amxc_var_t* const data,
91  UNUSED void* const priv) {
92  amxp_sigmngr_delete(&my_sigmngr);
93  amxp_sigmngr_trigger_signal(my_sigmngr, "test:signal2", NULL);
94 }
95 
96 static void test_slot_check_deleted_sigmngr(UNUSED const char* const sig_name,
97  UNUSED const amxc_var_t* const data,
98  UNUSED void* const priv) {
99  amxp_sigmngr_delete(&my_sigmngr);
100 }
101 
102 static void test_slot1(const char* const sig_name,
103  const amxc_var_t* const data,
104  UNUSED void* const priv) {
105  if(expected_sig_name != NULL) {
106  assert_ptr_not_equal(data, NULL);
107  const char* txt = amxc_var_constcast(cstring_t, data);
108  assert_int_equal(amxc_var_type_of(data), AMXC_VAR_ID_CSTRING);
109  assert_ptr_not_equal(txt, NULL);
110  assert_string_equal(sig_name, expected_sig_name);
111  assert_string_equal(txt, expected_sig_name);
112  } else {
113  if(data != NULL) {
114  assert_true(amxc_var_is_null(data));
115  }
116  }
117  count1++;
118 }
119 
120 static void test_slot2(const char* const sig_name,
121  const amxc_var_t* const data,
122  UNUSED void* const priv) {
123  if(expected_sig_name != NULL) {
124  assert_ptr_not_equal(data, NULL);
125  const char* txt = amxc_var_constcast(cstring_t, data);
126  assert_int_equal(amxc_var_type_of(data), AMXC_VAR_ID_CSTRING);
127  assert_ptr_not_equal(txt, NULL);
128  assert_string_equal(sig_name, expected_sig_name);
129  assert_string_equal(txt, expected_sig_name);
130  } else {
131  if(data != NULL) {
132  assert_true(amxc_var_is_null(data));
133  }
134  }
135 
136  count2++;
137 }
138 
139 static void test_delete_signal_slot(const char* const sig_name,
140  UNUSED const amxc_var_t* const data,
141  UNUSED void* const priv) {
142  amxp_signal_t* sig = amxp_sigmngr_find_signal(NULL, sig_name);
143  amxp_signal_delete(&sig);
144 }
145 
146 static void test_delete_signal_slot2(const char* const sig_name,
147  UNUSED const amxc_var_t* const data,
148  UNUSED void* const priv) {
149  amxp_signal_t* sig = amxp_sigmngr_find_signal(NULL, sig_name);
150  amxp_signal_delete(&sig);
151 }
152 
153 static void test_slot_disconnect_all(UNUSED const char* const sig_name,
154  UNUSED const amxc_var_t* const data,
155  UNUSED void* const priv) {
156  amxp_slot_disconnect_all(test_slot_disconnect_all);
157  amxp_slot_disconnect_all(test_slot1);
158  amxp_slot_disconnect_all(test_slot2);
159 }
160 
161 static void test_slot_remove_signal(const char* const sig_name,
162  UNUSED const amxc_var_t* const data,
163  UNUSED void* const priv) {
164  amxp_signal_mngr_t* local_sigmngr = (amxp_signal_mngr_t*) priv;
165  amxp_signal_t* sig1 = amxp_sigmngr_find_signal(local_sigmngr, sig_name);
166 
167  assert_non_null(sig1);
168  amxp_sigmngr_remove_signal(local_sigmngr, sig_name);
169 }
170 
171 static void test_deferred_func(UNUSED const amxc_var_t* const data,
172  void* const priv) {
173  check_expected(priv);
174 }
175 
176 static void test_deferred_func_remove_sigmngr(UNUSED const amxc_var_t* const data,
177  void* const priv) {
178  check_expected(priv);
179  amxp_sigmngr_delete(&my_sigmngr);
180 }
181 
182 static void handle_events(void) {
183  printf("Handling events ");
184  while(amxp_signal_read() == 0) {
185  printf(".");
186  }
187  printf("\n");
188 }
189 
190 void test_sigmngr_new_delete(UNUSED void** state) {
191  amxp_signal_mngr_t* local_sigmngr = NULL;
192  const amxc_htable_t* lsigs = NULL;
193  const amxc_htable_t* gsigs = NULL;
194  amxp_signal_t* sig1 = NULL;
195 
196  assert_int_not_equal(amxp_sigmngr_new(NULL), 0);
197  assert_int_not_equal(amxp_sigmngr_delete(NULL), 0);
198  assert_int_not_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
199 
200  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
201  assert_ptr_not_equal(local_sigmngr, NULL);
202 
203  lsigs = amxp_get_signals(local_sigmngr);
204  gsigs = amxp_get_signals(NULL);
205 
206  assert_ptr_not_equal(lsigs, gsigs);
207  assert_int_equal(amxc_htable_size(lsigs), 0);
208  assert_int_equal(amxc_htable_size(gsigs), 6);
209 
210  assert_int_equal(amxp_signal_new(local_sigmngr, &sig1, "test:signal1"), 0);
211  assert_int_equal(amxc_htable_size(lsigs), 1);
212  assert_int_equal(amxc_htable_size(gsigs), 6);
213 
214  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
215  assert_ptr_equal(local_sigmngr, NULL);
216 }
217 
218 void test_sigmngr_delete_pending_sigs(UNUSED void** state) {
219  amxp_signal_mngr_t* local_sigmngr = NULL;
220  amxp_signal_t* sig1 = NULL;
221  amxp_signal_t* sig2 = NULL;
222  amxp_signal_t* sig3 = NULL;
223 
224  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
225  assert_ptr_not_equal(local_sigmngr, NULL);
226  assert_int_equal(amxp_signal_new(local_sigmngr, &sig1, "test:signal1"), 0);
227  assert_int_equal(amxp_signal_new(local_sigmngr, &sig2, "test:signal2"), 0);
228  assert_int_equal(amxp_signal_new(local_sigmngr, &sig3, "test:signal3"), 0);
229 
230  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot1, NULL), 0);
231  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot2, NULL), 0);
232  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal2", NULL, test_slot1, NULL), 0);
233  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal3", NULL, test_slot2, NULL), 0);
234 
235  assert_int_equal(amxp_signal_emit(sig1, NULL), 0);
236  assert_int_equal(amxp_signal_emit(sig2, NULL), 0);
237  assert_int_equal(amxp_signal_emit(sig3, NULL), 0);
238 
239  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
240  assert_ptr_equal(local_sigmngr, NULL);
241 
242  assert_int_not_equal(amxp_signal_read(), 0);
243 }
244 
245 void test_sigmngr_trigger(UNUSED void** state) {
246  amxp_signal_mngr_t* local_sigmngr = NULL;
247  amxp_signal_t* sig1 = NULL;
248  amxp_signal_t* sig2 = NULL;
249  amxp_signal_t* sig3 = NULL;
250 
251  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
252  assert_ptr_not_equal(local_sigmngr, NULL);
253  assert_int_equal(amxp_signal_new(local_sigmngr, &sig1, "test:signal1"), 0);
254  assert_int_equal(amxp_signal_new(local_sigmngr, &sig2, "test:signal2"), 0);
255  assert_int_equal(amxp_signal_new(NULL, &sig3, "test:signal3"), 0);
256 
257  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot1, NULL), 0);
258  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot2, NULL), 0);
259  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal2", NULL, test_slot1, NULL), 0);
260  assert_int_not_equal(amxp_slot_connect(local_sigmngr, "test:signal3", NULL, test_slot2, NULL), 0);
261  assert_int_equal(amxp_slot_connect(NULL, "test:signal3", NULL, test_slot2, NULL), 0);
262 
263  amxp_sigmngr_trigger_signal(local_sigmngr, NULL, NULL);
264  amxp_sigmngr_trigger_signal(local_sigmngr, "", NULL);
265  amxp_sigmngr_trigger_signal(local_sigmngr, "not-existing", NULL);
266 
267  count1 = 0;
268  count2 = 0;
269 
270  amxp_sigmngr_trigger_signal(local_sigmngr, "test:signal1", NULL);
271  assert_int_equal(count1, 1);
272  assert_int_equal(count2, 1);
273 
274  amxp_sigmngr_trigger_signal(local_sigmngr, "test:signal2", NULL);
275  assert_int_equal(count1, 2);
276  assert_int_equal(count2, 1);
277 
278  amxp_sigmngr_trigger_signal(NULL, "test:signal3", NULL);
279  assert_int_equal(count1, 2);
280  assert_int_equal(count2, 2);
281 
282  count1 = 0;
283  count2 = 0;
284 
285  amxp_signal_trigger(sig1, NULL);
286  assert_int_equal(count1, 1);
287  assert_int_equal(count2, 1);
288 
289  amxp_signal_trigger(sig2, NULL);
290  assert_int_equal(count1, 2);
291  assert_int_equal(count2, 1);
292 
293  amxp_signal_trigger(sig3, NULL);
294  assert_int_equal(count1, 2);
295  assert_int_equal(count2, 2);
296 
297  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
298  assert_ptr_equal(local_sigmngr, NULL);
299 
300  amxp_signal_trigger(sig3, NULL);
301  assert_int_equal(count1, 2);
302  assert_int_equal(count2, 3);
303 
304  amxp_signal_delete(&sig3);
305 }
306 
307 void test_sigmngr_emit(UNUSED void** state) {
308  amxp_signal_mngr_t* local_sigmngr = NULL;
309  amxp_signal_t* sig1 = NULL;
310  amxp_signal_t* sig2 = NULL;
311  amxp_signal_t* sig3 = NULL;
312  amxc_var_t var;
313 
314  amxc_var_init(&var);
315 
316  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
317  assert_ptr_not_equal(local_sigmngr, NULL);
318  assert_int_equal(amxp_signal_new(local_sigmngr, &sig1, "test:signal1"), 0);
319  assert_int_equal(amxp_signal_new(local_sigmngr, &sig2, "test:signal2"), 0);
320  assert_int_equal(amxp_signal_new(NULL, &sig3, "test:signal3"), 0);
321 
322  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot1, NULL), 0);
323  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot2, NULL), 0);
324  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal2", NULL, test_slot1, NULL), 0);
325  assert_int_not_equal(amxp_slot_connect(local_sigmngr, "test:signal3", NULL, test_slot2, NULL), 0);
326  assert_int_equal(amxp_slot_connect(NULL, "test:signal3", NULL, test_slot2, NULL), 0);
327 
328  count1 = 0;
329  count2 = 0;
330 
331  assert_int_not_equal(amxp_signal_fd(), -1);
332 
333  assert_int_not_equal(amxp_signal_emit(NULL, NULL), 0);
334  assert_int_equal(count1, 0);
335  assert_int_equal(count2, 0);
336  assert_int_not_equal(amxp_signal_read(), 0);
337 
338  expected_sig_name = NULL;
339  assert_int_equal(amxp_sigmngr_emit_signal(local_sigmngr, "test:signal1", NULL), 0);
340  assert_int_equal(count1, 0);
341  assert_int_equal(count2, 0);
342  assert_int_equal(amxp_signal_read(), 0);
343  assert_int_equal(count1, 1);
344  assert_int_equal(count2, 1);
345 
346  expected_sig_name = amxp_signal_name(sig1);
347  amxc_var_set_cstring_t(&var, expected_sig_name);
348  assert_int_equal(amxp_sigmngr_emit_signal(local_sigmngr, "test:signal1", &var), 0);
349  assert_int_equal(count1, 1);
350  assert_int_equal(count2, 1);
351  assert_int_equal(amxp_signal_read(), 0);
352  assert_int_equal(count1, 2);
353  assert_int_equal(count2, 2);
354 
355  expected_sig_name = amxp_signal_name(sig2);
356  amxc_var_set_cstring_t(&var, expected_sig_name);
357  assert_int_equal(amxp_sigmngr_emit_signal(local_sigmngr, "test:signal2", &var), 0);
358  assert_int_equal(count1, 2);
359  assert_int_equal(count2, 2);
360  assert_int_equal(amxp_signal_read(), 0);
361  assert_int_equal(count1, 3);
362  assert_int_equal(count2, 2);
363 
364  expected_sig_name = amxp_signal_name(sig3);
365  amxc_var_set_cstring_t(&var, expected_sig_name);
366  assert_int_not_equal(amxp_sigmngr_emit_signal(local_sigmngr, "test:signal3", &var), 0);
367  assert_int_equal(amxp_sigmngr_emit_signal(NULL, "test:signal3", &var), 0);
368  assert_int_equal(count1, 3);
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, 3);
373 
374  assert_int_not_equal(amxp_sigmngr_emit_signal(local_sigmngr, NULL, NULL), 0);
375  assert_int_not_equal(amxp_sigmngr_emit_signal(local_sigmngr, "", NULL), 0);
376 
377  assert_int_equal(amxp_sigmngr_emit_signal(local_sigmngr, "test:signal1", NULL), 0);
378  assert_int_equal(amxp_sigmngr_emit_signal(local_sigmngr, "test:signal1", &var), 0);
379  assert_int_equal(amxp_sigmngr_emit_signal(local_sigmngr, "test:signal2", &var), 0);
380  assert_int_equal(amxp_sigmngr_emit_signal(NULL, "test:signal3", &var), 0);
381 
382  amxp_signal_delete(&sig1);
383  amxp_signal_delete(&sig2);
384  amxp_signal_delete(&sig3);
385 
386  assert_int_equal(count1, 3);
387  assert_int_equal(count2, 3);
388  assert_int_not_equal(amxp_signal_read(), 0);
389  assert_int_equal(count1, 3);
390  assert_int_equal(count2, 3);
391 
392  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
393  assert_ptr_equal(local_sigmngr, NULL);
394 
395  assert_int_not_equal(amxp_signal_read(), 0);
396 
397  amxc_var_clean(&var);
398 }
399 
400 void test_sigmngr_suspend_resume(UNUSED void** state) {
401  amxp_signal_mngr_t* local_sigmngr = NULL;
402  amxp_signal_t* sig1 = NULL;
403  amxc_var_t var;
404 
405  amxc_var_init(&var);
406 
407  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
408  assert_ptr_not_equal(local_sigmngr, NULL);
409  assert_int_equal(amxp_signal_new(local_sigmngr, &sig1, "test:signal1"), 0);
410 
411  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot1, NULL), 0);
412 
413  count1 = 0;
414 
415  assert_int_not_equal(amxp_signal_fd(), -1);
416 
417  expected_sig_name = NULL;
418  assert_int_equal(amxp_sigmngr_emit_signal(local_sigmngr, "test:signal1", NULL), 0);
419  assert_int_equal(count1, 0);
420  assert_int_equal(amxp_signal_read(), 0);
421  assert_int_equal(count1, 1);
422 
423  expected_sig_name = NULL;
424  assert_int_equal(amxp_sigmngr_suspend(local_sigmngr), 0);
425  assert_int_equal(amxp_sigmngr_emit_signal(local_sigmngr, "test:signal1", NULL), 0);
426  assert_int_not_equal(amxp_signal_read(), 0);
427  assert_int_equal(count1, 1);
428  expected_sig_name = NULL;
429  assert_int_equal(amxp_sigmngr_resume(local_sigmngr), 0);
430  assert_int_equal(amxp_signal_read(), 0);
431  assert_int_equal(count1, 2);
432 
433  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
434  assert_ptr_equal(local_sigmngr, NULL);
435 
436  amxc_var_clean(&var);
437 }
438 
439 void test_sigmngr_connect_all(UNUSED void** state) {
440  amxc_var_t var;
441  amxp_signal_mngr_t* local_sigmngr = NULL;
442  amxp_signal_t* sig1 = NULL;
443  amxp_signal_t* sig2 = NULL;
444  amxp_signal_t* sig3 = NULL;
445 
446  amxc_var_init(&var);
447 
448  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
449  assert_ptr_not_equal(local_sigmngr, NULL);
450  assert_int_equal(amxp_signal_new(local_sigmngr, &sig1, "test:signal1"), 0);
451  assert_int_equal(amxp_signal_new(local_sigmngr, &sig2, "test:signal2"), 0);
452  assert_int_equal(amxp_signal_new(NULL, &sig3, "test:signal3"), 0);
453 
454  assert_int_equal(amxp_slot_connect(local_sigmngr, "*", NULL, test_slot1, NULL), 0);
455  assert_int_equal(amxp_slot_connect(NULL, "test:signal3", NULL, test_slot2, NULL), 0);
456 
457  count1 = 0;
458  count2 = 0;
459 
460  expected_sig_name = amxp_signal_name(sig1);
461  amxc_var_set_cstring_t(&var, expected_sig_name);
462  amxp_signal_trigger(sig1, &var);
463  assert_int_equal(count1, 1);
464  assert_int_equal(count2, 0);
465 
466  expected_sig_name = amxp_signal_name(sig2);
467  amxc_var_set_cstring_t(&var, expected_sig_name);
468  amxp_signal_trigger(sig2, &var);
469  assert_int_equal(count1, 2);
470  assert_int_equal(count2, 0);
471 
472  expected_sig_name = amxp_signal_name(sig3);
473  amxc_var_set_cstring_t(&var, expected_sig_name);
474  amxp_signal_trigger(sig3, &var);
475  assert_int_equal(count1, 2);
476  assert_int_equal(count2, 1);
477 
478  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
479  assert_ptr_equal(local_sigmngr, NULL);
480  amxp_signal_delete(&sig3);
481  amxc_var_clean(&var);
482 }
483 
484 void test_sigmngr_connect_all2(UNUSED void** state) {
485  amxc_var_t var;
486  amxp_signal_mngr_t* local_sigmngr = NULL;
487  amxp_signal_t* sig1 = NULL;
488  amxp_signal_t* sig2 = NULL;
489  amxp_signal_t* sig3 = NULL;
490 
491  amxc_var_init(&var);
492 
493  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
494  assert_ptr_not_equal(local_sigmngr, NULL);
495  assert_int_equal(amxp_signal_new(local_sigmngr, &sig1, "test:signal1"), 0);
496  assert_int_equal(amxp_signal_new(local_sigmngr, &sig2, "test:signal2"), 0);
497  assert_int_equal(amxp_signal_new(NULL, &sig3, "test:signal3"), 0);
498 
499  assert_int_equal(amxp_slot_connect(NULL, "*", NULL, test_slot1, NULL), 0);
500 
501  count1 = 0;
502  count2 = 0;
503 
504  expected_sig_name = amxp_signal_name(sig1);
505  amxc_var_set_cstring_t(&var, expected_sig_name);
506  amxp_signal_trigger(sig1, &var);
507  assert_int_equal(count1, 1);
508  assert_int_equal(count2, 0);
509 
510  expected_sig_name = amxp_signal_name(sig2);
511  amxc_var_set_cstring_t(&var, expected_sig_name);
512  amxp_signal_trigger(sig2, &var);
513  assert_int_equal(count1, 2);
514  assert_int_equal(count2, 0);
515 
516  expected_sig_name = amxp_signal_name(sig3);
517  amxc_var_set_cstring_t(&var, expected_sig_name);
518  amxp_signal_trigger(sig3, &var);
519  assert_int_equal(count1, 3);
520  assert_int_equal(count2, 0);
521 
522  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
523  assert_ptr_equal(local_sigmngr, NULL);
524  amxp_signal_delete(&sig3);
525  amxc_var_clean(&var);
526 }
527 
528 void test_sigmngr_disconnect_all_1(UNUSED void** state) {
529  amxc_var_t var;
530  amxp_signal_mngr_t* local_sigmngr = NULL;
531  amxp_signal_t* sig1 = NULL;
532  amxp_signal_t* sig2 = NULL;
533  amxp_signal_t* sig3 = NULL;
534 
535  amxc_var_init(&var);
536 
537  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
538  assert_ptr_not_equal(local_sigmngr, NULL);
539  assert_int_equal(amxp_signal_new(local_sigmngr, &sig1, "test:signal1"), 0);
540  assert_int_equal(amxp_signal_new(local_sigmngr, &sig2, "test:signal2"), 0);
541  assert_int_equal(amxp_signal_new(NULL, &sig3, "test:signal3"), 0);
542 
543  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot1, NULL), 0);
544  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal2", NULL, test_slot1, NULL), 0);
545  assert_int_equal(amxp_slot_connect(NULL, "test:signal3", NULL, test_slot1, NULL), 0);
546  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot2, NULL), 0);
547  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal2", NULL, test_slot2, NULL), 0);
548  assert_int_equal(amxp_slot_connect(NULL, "test:signal3", NULL, test_slot2, NULL), 0);
549 
550  count1 = 0;
551  count2 = 0;
552 
553  expected_sig_name = amxp_signal_name(sig1);
554  amxc_var_set_cstring_t(&var, expected_sig_name);
555  amxp_signal_trigger(sig1, &var);
556  assert_int_equal(count1, 1);
557  assert_int_equal(count2, 1);
558 
559  expected_sig_name = amxp_signal_name(sig2);
560  amxc_var_set_cstring_t(&var, expected_sig_name);
561  amxp_signal_trigger(sig2, &var);
562  assert_int_equal(count1, 2);
563  assert_int_equal(count2, 2);
564 
565  expected_sig_name = amxp_signal_name(sig3);
566  amxc_var_set_cstring_t(&var, expected_sig_name);
567  amxp_signal_trigger(sig3, &var);
568  assert_int_equal(count1, 3);
569  assert_int_equal(count2, 3);
570 
571  assert_int_equal(amxp_slot_disconnect(local_sigmngr, "*", test_slot1), 0);
572 
573  expected_sig_name = amxp_signal_name(sig1);
574  amxc_var_set_cstring_t(&var, expected_sig_name);
575  amxp_signal_trigger(sig1, &var);
576  assert_int_equal(count1, 3);
577  assert_int_equal(count2, 4);
578 
579  expected_sig_name = amxp_signal_name(sig2);
580  amxc_var_set_cstring_t(&var, expected_sig_name);
581  amxp_signal_trigger(sig2, &var);
582  assert_int_equal(count1, 3);
583  assert_int_equal(count2, 5);
584 
585  expected_sig_name = amxp_signal_name(sig3);
586  amxc_var_set_cstring_t(&var, expected_sig_name);
587  amxp_signal_trigger(sig3, &var);
588  assert_int_equal(count1, 4);
589  assert_int_equal(count2, 6);
590 
591  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
592  assert_ptr_equal(local_sigmngr, NULL);
593  amxp_signal_delete(&sig3);
594  amxc_var_clean(&var);
595 }
596 
597 void test_sigmngr_disconnect_all_2(UNUSED void** state) {
598  amxc_var_t var;
599  amxp_signal_mngr_t* local_sigmngr = NULL;
600  amxp_signal_t* sig1 = NULL;
601  amxp_signal_t* sig2 = NULL;
602  amxp_signal_t* sig3 = NULL;
603 
604  amxc_var_init(&var);
605 
606  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
607  assert_ptr_not_equal(local_sigmngr, NULL);
608  assert_int_equal(amxp_signal_new(local_sigmngr, &sig1, "test:signal1"), 0);
609  assert_int_equal(amxp_signal_new(local_sigmngr, &sig2, "test:signal2"), 0);
610  assert_int_equal(amxp_signal_new(NULL, &sig3, "test:signal3"), 0);
611 
612  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot1, NULL), 0);
613  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal2", NULL, test_slot1, NULL), 0);
614  assert_int_equal(amxp_slot_connect(NULL, "test:signal3", NULL, test_slot1, NULL), 0);
615  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot2, NULL), 0);
616  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal2", NULL, test_slot2, NULL), 0);
617  assert_int_equal(amxp_slot_connect(NULL, "test:signal3", NULL, test_slot2, NULL), 0);
618 
619  count1 = 0;
620  count2 = 0;
621 
622  expected_sig_name = amxp_signal_name(sig1);
623  amxc_var_set_cstring_t(&var, expected_sig_name);
624  amxp_signal_trigger(sig1, &var);
625  assert_int_equal(count1, 1);
626  assert_int_equal(count2, 1);
627 
628  expected_sig_name = amxp_signal_name(sig2);
629  amxc_var_set_cstring_t(&var, expected_sig_name);
630  amxp_signal_trigger(sig2, &var);
631  assert_int_equal(count1, 2);
632  assert_int_equal(count2, 2);
633 
634  expected_sig_name = amxp_signal_name(sig3);
635  amxc_var_set_cstring_t(&var, expected_sig_name);
636  amxp_signal_trigger(sig3, &var);
637  assert_int_equal(count1, 3);
638  assert_int_equal(count2, 3);
639 
640  amxp_slot_disconnect_all(test_slot1);
641 
642  expected_sig_name = amxp_signal_name(sig1);
643  amxc_var_set_cstring_t(&var, expected_sig_name);
644  amxp_signal_trigger(sig1, &var);
645  assert_int_equal(count1, 3);
646  assert_int_equal(count2, 4);
647 
648  expected_sig_name = amxp_signal_name(sig2);
649  amxc_var_set_cstring_t(&var, expected_sig_name);
650  amxp_signal_trigger(sig2, &var);
651  assert_int_equal(count1, 3);
652  assert_int_equal(count2, 5);
653 
654  expected_sig_name = amxp_signal_name(sig3);
655  amxc_var_set_cstring_t(&var, expected_sig_name);
656  amxp_signal_trigger(sig3, &var);
657  assert_int_equal(count1, 3);
658  assert_int_equal(count2, 6);
659 
660  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
661  assert_ptr_equal(local_sigmngr, NULL);
662  amxp_signal_delete(&sig3);
663  amxc_var_clean(&var);
664 
665  amxp_slot_disconnect_all(NULL);
666 }
667 
668 void test_sigmngr_add_remove_signal(UNUSED void** state) {
669  amxp_signal_mngr_t* local_sigmngr = NULL;
670  amxp_signal_t* sig = NULL;
671 
672  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
673 
674  assert_int_equal(amxp_sigmngr_add_signal(NULL, "test:signal1"), 0);
675  assert_int_not_equal(amxp_sigmngr_add_signal(local_sigmngr, NULL), 0);
676  assert_int_not_equal(amxp_sigmngr_add_signal(local_sigmngr, ""), 0);
677 
678  assert_int_equal(amxp_sigmngr_add_signal(local_sigmngr, "test:signal1"), 0);
679  assert_int_equal(amxp_sigmngr_add_signal(local_sigmngr, "test:signal2"), 0);
680  assert_int_equal(amxp_sigmngr_add_signal(local_sigmngr, "test:signal3"), 0);
681 
682  sig = amxp_sigmngr_find_signal(NULL, "test:signal1");
683  assert_int_equal(amxp_sigmngr_remove_signal(NULL, "test:signal1"), 0);
684  amxp_signal_delete(&sig);
685 
686  assert_int_not_equal(amxp_sigmngr_remove_signal(local_sigmngr, NULL), 0);
687  assert_int_not_equal(amxp_sigmngr_remove_signal(local_sigmngr, ""), 0);
688 
689  assert_int_not_equal(amxp_sigmngr_remove_signal(local_sigmngr, "test:signal4"), 0);
690 
691  sig = amxp_sigmngr_find_signal(local_sigmngr, "test:signal1");
692  assert_int_equal(amxp_sigmngr_remove_signal(local_sigmngr, "test:signal1"), 0);
693  amxp_signal_delete(&sig);
694 
695  sig = amxp_sigmngr_find_signal(local_sigmngr, "test:signal2");
696  assert_int_equal(amxp_sigmngr_remove_signal(local_sigmngr, "test:signal2"), 0);
697  amxp_signal_delete(&sig);
698 
699  sig = amxp_sigmngr_find_signal(local_sigmngr, "test:signal3");
700  assert_int_equal(amxp_sigmngr_remove_signal(local_sigmngr, "test:signal3"), 0);
701  amxp_signal_delete(&sig);
702 
703  assert_int_not_equal(amxp_sigmngr_remove_signal(local_sigmngr, "test:signal1"), 0);
704 
705  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
706  assert_ptr_equal(local_sigmngr, NULL);
707 }
708 
709 void test_sigmngr_crash_connect_not_existing_signal(UNUSED void** state) {
710  amxp_signal_mngr_t* local_sigmngr = NULL;
711 
712  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
713  assert_int_equal(amxp_sigmngr_add_signal(local_sigmngr, "mysignal"), 0);
714  assert_int_not_equal(amxp_slot_connect(local_sigmngr, "anothersignal", NULL, test_slot1, NULL), 0);
715  printf("%p\n", local_sigmngr);
716  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
717 }
718 
719 void test_sigmngr_find_signal(UNUSED void** state) {
720  amxp_signal_mngr_t* local_sigmngr = NULL;
721 
722  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
723 
724  assert_int_equal(amxp_sigmngr_add_signal(local_sigmngr, "test:signal1"), 0);
725  assert_int_equal(amxp_sigmngr_add_signal(local_sigmngr, "test:signal2"), 0);
726  assert_int_equal(amxp_sigmngr_add_signal(local_sigmngr, "test:signal3"), 0);
727 
728  assert_ptr_not_equal(amxp_sigmngr_find_signal(local_sigmngr, "test:signal1"), NULL);
729  assert_ptr_not_equal(amxp_sigmngr_find_signal(local_sigmngr, "test:signal3"), NULL);
730 
731  assert_ptr_equal(amxp_sigmngr_find_signal(local_sigmngr, ""), NULL);
732  assert_ptr_equal(amxp_sigmngr_find_signal(local_sigmngr, NULL), NULL);
733 
734  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
735 }
736 
737 void test_signal_has_slots(UNUSED void** state) {
738  amxp_signal_mngr_t* local_sigmngr = NULL;
739  amxp_signal_t* sig1 = NULL;
740 
741  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
742 
743  assert_int_equal(amxp_signal_new(local_sigmngr, &sig1, "test:signal1"), 0);
744  assert_int_equal(amxp_signal_disconnect_all(sig1), 0);
745 
746  assert_false(amxp_signal_has_slots(sig1));
747  assert_false(amxp_signal_has_slots(NULL));
748 
749  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot1, NULL), 0);
750  assert_true(amxp_signal_has_slots(sig1));
751 
752  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
753 }
754 
755 void test_slot_disconnect_priv(UNUSED void** state) {
756  amxp_signal_mngr_t* local_sigmngr = NULL;
757  amxp_signal_t* sig1 = NULL;
758  const char* priv = "PRIV DATA";
759 
760  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
761 
762  assert_int_equal(amxp_signal_new(local_sigmngr, &sig1, "test:signal1"), 0);
763 
764  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot1, (void*) priv), 0);
765 
766  count1 = 0;
767  expected_sig_name = NULL;
768  amxp_signal_trigger(sig1, NULL);
769  assert_int_equal(count1, 1);
770 
771  assert_int_equal(amxp_slot_disconnect_with_priv(local_sigmngr, NULL, (void*) priv), 0);
772 
773  count1 = 0;
774  expected_sig_name = NULL;
775  amxp_signal_trigger(sig1, NULL);
776  assert_int_equal(count1, 0);
777 
778  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot1, (void*) priv), 0);
779 
780  count1 = 0;
781  expected_sig_name = NULL;
782  amxp_signal_trigger(sig1, NULL);
783  assert_int_equal(count1, 1);
784 
785  assert_int_equal(amxp_slot_disconnect_with_priv(local_sigmngr, test_slot1, NULL), 0);
786  assert_int_equal(amxp_slot_disconnect_with_priv(local_sigmngr, test_slot2, (void*) priv), 0);
787 
788  count1 = 0;
789  expected_sig_name = NULL;
790  amxp_signal_trigger(sig1, NULL);
791  assert_int_equal(count1, 1);
792 
793  assert_int_equal(amxp_slot_disconnect_with_priv(local_sigmngr, test_slot1, (void*) priv), 0);
794  count1 = 0;
795  expected_sig_name = NULL;
796  amxp_signal_trigger(sig1, NULL);
797  assert_int_equal(count1, 0);
798 
799  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
800 }
801 
802 void test_does_not_crash_with_rogue_signal(UNUSED void** state) {
803  amxp_signal_t* sig1 = calloc(1, sizeof(amxp_signal_t));
804 
805  amxp_signal_trigger(sig1, NULL);
806  assert_int_not_equal(amxp_signal_emit(sig1, NULL), 0);
807 
808  free(sig1);
809 }
810 
811 void test_sigmngr_disable(UNUSED void** state) {
812  amxp_signal_mngr_t* local_sigmngr = NULL;
813  amxp_signal_t* sig1 = NULL;
814 
815  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
816  assert_ptr_not_equal(local_sigmngr, NULL);
817  assert_int_equal(amxp_signal_new(local_sigmngr, &sig1, "test:signal1"), 0);
818 
819  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot1, NULL), 0);
820 
821  count1 = 0;
822  expected_sig_name = NULL;
823  assert_int_equal(amxp_sigmngr_enable(local_sigmngr, false), 0);
824  amxp_signal_trigger(sig1, NULL);
825  assert_int_not_equal(amxp_signal_emit(sig1, NULL), 0);
826  assert_int_equal(count1, 0);
827 
828  assert_int_equal(amxp_sigmngr_enable(local_sigmngr, true), 0);
829  assert_int_not_equal(amxp_signal_read(), 0);
830  amxp_signal_trigger(sig1, NULL);
831  assert_int_equal(count1, 1);
832 
833  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
834  assert_ptr_equal(local_sigmngr, NULL);
835 }
836 
837 void test_sigmngr_trigger_unknown_signal_should_not_segfault(UNUSED void** state) {
838  amxp_sigmngr_trigger_signal(NULL, "NotExisiting", NULL);
839 }
840 
841 void test_removing_signal_in_slot(UNUSED void** state) {
842  amxp_signal_mngr_t* local_sigmngr = NULL;
843  amxp_signal_t* sig1 = NULL;
844 
845  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
846  assert_ptr_not_equal(local_sigmngr, NULL);
847  assert_int_equal(amxp_signal_new(local_sigmngr, &sig1, "test:signal1"), 0);
848 
849  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot_remove_signal, local_sigmngr), 0);
850  amxp_signal_trigger(sig1, NULL);
851 
852  sig1 = amxp_sigmngr_find_signal(local_sigmngr, "test:signal1");
853  assert_null(sig1);
854 
855  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
856 }
857 
858 void test_delete_sigmngr_in_slot(UNUSED void** state) {
859  amxp_signal_t* sig1 = NULL;
860 
861  assert_int_equal(amxp_sigmngr_new(&my_sigmngr), 0);
862  assert_ptr_not_equal(my_sigmngr, NULL);
863  assert_int_equal(amxp_signal_new(my_sigmngr, &sig1, "test:signal1"), 0);
864 
865  assert_int_equal(amxp_slot_connect(my_sigmngr, "test:signal1", NULL, test_slot_delete_sigmngr, NULL), 0);
866  assert_int_equal(amxp_slot_connect(my_sigmngr, "test:signal1", NULL, test_slot_check_deleted_sigmngr, NULL), 0);
867  amxp_signal_trigger(sig1, NULL);
868 
869  sig1 = NULL;
870  assert_null(my_sigmngr);
871 
872  assert_int_equal(amxp_sigmngr_new(&my_sigmngr), 0);
873  assert_ptr_not_equal(my_sigmngr, NULL);
874  assert_int_equal(amxp_signal_new(my_sigmngr, &sig1, "test:signal1"), 0);
875 
876  assert_int_equal(amxp_slot_connect(my_sigmngr, "test:signal1", NULL, test_slot_delete_sigmngr, NULL), 0);
877  assert_int_equal(amxp_slot_connect(my_sigmngr, "test:signal1", NULL, test_slot_check_deleted_sigmngr, NULL), 0);
878  amxp_sigmngr_trigger_signal(my_sigmngr, "test:signal1", NULL);
879 }
880 
881 void test_deferred_call(UNUSED void** state) {
882  amxc_var_t var_data;
883  char* data = calloc(1, 10);
884  strcpy(data, "abcdefg");
885 
886  amxc_var_init(&var_data);
887  amxc_var_set(cstring_t, &var_data, "Hello");
888 
889  assert_int_equal(amxp_sigmngr_new(&my_sigmngr), 0);
890  assert_ptr_not_equal(my_sigmngr, NULL);
891 
892  expect_memory(test_deferred_func, priv, data, 10);
893  assert_int_equal(amxp_sigmngr_deferred_call(my_sigmngr, test_deferred_func, NULL, (void*) data), 0);
894  handle_events();
895 
896  expect_memory(test_deferred_func, priv, data, 10);
897  assert_int_equal(amxp_sigmngr_deferred_call(my_sigmngr, test_deferred_func, &var_data, (void*) data), 0);
898  handle_events();
899 
900  free(data);
901  amxc_var_clean(&var_data);
902  assert_int_equal(amxp_sigmngr_delete(&my_sigmngr), 0);
903 }
904 
905 void test_deferred_call_delete_sigmngr(UNUSED void** state) {
906  char* data = calloc(1, 10);
907  strcpy(data, "abcdefg");
908 
909  assert_int_equal(amxp_sigmngr_new(&my_sigmngr), 0);
910  assert_ptr_not_equal(my_sigmngr, NULL);
911 
912  expect_memory(test_deferred_func_remove_sigmngr, priv, data, 10);
913  assert_int_equal(amxp_sigmngr_deferred_call(my_sigmngr, test_deferred_func_remove_sigmngr, NULL, (void*) data), 0);
914  handle_events();
915 
916  free(data);
917  assert_null(my_sigmngr);
918 }
919 
920 void test_can_disconnect_in_slot(UNUSED void** state) {
921  amxp_signal_mngr_t* local_sigmngr = NULL;
922  amxp_signal_t* sig1 = NULL;
923  const char* priv = "PRIV DATA";
924 
925  assert_int_equal(amxp_sigmngr_new(&local_sigmngr), 0);
926 
927  assert_int_equal(amxp_signal_new(local_sigmngr, &sig1, "test:signal1"), 0);
928 
929  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot1, NULL), 0);
930  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot_disconnect_all, (void*) priv), 0);
931  assert_int_equal(amxp_slot_connect(local_sigmngr, "test:signal1", NULL, test_slot2, NULL), 0);
932 
933  count1 = 0;
934  count2 = 0;
935  expected_sig_name = NULL;
936  amxp_signal_trigger(sig1, NULL);
937  assert_int_equal(count1, 1);
938  assert_int_equal(count2, 0);
939 
940  count1 = 0;
941  count2 = 0;
942  expected_sig_name = NULL;
943  amxp_signal_trigger(sig1, NULL);
944  assert_int_equal(count1, 0);
945  assert_int_equal(count2, 0);
946 
947  assert_int_equal(amxp_sigmngr_delete(&local_sigmngr), 0);
948 }
949 
950 void test_can_delete_signal_in_slot(UNUSED void** state) {
951  amxp_signal_t* sig1 = NULL;
952  amxp_signal_t* sig2 = NULL;
953 
954  assert_int_equal(amxp_signal_new(NULL, &sig1, "test:signal1"), 0);
955  assert_int_equal(amxp_signal_new(NULL, &sig2, "test:signal2"), 0);
956 
957  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_delete_signal_slot, NULL), 0);
958  assert_int_equal(amxp_slot_connect(NULL, "test:signal2", NULL, test_delete_signal_slot, NULL), 0);
959 
960  amxp_signal_trigger(sig1, NULL);
961  amxp_signal_trigger(sig2, NULL);
962 }
963 
964 void test_can_delete_signal_in_multiple_slots(UNUSED void** state) {
965  amxp_signal_t* sig1 = NULL;
966  amxp_signal_t* sig2 = NULL;
967 
968  assert_int_equal(amxp_signal_new(NULL, &sig1, "test:signal1"), 0);
969  assert_int_equal(amxp_signal_new(NULL, &sig2, "test:signal2"), 0);
970 
971  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_delete_signal_slot, NULL), 0);
972  assert_int_equal(amxp_slot_connect(NULL, "test:signal1", NULL, test_delete_signal_slot2, NULL), 0);
973  assert_int_equal(amxp_slot_connect(NULL, "test:signal2", NULL, test_delete_signal_slot, NULL), 0);
974  assert_int_equal(amxp_slot_connect_filtered(NULL, "^test:.*$", NULL, test_delete_signal_slot, NULL), 0);
975 
976  amxp_sigmngr_trigger_signal(NULL, "test:signal1", NULL);
977  amxp_sigmngr_trigger_signal(NULL, "test:signal2", NULL);
978 }
979 
980 void test_can_trigger_non_registered_signal(UNUSED void** state) {
981  assert_int_equal(amxp_slot_connect_filtered(NULL, "^test:.*", NULL, test_slot1, NULL), 0);
982 
983  count1 = 0;
984  count2 = 0;
985  expected_sig_name = NULL;
986 
987  amxp_sigmngr_trigger_signal(NULL, "test:signal1", NULL);
988  assert_int_equal(count1, 1);
989  assert_int_equal(count2, 0);
990 
991  amxp_slot_disconnect_all(test_slot1);
992 }
993 
994 void test_delete_sigmngr_in_regexp_slot(UNUSED void** state) {
995  assert_int_equal(amxp_sigmngr_new(&my_sigmngr), 0);
996  assert_ptr_not_equal(my_sigmngr, NULL);
997  assert_int_equal(amxp_slot_connect_filtered(my_sigmngr, "^test:.*", NULL, test_slot_delete_sigmngr, NULL), 0);
998 
999  amxp_sigmngr_trigger_signal(my_sigmngr, "test:signal1", NULL);
1000  assert_null(my_sigmngr);
1001 }
1002 
1003 void test_delete_sigmngr_in_slot_and_trigger_slot(UNUSED void** state) {
1004  amxp_signal_t* sig1 = NULL;
1005  amxp_signal_t* sig2 = NULL;
1006 
1007  assert_int_equal(amxp_sigmngr_new(&my_sigmngr), 0);
1008  assert_ptr_not_equal(my_sigmngr, NULL);
1009 
1010  assert_int_equal(amxp_signal_new(my_sigmngr, &sig1, "test:signal1"), 0);
1011  assert_int_equal(amxp_signal_new(my_sigmngr, &sig2, "test:signal2"), 0);
1012 
1013  assert_int_equal(amxp_slot_connect(my_sigmngr, "test:signal1", NULL, test_delete_sigmngr_and_trigger_slot, NULL), 0);
1014  assert_int_equal(amxp_slot_connect(my_sigmngr, "test:signal2", NULL, test_slot2, NULL), 0);
1015 
1016  amxp_sigmngr_trigger_signal(my_sigmngr, "test:signal1", NULL);
1017  assert_null(my_sigmngr);
1018 }
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.
amxp_syssig.h
Ambiorix Linux Signal Handling.
UNUSED
#define UNUSED
Definition: main.c:68
amxp_sigmngr_add_signal
int amxp_sigmngr_add_signal(amxp_signal_mngr_t *const sig_mngr, const char *name)
Adds a signal to a signal manager.
Definition: amxp_signal.c:433
amxp_sigmngr_new
int amxp_sigmngr_new(amxp_signal_mngr_t **sig_mngr)
Constructor function, creates a new signal manager instance.
Definition: amxp_signal.c:330
amxp_sigmngr_trigger_signal
void amxp_sigmngr_trigger_signal(amxp_signal_mngr_t *const sig_mngr, const char *name, const amxc_var_t *const data)
Triggers a signal.
Definition: amxp_signal.c:492
amxp_sigmngr_remove_signal
int amxp_sigmngr_remove_signal(amxp_signal_mngr_t *const sig_mngr, const char *name)
Removes a signal from a signal manager.
Definition: amxp_signal.c:448
amxp_sigmngr_find_signal
amxp_signal_t * amxp_sigmngr_find_signal(const amxp_signal_mngr_t *const sig_mngr, const char *name)
Get the pointer to the signal.
Definition: amxp_signal.c:475
amxp_sigmngr_delete
int amxp_sigmngr_delete(amxp_signal_mngr_t **sig_mngr)
Destructor function, deletes a signal manager instance.
Definition: amxp_signal.c:349
amxp_sigmngr_suspend
int amxp_sigmngr_suspend(amxp_signal_mngr_t *const sig_mngr)
Suspends the handling of signals for the signal manager.
Definition: amxp_signal.c:571
amxp_sigmngr_deferred_call
int amxp_sigmngr_deferred_call(amxp_signal_mngr_t *const sig_mngr, amxp_deferred_fn_t fn, const amxc_var_t *const data, void *priv)
Defers a function call.
Definition: amxp_signal.c:536
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_sigmngr_enable
int amxp_sigmngr_enable(amxp_signal_mngr_t *const sig_mngr, bool enable)
Enables or disables the signal manager.
Definition: amxp_signal.c:561
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_sigmngr_resume
int amxp_sigmngr_resume(amxp_signal_mngr_t *const sig_mngr)
Resumes the handling of signals for the signal manager.
Definition: amxp_signal.c:595
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_sigmngr_emit_signal
int amxp_sigmngr_emit_signal(const amxp_signal_mngr_t *const sig_mngr, const char *name, const amxc_var_t *const data)
Emits a signal.
Definition: amxp_signal.c:514
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_filtered
int amxp_slot_connect_filtered(amxp_signal_mngr_t *const sig_mngr, const char *const sig_reg_exp, const char *const expression, amxp_slot_fn_t fn, void *const priv)
Connects a slot (function) to signals using a regular expression.
Definition: amxp_slot.c:330
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_slot_disconnect_with_priv
int amxp_slot_disconnect_with_priv(amxp_signal_mngr_t *sig_mngr, amxp_slot_fn_t fn, void *priv)
Disconnects a slot from (a) signal(s).
Definition: amxp_slot.c:405
_amxp_signal_mngr
Structure containing the signal manager information.
Definition: amxp_signal.h:103
_amxp_signal
Structure containing the signal information.
Definition: amxp_signal.h:119
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
test_can_delete_signal_in_multiple_slots
void test_can_delete_signal_in_multiple_slots(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:964
test_sigmngr_add_remove_signal
void test_sigmngr_add_remove_signal(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:668
test_deferred_func_remove_sigmngr
static void test_deferred_func_remove_sigmngr(UNUSED const amxc_var_t *const data, void *const priv)
Definition: test_signal_slots_sigmngr.c:176
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_sigmngr.c:120
test_delete_signal_slot2
static void test_delete_signal_slot2(const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
Definition: test_signal_slots_sigmngr.c:146
test_slot_check_deleted_sigmngr
static void test_slot_check_deleted_sigmngr(UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
Definition: test_signal_slots_sigmngr.c:96
my_sigmngr
amxp_signal_mngr_t * my_sigmngr
Definition: test_signal_slots_sigmngr.c:81
test_signal_has_slots
void test_signal_has_slots(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:737
test_deferred_func
static void test_deferred_func(UNUSED const amxc_var_t *const data, void *const priv)
Definition: test_signal_slots_sigmngr.c:171
count2
static int count2
Definition: test_signal_slots_sigmngr.c:79
test_delete_sigmngr_in_slot
void test_delete_sigmngr_in_slot(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:858
test_sigmngr_connect_all2
void test_sigmngr_connect_all2(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:484
test_sigmngr_emit
void test_sigmngr_emit(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:307
test_slot_disconnect_all
static void test_slot_disconnect_all(UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
Definition: test_signal_slots_sigmngr.c:153
expected_sig_name
static const char * expected_sig_name
Definition: test_signal_slots_sigmngr.c:77
test_sigmngr_suspend_resume
void test_sigmngr_suspend_resume(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:400
test_deferred_call_delete_sigmngr
void test_deferred_call_delete_sigmngr(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:905
test_can_trigger_non_registered_signal
void test_can_trigger_non_registered_signal(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:980
test_removing_signal_in_slot
void test_removing_signal_in_slot(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:841
test_sigmngr_trigger
void test_sigmngr_trigger(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:245
test_delete_signal_slot
static void test_delete_signal_slot(const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
Definition: test_signal_slots_sigmngr.c:139
test_does_not_crash_with_rogue_signal
void test_does_not_crash_with_rogue_signal(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:802
test_sigmngr_find_signal
void test_sigmngr_find_signal(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:719
test_can_delete_signal_in_slot
void test_can_delete_signal_in_slot(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:950
test_slot_disconnect_priv
void test_slot_disconnect_priv(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:755
test_can_disconnect_in_slot
void test_can_disconnect_in_slot(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:920
test_sigmngr_disconnect_all_2
void test_sigmngr_disconnect_all_2(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:597
count1
static int count1
Definition: test_signal_slots_sigmngr.c:78
test_sigmngr_trigger_unknown_signal_should_not_segfault
void test_sigmngr_trigger_unknown_signal_should_not_segfault(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:837
test_sigmngr_crash_connect_not_existing_signal
void test_sigmngr_crash_connect_not_existing_signal(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:709
test_sigmngr_disconnect_all_1
void test_sigmngr_disconnect_all_1(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:528
test_sigmngr_new_delete
void test_sigmngr_new_delete(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:190
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_sigmngr.c:102
test_slot_delete_sigmngr
static void test_slot_delete_sigmngr(UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
Definition: test_signal_slots_sigmngr.c:83
test_sigmngr_connect_all
void test_sigmngr_connect_all(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:439
test_deferred_call
void test_deferred_call(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:881
test_delete_sigmngr_in_regexp_slot
void test_delete_sigmngr_in_regexp_slot(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:994
test_sigmngr_delete_pending_sigs
void test_sigmngr_delete_pending_sigs(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:218
test_delete_sigmngr_in_slot_and_trigger_slot
void test_delete_sigmngr_in_slot_and_trigger_slot(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:1003
test_delete_sigmngr_and_trigger_slot
static void test_delete_sigmngr_and_trigger_slot(UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
Definition: test_signal_slots_sigmngr.c:89
test_slot_remove_signal
static void test_slot_remove_signal(const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
Definition: test_signal_slots_sigmngr.c:161
test_sigmngr_disable
void test_sigmngr_disable(UNUSED void **state)
Definition: test_signal_slots_sigmngr.c:811
handle_events
static void handle_events(void)
Definition: test_signal_slots_sigmngr.c:182
test_signal_slots_sigmngr.h