libamxp  1.4.0
Patterns C Implementation
Functions | Variables
test_signal_slots_global.c File Reference
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <fcntl.h>
#include <unistd.h>
#include <cmocka.h>
#include <amxc/amxc_variant.h>
#include <amxc/amxc_lqueue.h>
#include <amxp/amxp_signal.h>
#include <amxp/amxp_slot.h>
#include <amxp_signal_priv.h>
#include "test_signal_slots_global.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions

static void test_slot1 (const char *const sig_name, const amxc_var_t *const data, UNUSED void *const priv)
 
static void test_slot2 (const char *const sig_name, const amxc_var_t *const data, UNUSED void *const priv)
 
void test_signal_new (UNUSED void **state)
 
void test_signal_delete (UNUSED void **state)
 
void test_slot_connect (UNUSED void **state)
 
void test_slot_connect_all (UNUSED void **state)
 
void test_signal_trigger (UNUSED void **state)
 
void test_signal_emit (UNUSED void **state)
 
void test_slot_disconnect (UNUSED void **state)
 
void test_signal_disconnect_all (UNUSED void **state)
 
void test_slot_disconnect_all (UNUSED void **state)
 
void test_slot_disconnect_all2 (UNUSED void **state)
 
void test_signal_slot_verify_cleanup (UNUSED void **state)
 

Variables

static const char * expected_sig_name = NULL
 
static int count1 = 0
 
static int count2 = 0
 

Function Documentation

◆ test_signal_delete()

void test_signal_delete ( UNUSED void **  state)

Definition at line 151 of file test_signal_slots_global.c.

151  {
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 }
amxp_get_signals
const amxc_htable_t PRIVATE * amxp_get_signals(const amxp_signal_mngr_t *sig_mngr)
Definition: amxp_signal.c:325
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_delete
int amxp_signal_delete(amxp_signal_t **signal)
Destructor function, deletes a signal.
Definition: amxp_signal.c:669
_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_signal_disconnect_all()

void test_signal_disconnect_all ( UNUSED void **  state)

Definition at line 452 of file test_signal_slots_global.c.

452  {
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 }
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_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_disconnect_all
int amxp_signal_disconnect_all(amxp_signal_t *const signal)
Disconnects all slots from the signal.
Definition: amxp_signal.c:806
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
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
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
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_signal_emit()

void test_signal_emit ( UNUSED void **  state)

Definition at line 322 of file test_signal_slots_global.c.

322  {
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 }
amxp_signal_read
int amxp_signal_read(void)
Reads from the amxp signal file descriptor.
Definition: amxp_signal.c:769
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

◆ test_signal_new()

void test_signal_new ( UNUSED void **  state)

Definition at line 115 of file test_signal_slots_global.c.

115  {
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 }

◆ test_signal_slot_verify_cleanup()

void test_signal_slot_verify_cleanup ( UNUSED void **  state)

Definition at line 601 of file test_signal_slots_global.c.

601  {
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 }

◆ test_signal_trigger()

void test_signal_trigger ( UNUSED void **  state)

Definition at line 261 of file test_signal_slots_global.c.

261  {
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 }

◆ test_slot1()

static void test_slot1 ( const char *const  sig_name,
const amxc_var_t *const  data,
UNUSED void *const  priv 
)
static

Definition at line 78 of file test_signal_slots_global.c.

80  {
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 }

◆ test_slot2()

static void test_slot2 ( const char *const  sig_name,
const amxc_var_t *const  data,
UNUSED void *const  priv 
)
static

Definition at line 96 of file test_signal_slots_global.c.

98  {
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 }

◆ test_slot_connect()

void test_slot_connect ( UNUSED void **  state)

Definition at line 178 of file test_signal_slots_global.c.

178  {
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 }
_amxp_signal::slots
amxc_llist_t slots
Definition: amxp_signal.h:121

◆ test_slot_connect_all()

void test_slot_connect_all ( UNUSED void **  state)

Definition at line 212 of file test_signal_slots_global.c.

212  {
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 }
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

◆ test_slot_disconnect()

void test_slot_disconnect ( UNUSED void **  state)

Definition at line 403 of file test_signal_slots_global.c.

403  {
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 }
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_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

◆ test_slot_disconnect_all()

void test_slot_disconnect_all ( UNUSED void **  state)

Definition at line 500 of file test_signal_slots_global.c.

500  {
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 }

◆ test_slot_disconnect_all2()

void test_slot_disconnect_all2 ( UNUSED void **  state)

Definition at line 550 of file test_signal_slots_global.c.

550  {
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 }

Variable Documentation

◆ count1

int count1 = 0
static

Definition at line 74 of file test_signal_slots_global.c.

◆ count2

int count2 = 0
static

Definition at line 75 of file test_signal_slots_global.c.

◆ expected_sig_name

const char* expected_sig_name = NULL
static

Definition at line 73 of file test_signal_slots_global.c.