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

Go to the source code of this file.

Functions

static void test_slot_delete_sigmngr (UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
 
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)
 
static void test_slot_check_deleted_sigmngr (UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
 
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)
 
static void test_delete_signal_slot (const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
 
static void test_delete_signal_slot2 (const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
 
static void test_slot_disconnect_all (UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
 
static void test_slot_remove_signal (const char *const sig_name, UNUSED const amxc_var_t *const data, UNUSED void *const priv)
 
static void test_deferred_func (UNUSED const amxc_var_t *const data, void *const priv)
 
static void test_deferred_func_remove_sigmngr (UNUSED const amxc_var_t *const data, void *const priv)
 
static void handle_events (void)
 
void test_sigmngr_new_delete (UNUSED void **state)
 
void test_sigmngr_delete_pending_sigs (UNUSED void **state)
 
void test_sigmngr_trigger (UNUSED void **state)
 
void test_sigmngr_emit (UNUSED void **state)
 
void test_sigmngr_suspend_resume (UNUSED void **state)
 
void test_sigmngr_connect_all (UNUSED void **state)
 
void test_sigmngr_connect_all2 (UNUSED void **state)
 
void test_sigmngr_disconnect_all_1 (UNUSED void **state)
 
void test_sigmngr_disconnect_all_2 (UNUSED void **state)
 
void test_sigmngr_add_remove_signal (UNUSED void **state)
 
void test_sigmngr_crash_connect_not_existing_signal (UNUSED void **state)
 
void test_sigmngr_find_signal (UNUSED void **state)
 
void test_signal_has_slots (UNUSED void **state)
 
void test_slot_disconnect_priv (UNUSED void **state)
 
void test_does_not_crash_with_rogue_signal (UNUSED void **state)
 
void test_sigmngr_disable (UNUSED void **state)
 
void test_sigmngr_trigger_unknown_signal_should_not_segfault (UNUSED void **state)
 
void test_removing_signal_in_slot (UNUSED void **state)
 
void test_delete_sigmngr_in_slot (UNUSED void **state)
 
void test_deferred_call (UNUSED void **state)
 
void test_deferred_call_delete_sigmngr (UNUSED void **state)
 
void test_can_disconnect_in_slot (UNUSED void **state)
 
void test_can_delete_signal_in_slot (UNUSED void **state)
 
void test_can_delete_signal_in_multiple_slots (UNUSED void **state)
 
void test_can_trigger_non_registered_signal (UNUSED void **state)
 
void test_delete_sigmngr_in_regexp_slot (UNUSED void **state)
 
void test_delete_sigmngr_in_slot_and_trigger_slot (UNUSED void **state)
 

Variables

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

Function Documentation

◆ handle_events()

static void handle_events ( void  )
static

Definition at line 182 of file test_signal_slots_sigmngr.c.

182  {
183  printf("Handling events ");
184  while(amxp_signal_read() == 0) {
185  printf(".");
186  }
187  printf("\n");
188 }
amxp_signal_read
int amxp_signal_read(void)
Reads from the amxp signal file descriptor.
Definition: amxp_signal.c:769

◆ test_can_delete_signal_in_multiple_slots()

void test_can_delete_signal_in_multiple_slots ( UNUSED void **  state)

Definition at line 964 of file test_signal_slots_sigmngr.c.

964  {
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 }
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_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_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_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
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_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_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_can_delete_signal_in_slot()

void test_can_delete_signal_in_slot ( UNUSED void **  state)

Definition at line 950 of file test_signal_slots_sigmngr.c.

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

◆ test_can_disconnect_in_slot()

void test_can_disconnect_in_slot ( UNUSED void **  state)

Definition at line 920 of file test_signal_slots_sigmngr.c.

920  {
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 }
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_delete
int amxp_sigmngr_delete(amxp_signal_mngr_t **sig_mngr)
Destructor function, deletes a signal manager instance.
Definition: amxp_signal.c:349
_amxp_signal_mngr
Structure containing the signal manager information.
Definition: amxp_signal.h:103
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
count2
static int count2
Definition: test_signal_slots_sigmngr.c:79
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
count1
static int count1
Definition: test_signal_slots_sigmngr.c:78
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_can_trigger_non_registered_signal()

void test_can_trigger_non_registered_signal ( UNUSED void **  state)

Definition at line 980 of file test_signal_slots_sigmngr.c.

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

◆ test_deferred_call()

void test_deferred_call ( UNUSED void **  state)

Definition at line 881 of file test_signal_slots_sigmngr.c.

881  {
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 }
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
my_sigmngr
amxp_signal_mngr_t * my_sigmngr
Definition: test_signal_slots_sigmngr.c:81
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
handle_events
static void handle_events(void)
Definition: test_signal_slots_sigmngr.c:182

◆ test_deferred_call_delete_sigmngr()

void test_deferred_call_delete_sigmngr ( UNUSED void **  state)

Definition at line 905 of file test_signal_slots_sigmngr.c.

905  {
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 }
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_deferred_func()

static void test_deferred_func ( UNUSED const amxc_var_t *const  data,
void *const  priv 
)
static

Definition at line 171 of file test_signal_slots_sigmngr.c.

172  {
173  check_expected(priv);
174 }

◆ test_deferred_func_remove_sigmngr()

static void test_deferred_func_remove_sigmngr ( UNUSED const amxc_var_t *const  data,
void *const  priv 
)
static

Definition at line 176 of file test_signal_slots_sigmngr.c.

177  {
178  check_expected(priv);
179  amxp_sigmngr_delete(&my_sigmngr);
180 }

◆ 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 
)
static

Definition at line 89 of file test_signal_slots_sigmngr.c.

91  {
92  amxp_sigmngr_delete(&my_sigmngr);
93  amxp_sigmngr_trigger_signal(my_sigmngr, "test:signal2", NULL);
94 }

◆ test_delete_sigmngr_in_regexp_slot()

void test_delete_sigmngr_in_regexp_slot ( UNUSED void **  state)

Definition at line 994 of file test_signal_slots_sigmngr.c.

994  {
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 }
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_delete_sigmngr_in_slot()

void test_delete_sigmngr_in_slot ( UNUSED void **  state)

Definition at line 858 of file test_signal_slots_sigmngr.c.

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

◆ test_delete_sigmngr_in_slot_and_trigger_slot()

void test_delete_sigmngr_in_slot_and_trigger_slot ( UNUSED void **  state)

Definition at line 1003 of file test_signal_slots_sigmngr.c.

1003  {
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 }
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_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 
)
static

Definition at line 139 of file test_signal_slots_sigmngr.c.

141  {
142  amxp_signal_t* sig = amxp_sigmngr_find_signal(NULL, sig_name);
143  amxp_signal_delete(&sig);
144 }
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_signal_delete
int amxp_signal_delete(amxp_signal_t **signal)
Destructor function, deletes a signal.
Definition: amxp_signal.c:669

◆ 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 
)
static

