test_amxd_object_event.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 <signal.h>
#include <cmocka.h>
#include <sys/signalfd.h>
#include <string.h>
#include <amxc/amxc.h>
#include <amxp/amxp_signal.h>
#include <amxp/amxp_slot.h>
#include <amxp/amxp_timer.h>
#include <amxd/amxd_common.h>
#include <amxd/amxd_dm.h>
#include <amxd/amxd_object.h>
#include <amxd/amxd_object_event.h>
#include <amxd/amxd_transaction.h>
#include "test_amxd_object_event.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions
static void	test_event_handler (UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, void *const priv)
static void	test_build_dm (void)
static int	read_sig_alarm (void)
int	test_object_event_setup (UNUSED void **state)
int	test_object_event_teardown (UNUSED void **state)
void	test_can_start_and_stop_periodic_inform (UNUSED void **state)
void	test_only_one_periodic_inform_per_object (UNUSED void **state)
void	test_timer_stops_when_object_is_destroyed (UNUSED void **state)
void	test_events_are_not_duplicated (UNUSED void **state)
void	test_can_allocate_event_data (UNUSED void **state)
void	test_allocate_event_data_fails_when_event_not_found (UNUSED void **state)
void	test_can_send_event (UNUSED void **state)
void	test_can_change_event_definition (UNUSED void **state)
void	test_can_remove_event_definition (UNUSED void **state)
void	test_event_changed_is_send (UNUSED void **state)

Variables
static amxd_dm_t	dm
static int	sfd
static sigset_t	mask

Function Documentation

read_sig_alarm()

static int read_sig_alarm ( void  )

static

Definition at line 133 of file test_amxd_object_event.c.

                                {
    while(1) {
        struct signalfd_siginfo si;
        ssize_t res;
        res = read(sfd, &si, sizeof(si));
        assert_false(res < 0);
        assert_false(res != sizeof(si));
        if(si.ssi_signo == SIGALRM) {
            amxp_timers_calculate();
            amxp_timers_check();
            break;
        }
    }
 
    while(amxp_signal_read() == 0) {
    }
 
    return 0;
}

test_allocate_event_data_fails_when_event_not_found()

void test_allocate_event_data_fails_when_event_not_found

(

UNUSED void **

state

)

Definition at line 329 of file test_amxd_object_event.c.

                                                                              {
    amxc_var_t* event_data = NULL;
    amxd_object_t* object = amxd_dm_findf(&dm, "MyRootObject.MyChildObject2.");
    assert_non_null(object);
 
    event_data = amxd_object_new_event_data(object, "MyEvent3!");
    assert_null(event_data);
 
    event_data = amxd_object_new_event_data(object, NULL);
    assert_null(event_data);
 
    event_data = amxd_object_new_event_data(object, "");
    assert_null(event_data);
 
    event_data = amxd_object_new_event_data(NULL, "MyEvent2!");
    assert_null(event_data);
}

test_build_dm()

static void test_build_dm ( void  )

static