Definition at line 146 of file test_signal_slots_sigmngr.c.

148  {
149  amxp_signal_t* sig = amxp_sigmngr_find_signal(NULL, sig_name);
150  amxp_signal_delete(&sig);
151 }

◆ test_does_not_crash_with_rogue_signal()

void test_does_not_crash_with_rogue_signal ( UNUSED void **  state)

Definition at line 802 of file test_signal_slots_sigmngr.c.

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

◆ test_removing_signal_in_slot()

void test_removing_signal_in_slot ( UNUSED void **  state)

Definition at line 841 of file test_signal_slots_sigmngr.c.

841  {
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 }
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_add_remove_signal()

void test_sigmngr_add_remove_signal ( UNUSED void **  state)

Definition at line 668 of file test_signal_slots_sigmngr.c.

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

◆ test_sigmngr_connect_all()

void test_sigmngr_connect_all ( UNUSED void **  state)

Definition at line 439 of file test_signal_slots_sigmngr.c.

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

◆ test_sigmngr_connect_all2()

void test_sigmngr_connect_all2 ( UNUSED void **  state)

Definition at line 484 of file test_signal_slots_sigmngr.c.

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

◆ test_sigmngr_crash_connect_not_existing_signal()

void test_sigmngr_crash_connect_not_existing_signal ( UNUSED void **  state)

Definition at line 709 of file test_signal_slots_sigmngr.c.

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

◆ test_sigmngr_delete_pending_sigs()

void test_sigmngr_delete_pending_sigs ( UNUSED void **  state)

Definition at line 218 of file test_signal_slots_sigmngr.c.

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

◆ test_sigmngr_disable()

void test_sigmngr_disable ( UNUSED void **  state)

Definition at line 811 of file test_signal_slots_sigmngr.c.

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

◆ test_sigmngr_disconnect_all_1()

void test_sigmngr_disconnect_all_1 ( UNUSED void **  state)

Definition at line 528 of file test_signal_slots_sigmngr.c.

528  {
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 }
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_sigmngr_disconnect_all_2()

void test_sigmngr_disconnect_all_2 ( UNUSED void **  state)

Definition at line 597 of file test_signal_slots_sigmngr.c.

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

◆ test_sigmngr_emit()

void test_sigmngr_emit ( UNUSED void **  state)

Definition at line 307 of file test_signal_slots_sigmngr.c.

307  {
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 }
amxp_signal_fd
int amxp_signal_fd(void)
Gets the amxp signal file descriptor.
Definition: amxp_signal.c:841
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

◆ test_sigmngr_find_signal()

void test_sigmngr_find_signal ( UNUSED void **  state)

Definition at line 719 of file test_signal_slots_sigmngr.c.

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

◆ test_sigmngr_new_delete()

void test_sigmngr_new_delete ( UNUSED void **  state)

Definition at line 190 of file test_signal_slots_sigmngr.c.

190  {
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 }
amxp_get_signals
const amxc_htable_t PRIVATE * amxp_get_signals(const amxp_signal_mngr_t *sig_mngr)
Definition: amxp_signal.c:325

◆ test_sigmngr_suspend_resume()

void test_sigmngr_suspend_resume ( UNUSED void **  state)

Definition at line 400 of file test_signal_slots_sigmngr.c.

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

◆ test_sigmngr_trigger()

void test_sigmngr_trigger ( UNUSED void **  state)

Definition at line 245 of file test_signal_slots_sigmngr.c.

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

◆ test_sigmngr_trigger_unknown_signal_should_not_segfault()

void test_sigmngr_trigger_unknown_signal_should_not_segfault ( UNUSED void **  state)

Definition at line 837 of file test_signal_slots_sigmngr.c.

837  {
838  amxp_sigmngr_trigger_signal(NULL, "NotExisiting", NULL);
839 }

◆ test_signal_has_slots()

void test_signal_has_slots ( UNUSED void **  state)

Definition at line 737 of file test_signal_slots_sigmngr.c.

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

◆ 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 102 of file test_signal_slots_sigmngr.c.

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

◆ 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 120 of file test_signal_slots_sigmngr.c.

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

◆ 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 
)
static

Definition at line 96 of file test_signal_slots_sigmngr.c.

98  {
99  amxp_sigmngr_delete(&my_sigmngr);
100 }

◆ 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 
)
static

Definition at line 83 of file test_signal_slots_sigmngr.c.

85  {
86  amxp_sigmngr_delete(&my_sigmngr);
87 }

◆ 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 
)
static

Definition at line 153 of file test_signal_slots_sigmngr.c.

155  {
156  amxp_slot_disconnect_all(test_slot_disconnect_all);
157  amxp_slot_disconnect_all(test_slot1);
158  amxp_slot_disconnect_all(test_slot2);
159 }

◆ test_slot_disconnect_priv()

void test_slot_disconnect_priv ( UNUSED void **  state)

Definition at line 755 of file test_signal_slots_sigmngr.c.

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

◆ 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 
)
static

Definition at line 161 of file test_signal_slots_sigmngr.c.

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

Variable Documentation

◆ count1

int count1 = 0
static

Definition at line 78 of file test_signal_slots_sigmngr.c.

◆ count2

int count2 = 0
static

Definition at line 79 of file test_signal_slots_sigmngr.c.

◆ expected_sig_name

const char* expected_sig_name = NULL
static

Definition at line 77 of file test_signal_slots_sigmngr.c.

◆ my_sigmngr

amxp_signal_mngr_t* my_sigmngr = NULL

Definition at line 81 of file test_signal_slots_sigmngr.c.