Definition at line 95 of file test_amxd_object_event.c.

                                {
    amxd_object_t* object = NULL;
    amxd_object_t* child_object = NULL;
    amxd_param_t* param = NULL;
    amxc_var_t* event_data = NULL;
 
    assert_int_equal(amxd_dm_init(&dm), 0);
    amxc_var_new(&event_data);
    amxc_var_set_type(event_data, AMXC_VAR_ID_HTABLE);
    amxc_var_add_key(cstring_t, event_data, "param1", "Text");
    amxc_var_add_key(uint32_t, event_data, "param2", 100);
 
    assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "MyRootObject"), 0);
    assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
 
    assert_int_equal(amxd_object_new(&child_object, amxd_object_singleton, "MyChildObject1"), 0);
    assert_int_equal(amxd_object_add_object(object, child_object), 0);
 
    assert_int_equal(amxd_param_new(&param, "MyParam1", AMXC_VAR_ID_CSTRING), 0);
    assert_int_equal(amxd_object_add_param(child_object, param), 0);
    assert_int_equal(amxd_param_new(&param, "MyParam2", AMXC_VAR_ID_BOOL), 0);
    assert_int_equal(amxd_object_add_param(child_object, param), 0);
    assert_int_equal(amxd_param_new(&param, "MyParam3", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(child_object, param), 0);
 
    assert_int_equal(amxd_object_new(&child_object, amxd_object_singleton, "MyChildObject2"), 0);
    assert_int_equal(amxd_object_add_object(object, child_object), 0);
 
    assert_int_equal(amxd_param_new(&param, "MyParam1", AMXC_VAR_ID_CSTRING), 0);
    assert_int_equal(amxd_object_add_param(child_object, param), 0);
    assert_int_equal(amxd_param_new(&param, "MyParam2", AMXC_VAR_ID_BOOL), 0);
    assert_int_equal(amxd_object_add_param(child_object, param), 0);
    assert_int_equal(amxd_param_new(&param, "MyParam3", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(child_object, param), 0);
    assert_int_equal(amxd_object_add_event(child_object, "MyEvent1!"), 0);
    assert_int_equal(amxd_object_add_event_ext(child_object, "MyEvent2!", event_data), 0);
}

test_can_allocate_event_data()

void test_can_allocate_event_data

(

UNUSED void **

state

)

Definition at line 311 of file test_amxd_object_event.c.

                                                       {
    amxc_var_t* event_data = NULL;
    amxd_object_t* object = amxd_dm_findf(&dm, "MyRootObject.MyChildObject2.");
    assert_non_null(object);
 
    event_data = amxd_object_new_event_data(object, "MyEvent1!");
    assert_non_null(event_data);
 
    assert_int_equal(amxc_var_type_of(event_data), AMXC_VAR_ID_NULL);
    amxc_var_delete(&event_data);
 
    event_data = amxd_object_new_event_data(object, "MyEvent2!");
    assert_non_null(event_data);
    assert_int_equal(amxc_var_type_of(event_data), AMXC_VAR_ID_HTABLE);
 
    amxc_var_delete(&event_data);
}

test_can_change_event_definition()

void test_can_change_event_definition

(

UNUSED void **

state

)

Definition at line 367 of file test_amxd_object_event.c.

                                                           {
    amxc_var_t* event_data = NULL;
    amxd_object_t* object = amxd_dm_findf(&dm, "MyRootObject.MyChildObject2.");
    assert_non_null(object);
 
    assert_int_equal(amxd_object_add_event(object, "MyEvent2!"), 0);
    event_data = amxd_object_new_event_data(object, "MyEvent2!");
    assert_non_null(event_data);
 
    assert_int_equal(amxc_var_type_of(event_data), AMXC_VAR_ID_NULL);
    amxc_var_delete(&event_data);
}

test_can_remove_event_definition()

void test_can_remove_event_definition

(

UNUSED void **

state

)

Definition at line 380 of file test_amxd_object_event.c.

                                                           {
    amxc_var_t* event_data = NULL;
    amxd_object_t* object = amxd_dm_findf(&dm, "MyRootObject.MyChildObject2.");
    assert_non_null(object);
 
    amxd_object_remove_event(object, "MyEvent2!");
    event_data = amxd_object_new_event_data(object, "MyEvent2!");
    assert_null(event_data);
}

test_can_send_event()

void test_can_send_event

(

UNUSED void **

state

)

Definition at line 347 of file test_amxd_object_event.c.

                                              {
    amxc_var_t* event_data = NULL;
    uint32_t count = 0;
    amxd_object_t* object = amxd_dm_findf(&dm, "MyRootObject.MyChildObject2.");
    assert_non_null(object);
 
    while(amxp_signal_read() == 0) {
    }
 
    event_data = amxd_object_new_event_data(object, "MyEvent2!");
    amxd_object_emit_signal(object, "MyEvent2!", event_data);
    amxc_var_delete(&event_data);
 
    while(amxp_signal_read() == 0) {
        count++;
    }
 
    assert_int_equal(count, 1);
}

test_can_start_and_stop_periodic_inform()

void test_can_start_and_stop_periodic_inform

(

UNUSED void **

state

)

Definition at line 175 of file test_amxd_object_event.c.

                                                                  {
    amxd_object_t* object = NULL;
    amxp_timer_t* expire = NULL;
    int counter = 0;
 
    amxp_timer_new(&expire, NULL, NULL);
    object = amxd_dm_findf(&dm, "MyRootObject.MyChildObject1");
 
    amxp_timer_start(expire, 5000);
 
    counter = 0;
    amxp_slot_connect(&dm.sigmngr, "dm:periodic-inform", NULL, test_event_handler, &counter);
    assert_int_equal(amxd_object_new_pi(object, 1), 0);
    read_sig_alarm();
    read_sig_alarm();
    read_sig_alarm();
    assert_int_equal(amxd_object_delete_pi(object), 0);
    assert_int_equal(counter, 3);
 
    counter = 0;
    read_sig_alarm();
    assert_int_equal(counter, 0);
 
    while(amxp_signal_read() == 0) {
    }
 
    amxp_timer_start(expire, 5000);
 
    assert_int_equal(amxd_object_new_pi(object, 1), 0);
    read_sig_alarm();
    read_sig_alarm();
    read_sig_alarm();
    assert_int_equal(amxd_object_delete_pi(object), 0);
    assert_true(counter >= 2);
 
    counter = 0;
    read_sig_alarm();
    assert_int_equal(counter, 0);
 
    amxp_timer_set_interval(expire, 1000);
    amxp_timer_start(expire, 5000);
 
    counter = 0;
    read_sig_alarm();
    read_sig_alarm();
    read_sig_alarm();
    assert_int_equal(counter, 0);
    amxp_timer_delete(&expire);
    amxp_slot_disconnect(&dm.sigmngr, "dm:periodic-inform", test_event_handler);
}

test_event_changed_is_send()

void test_event_changed_is_send

(

UNUSED void **

state

)

Definition at line 390 of file test_amxd_object_event.c.

                                                     {
    amxd_trans_t transaction;
    int counter = 0;
    amxc_var_t data;
    amxc_var_t* params = NULL;
 
    amxp_slot_connect(&dm.sigmngr, "dm:object-changed", NULL, test_event_handler, &counter);
 
    assert_int_equal(amxd_trans_init(&transaction), 0);
    assert_int_equal(amxd_trans_select_pathf(&transaction, "MyRootObject.MyChildObject2."), 0);
    assert_int_equal(amxd_trans_set_value(cstring_t, &transaction, "MyParam1", "Hello world"), 0);
    assert_int_equal(amxd_trans_set_value(bool, &transaction, "MyParam2", true), 0);
    amxd_trans_dump(&transaction, STDOUT_FILENO, false);
    assert_int_equal(amxd_trans_apply(&transaction, &dm), 0);
    amxd_trans_clean(&transaction);
 
    while(amxp_signal_read() == 0) {
    }
    assert_int_equal(counter, 1);
    counter = 0;
 
    amxc_var_init(&data);
    amxc_var_set_type(&data, AMXC_VAR_ID_HTABLE);
    amxc_var_add_key(uint32_t, &data, "access", amxd_dm_access_public);
    amxc_var_add_key(bool, &data, "set_read_only", false);
    params = amxc_var_add_key(amxc_htable_t, &data, "oparameters", NULL);
    amxc_var_add_key(cstring_t, params, "MyParam1", "Hello Universe");
    amxc_var_add_key(bool, params, "MyParam2", false);
 
    assert_int_equal(amxd_trans_init(&transaction), 0);
    assert_int_equal(amxd_trans_select_pathf(&transaction, "MyRootObject.MyChildObject2."), 0);
    amxd_trans_add_action(&transaction, action_object_write, &data);
    amxd_trans_dump(&transaction, STDOUT_FILENO, false);
    assert_int_equal(amxd_trans_apply(&transaction, &dm), 0);
    amxd_trans_clean(&transaction);
 
    while(amxp_signal_read() == 0) {
    }
    assert_int_equal(counter, 1);
 
    amxc_var_clean(&data);
    amxp_slot_disconnect(&dm.sigmngr, "dm:object-changed", test_event_handler);
}

test_event_handler()

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

static

Definition at line 87 of file test_amxd_object_event.c.

                                                 {
    int* counter = (int*) priv;
    printf("event recieved %s\n", sig_name);
    (*counter)++;
}

test_events_are_not_duplicated()

void test_events_are_not_duplicated

(

UNUSED void **

state

)

Definition at line 277 of file test_amxd_object_event.c.

                                                         {
    amxd_trans_t transaction;
    int counter = 0;
    amxd_object_t* child_object = NULL;
    amxd_object_t* child_object2 = NULL;
    amxd_object_t* root = amxd_dm_findf(&dm, "MyRootObject");
 
    amxp_slot_connect(&dm.sigmngr, "*", NULL, test_event_handler, &counter);
 
    assert_int_equal(amxd_object_new(&child_object, amxd_object_template, "MyTemplate"), 0);
    assert_int_equal(amxd_object_add_object(root, child_object), 0);
    assert_int_equal(amxd_object_new(&child_object2, amxd_object_singleton, "MySubObject"), 0);
    assert_int_equal(amxd_object_set_attr(child_object2, amxd_oattr_private, true), 0);
    assert_int_equal(amxd_object_add_object(child_object, child_object2), 0);
    assert_int_equal(amxd_object_new(&child_object2, amxd_object_template, "MySubTemplate"), 0);
    assert_int_equal(amxd_object_add_object(child_object, child_object2), 0);
 
    amxd_trans_init(&transaction);
    amxd_trans_select_pathf(&transaction, "MyRootObject.MyTemplate.");
    amxd_trans_add_inst(&transaction, 0, NULL);
    amxd_trans_select_pathf(&transaction, ".MySubTemplate.");
    amxd_trans_add_inst(&transaction, 0, NULL);
    assert_int_equal(amxd_trans_apply(&transaction, &dm), 0);
 
    while(amxp_signal_read() == 0) {
    }
 
    assert_int_equal(counter, 6); // 2 instance add + 4 object added
 
    amxp_slot_disconnect_all(test_event_handler);
 
    amxd_trans_clean(&transaction);
}

test_object_event_setup()

int test_object_event_setup

(

UNUSED void **

state

)

Definition at line 153 of file test_amxd_object_event.c.

                                                 {
    test_build_dm();
 
    sigemptyset(&mask);
    sigaddset(&mask, SIGALRM);
 
    int rv = sigprocmask(SIG_BLOCK, &mask, NULL);
    assert_false(rv < 0);
 
    sfd = signalfd(-1, &mask, 0);
    assert_false(sfd < 0);
 
    return 0;
}

test_object_event_teardown()

int test_object_event_teardown

(

UNUSED void **

state

)

Definition at line 168 of file test_amxd_object_event.c.

                                                    {
    close(sfd);
    amxd_dm_clean(&dm);
 
    return 0;
}

test_only_one_periodic_inform_per_object()

void test_only_one_periodic_inform_per_object

(

UNUSED void **

state

)

Definition at line 226 of file test_amxd_object_event.c.

                                                                   {
    amxd_object_t* object = NULL;
    amxp_timer_t* expire = NULL;
    int counter = 0;
 
    amxp_timer_new(&expire, NULL, NULL);
    object = amxd_dm_findf(&dm, "MyRootObject.MyChildObject1");
 
    amxp_slot_connect(&dm.sigmngr, "dm:periodic-inform", NULL, test_event_handler, &counter);
    assert_int_equal(amxd_object_new_pi(object, 2), 0);
    assert_int_not_equal(amxd_object_new_pi(object, 1), 0);
    read_sig_alarm();
    read_sig_alarm();
    read_sig_alarm();
    assert_int_equal(amxd_object_delete_pi(object), 0);
    assert_true(counter >= 2);
 
    counter = 0;
    amxp_timer_set_interval(expire, 10000);
    amxp_timer_start(expire, 1000);
    read_sig_alarm();
    read_sig_alarm();
    read_sig_alarm();
    assert_int_equal(counter, 0);
    amxp_timer_delete(&expire);
    amxp_slot_disconnect(&dm.sigmngr, "dm:periodic-inform", test_event_handler);
}

test_timer_stops_when_object_is_destroyed()

void test_timer_stops_when_object_is_destroyed

(

UNUSED void **

state

)

Definition at line 254 of file test_amxd_object_event.c.

                                                                    {
    amxd_object_t* object = NULL;
    amxp_timer_t* expire = NULL;
    int counter = 0;
 
    amxp_timer_new(&expire, NULL, NULL);
    object = amxd_dm_findf(&dm, "MyRootObject.MyChildObject1");
 
    amxp_timer_start(expire, 5000);
    read_sig_alarm();
    assert_int_equal(counter, 0);
 
    amxp_timer_start(expire, 5000);
    amxp_slot_connect(&dm.sigmngr, "dm:periodic-inform", NULL, test_event_handler, &counter);
    assert_int_equal(amxd_object_new_pi(object, 1), 0);
    read_sig_alarm();
    amxd_object_delete(&object);
    read_sig_alarm();
    assert_int_equal(counter, 1);
    amxp_timer_delete(&expire);
    amxp_slot_disconnect(&dm.sigmngr, "dm:periodic-inform", test_event_handler);
}

Variable Documentation

dm

amxd_dm_t dm

static

Definition at line 83 of file test_amxd_object_event.c.

mask

sigset_t mask

static

Definition at line 85 of file test_amxd_object_event.c.

sfd

int sfd

static

Definition at line 84 of file test_amxd_object_event.c.