test_amxd_mib.c File Reference

#include <stdlib.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <cmocka.h>
#include <string.h>
#include <amxc/amxc.h>
#include <amxp/amxp_signal.h>
#include <amxp/amxp_slot.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_parameter.h>
#include <amxd/amxd_function.h>
#include <amxd/amxd_action.h>
#include <amxd/amxd_mib.h>
#include <amxd/amxd_transaction.h>
#include <amxd_priv.h>
#include "test_amxd_mib.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Functions
static void	test_event_handler (const char *const sig_name, UNUSED const amxc_var_t *const data, void *const priv)
static amxd_status_t	test_mib_cleanup_data (amxd_object_t *const object, amxd_param_t *const param, amxd_action_t reason, UNUSED const amxc_var_t *const args, UNUSED amxc_var_t *const retval, void *priv)
static amxd_object_t *	test_build_dm (void)
void	test_can_define_and_store_mib (UNUSED void **state)
static int	count_objects (UNUSED amxd_object_t *templ, UNUSED amxd_object_t *obj, void *priv)
void	test_can_add_remove_mib_to_from_object (UNUSED void **state)
void	test_can_add_remove_mib_to_from_object2 (UNUSED void **state)
void	test_can_add_multiple_mibs (UNUSED void **state)
void	test_add_mib_fails_when_duplicates (UNUSED void **state)
void	test_add_mib_fails_when_object_not_in_dm (UNUSED void **state)
void	test_functions_check_input_args (UNUSED void **state)
void	test_get_root_of_mib_is_null (UNUSED void **state)
void	test_set_attrs_on_mib_fails (UNUSED void **state)
void	test_add_mib_to_object_fails_when_leads_to_function_duplicate (UNUSED void **state)
void	test_add_mib_can_override_function (UNUSED void **state)
void	test_add_mib_function_inherits_argument_attrs (UNUSED void **state)
void	test_add_mib_to_instance (UNUSED void **state)
void	test_add_mib_using_transaction (UNUSED void **state)
void	test_add_mib_to_template (UNUSED void **state)
void	test_mib_not_removed_when_not_added (UNUSED void **state)
void	test_mib_events (UNUSED void **state)
void	test_can_fetch_dm_from_mib (UNUSED void **state)
void	test_can_declare_event_in_mib (UNUSED void **state)
void	test_add_mib_object_can_be_read_using_name_path (UNUSED void **state)
void	test_object_get_mibs (UNUSED void **state)

Variables
static amxd_dm_t	dm

Function Documentation

count_objects()

static int count_objects ( UNUSED amxd_object_t *  templ, UNUSED amxd_object_t *  obj, void *  priv  )

static

Definition at line 202 of file test_amxd_mib.c.

                                                                                             {
    int* count = (int*) priv;
    *count = *count + 1;
    return 1;
}

test_add_mib_can_override_function()

void test_add_mib_can_override_function

(

UNUSED void **

state

)

Definition at line 524 of file test_amxd_mib.c.

                                                             {
    amxd_object_t* mib = NULL;
    amxd_object_t* object = NULL;
    amxd_object_t* instance = NULL;
    amxd_function_t* func = NULL;
 
    test_build_dm();
 
    object = amxd_dm_findf(&dm, "TestObject.TemplObject");
    assert_ptr_not_equal(object, NULL);
    assert_int_equal(amxd_object_new_instance(&instance, object, NULL, 0, NULL), 0);
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    amxd_function_new(&func, "Func1", AMXC_VAR_ID_CSTRING, NULL);
    assert_int_equal(amxd_object_add_function(mib, func), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_equal(amxd_object_add_mib(instance, "TestMib"), 0);
 
    amxd_dm_clean(&dm);
}

test_add_mib_fails_when_duplicates()

void test_add_mib_fails_when_duplicates

(

UNUSED void **

state

)

Definition at line 385 of file test_amxd_mib.c.

                                                             {
    amxd_object_t* mib = NULL;
    amxd_object_t* object = NULL;
    amxd_param_t* param = NULL;
 
    object = test_build_dm();
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_not_equal(amxd_object_add_mib(object, "TestMib1"), 0);
    assert_false(amxd_object_has_mib(object, "TestMib1"));
    assert_ptr_not_equal(amxd_object_get_param_def(object, "Param1"), NULL);
 
    amxd_dm_clean(&dm);
}

test_add_mib_fails_when_object_not_in_dm()

void test_add_mib_fails_when_object_not_in_dm

(

UNUSED void **

state

)

Definition at line 406 of file test_amxd_mib.c.

                                                                   {
    amxd_object_t* mib = NULL;
    amxd_object_t* object = NULL;
    amxd_param_t* param = NULL;
 
    assert_int_equal(amxd_dm_init(&dm), 0);
 
    assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "TestObject"), 0);
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_not_equal(amxd_object_add_mib(object, "TestMib1"), 0);
    assert_false(amxd_object_has_mib(object, "TestMib1"));
    assert_ptr_equal(amxd_object_get_param_def(object, "Param1"), NULL);
 
    amxd_object_delete(&object);
    amxd_dm_clean(&dm);
}

test_add_mib_function_inherits_argument_attrs()

void test_add_mib_function_inherits_argument_attrs

(

UNUSED void **

state

)

Definition at line 548 of file test_amxd_mib.c.

                                                                        {
    amxd_object_t* mib = NULL;
    amxd_object_t* object = NULL;
    amxd_object_t* instance = NULL;
    amxd_function_t* func = NULL;
    amxc_var_t def_val;
 
    amxc_var_init(&def_val);
    amxc_var_set(bool, &def_val, true);
 
    test_build_dm();
 
    object = amxd_dm_findf(&dm, "TestObject.TemplObject");
    assert_ptr_not_equal(object, NULL);
    assert_int_equal(amxd_object_new_instance(&instance, object, NULL, 0, NULL), 0);
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    amxd_function_new(&func, "Func1", AMXC_VAR_ID_CSTRING, NULL);
    assert_int_equal(amxd_function_new_arg(func, "parameters", AMXC_VAR_ID_BOOL, &def_val), 0);
    amxd_function_arg_set_attr(func, "parameters", amxd_aattr_in, true);
    amxd_function_arg_set_attr(func, "parameters", amxd_aattr_out, true);
    amxd_function_arg_set_attr(func, "parameters", amxd_aattr_mandatory, true);
    amxd_function_arg_set_attr(func, "parameters", amxd_aattr_strict, true);
    assert_int_equal(amxd_object_add_function(mib, func), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_equal(amxd_object_add_mib(instance, "TestMib"), 0);
 
    func = amxd_object_get_function(instance, "Func1");
    assert_non_null(func);
 
    assert_true(amxd_function_arg_is_attr_set(func, "parameters", amxd_aattr_in));
    assert_true(amxd_function_arg_is_attr_set(func, "parameters", amxd_aattr_out));
    assert_true(amxd_function_arg_is_attr_set(func, "parameters", amxd_aattr_mandatory));
    assert_true(amxd_function_arg_is_attr_set(func, "parameters", amxd_aattr_strict));
 
    amxd_dm_clean(&dm);
}

test_add_mib_object_can_be_read_using_name_path()

void test_add_mib_object_can_be_read_using_name_path

(

UNUSED void **

state

)

Definition at line 855 of file test_amxd_mib.c.

                                                                          {
    amxd_object_t* mib = NULL;
    amxd_object_t* object = NULL;
    amxd_param_t* param = NULL;
    amxd_object_t* instance = NULL;
    amxc_var_t ret;
    amxc_var_t args;
 
    amxc_var_init(&ret);
    amxc_var_init(&args);
 
    object = test_build_dm();
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "TestObj"), 0);
    assert_int_equal(amxd_param_new(&param, "MParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(object, param), 0);
    assert_int_equal(amxd_object_add_object(mib, object), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    object = amxd_dm_findf(&dm, "TestObject.TemplObject");
    assert_ptr_not_equal(object, NULL);
    assert_int_equal(amxd_object_new_instance(&instance, object, "TestInstance", 0, NULL), 0);
    assert_int_equal(amxd_object_add_mib(instance, "TestMib1"), 0);
    assert_true(amxd_object_has_mib(instance, "TestMib1"));
    assert_ptr_not_equal(amxd_object_get_param_def(object, "Param1"), NULL);
 
    object = amxd_dm_findf(&dm, "TestObject.");
    amxc_var_set_type(&args, AMXC_VAR_ID_HTABLE);
    amxc_var_add_key(cstring_t, &args, "rel_path", "TemplObject.TestInstance.TestObj.");
    assert_int_equal(amxd_object_invoke_function(object, "_get", &args, &ret), 0);
 
    amxd_dm_clean(&dm);
 
    amxc_var_clean(&ret);
    amxc_var_clean(&args);
}

test_add_mib_to_instance()

void test_add_mib_to_instance

(

UNUSED void **

state

)

Definition at line 590 of file test_amxd_mib.c.

                                                   {
    amxd_object_t* mib = NULL;
    amxd_object_t* object = NULL;
    amxd_object_t* instance = NULL;
    amxd_param_t* param = NULL;
    amxc_var_t* data = NULL;
    amxd_function_t* func = NULL;
 
    amxc_var_new(&data);
    amxc_var_set(uint32_t, data, 0);
    test_build_dm();
 
    object = amxd_dm_findf(&dm, "TestObject.TemplObject");
    assert_ptr_not_equal(object, NULL);
    assert_int_equal(amxd_object_new_instance(&instance, object, NULL, 0, NULL), 0);
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_param_new(&param, "MibParamB", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_param_add_action_cb(param, action_param_validate, amxd_action_param_check_minimum, data), 0);
    assert_int_equal(amxd_param_add_action_cb(param, action_param_destroy, test_mib_cleanup_data, data), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    amxd_function_new(&func, "Func1", AMXC_VAR_ID_CSTRING, NULL);
    amxd_function_set_attr(func, amxd_fattr_template, true);
    assert_int_equal(amxd_object_add_function(mib, func), 0);
    amxd_function_new(&func, "Func2", AMXC_VAR_ID_CSTRING, NULL);
    amxd_function_set_attr(func, amxd_fattr_instance, true);
    assert_int_equal(amxd_object_add_function(mib, func), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib2"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam2", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_param_set_attr(param, amxd_pattr_template, true), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_equal(amxd_object_add_mib(instance, "TestMib1"), 0);
    param = amxd_object_get_param_def(instance, "MibParam1");
    assert_non_null(param);
 
    assert_int_equal(amxd_object_add_mib(instance, "TestMib2"), 0);
    param = amxd_object_get_param_def(instance, "MibParam2");
    assert_null(param);
 
    amxd_dm_clean(&dm);
}

test_add_mib_to_object_fails_when_leads_to_function_duplicate()

void test_add_mib_to_object_fails_when_leads_to_function_duplicate

(

UNUSED void **

state

)

Definition at line 499 of file test_amxd_mib.c.

                                                                                        {
    amxd_object_t* mib = NULL;
    amxd_object_t* mib_object = NULL;
    amxd_object_t* object = NULL;
    amxd_param_t* param = NULL;
    amxd_function_t* func = NULL;
 
    object = test_build_dm();
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_object_new(&mib_object, amxd_object_singleton, "MibChild"), 0);
    assert_int_equal(amxd_object_add_object(mib, mib_object), 0);
    amxd_function_new(&func, "Func1", AMXC_VAR_ID_CSTRING, NULL);
    assert_int_equal(amxd_object_add_function(mib, func), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_not_equal(amxd_object_add_mib(object, "TestMib"), 0);
 
    amxd_dm_clean(&dm);
}

test_add_mib_to_template()

void test_add_mib_to_template

(

UNUSED void **

state

)

Definition at line 685 of file test_amxd_mib.c.

                                                   {
    amxd_object_t* mib = NULL;
    amxd_object_t* object = NULL;
    amxd_object_t* instance = NULL;
    amxd_param_t* param = NULL;
    amxd_function_t* func = NULL;
 
    test_build_dm();
 
    object = amxd_dm_findf(&dm, "TestObject.TemplObject");
    assert_ptr_not_equal(object, NULL);
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
 
    amxd_function_new(&func, "Func2", AMXC_VAR_ID_CSTRING, NULL);
    amxd_function_set_attr(func, amxd_fattr_instance, true);
    assert_int_equal(amxd_object_add_function(mib, func), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_equal(amxd_object_add_mib(object, "TestMib1"), 0);
    param = amxd_object_get_param_def(object, "MibParam1");
    assert_non_null(param);
 
    assert_int_equal(amxd_object_new_instance(&instance, object, NULL, 0, NULL), 0);
    param = amxd_object_get_param_def(instance, "MibParam1");
    assert_non_null(param);
 
    amxd_dm_clean(&dm);
}

test_add_mib_using_transaction()

void test_add_mib_using_transaction

(

UNUSED void **

state

)

Definition at line 642 of file test_amxd_mib.c.

                                                         {
    amxd_object_t* mib = NULL;
    amxd_param_t* param = NULL;
    amxd_object_t* object = NULL;
    amxd_trans_t transaction;
 
    test_build_dm();
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_param_new(&param, "MibParamB", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_equal(amxd_trans_init(&transaction), 0);
    assert_int_equal(amxd_trans_select_pathf(&transaction, "TestObject.TemplObject."), 0);
    assert_int_equal(amxd_trans_add_inst(&transaction, 0, NULL), 0);
    assert_int_equal(amxd_trans_add_mib(&transaction, "TestMib1"), 0);
    assert_int_equal(amxd_trans_set_value(cstring_t, &transaction, "Param1", "Test"), 0);
    amxd_trans_dump(&transaction, STDOUT_FILENO, false);
    assert_int_equal(amxd_trans_apply(&transaction, &dm), 0);
 
    object = amxd_dm_findf(&dm, "TestObject.TemplObject.1.");
    assert_non_null(object);
    param = amxd_object_get_param_def(object, "MibParam1");
    assert_non_null(param);
 
    amxd_trans_clean(&transaction);
 
    assert_int_equal(amxd_trans_init(&transaction), 0);
    amxd_trans_select_pathf(&transaction, "TestObject.TemplObject.1.");
    assert_int_equal(amxd_trans_set_value(uint32_t, &transaction, "MibParam1", 102), 0);
    assert_int_equal(amxd_trans_add_mib(&transaction, "TestMib1"), 0);
    amxd_trans_dump(&transaction, STDOUT_FILENO, true);
    assert_int_equal(amxd_trans_apply(&transaction, &dm), 0);
 
    amxd_trans_clean(&transaction);
    amxd_dm_clean(&dm);
}

test_build_dm()

static amxd_object_t* test_build_dm ( void  )

static

Definition at line 128 of file test_amxd_mib.c.

                                          {
    amxd_object_t* object = NULL;
    amxd_param_t* param = NULL;
    amxd_function_t* func = NULL;
    amxd_object_t* templ_obj = NULL;
 
    assert_int_equal(amxd_dm_init(&dm), 0);
 
    assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "TestObject"), 0);
    assert_int_equal(amxd_dm_add_root_object(&dm, object), 0);
 
    assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CSTRING), 0);
    assert_int_equal(amxd_object_add_param(object, param), 0);
    assert_int_equal(amxd_param_new(&param, "Param2", AMXC_VAR_ID_BOOL), 0);
    assert_int_equal(amxd_object_add_param(object, param), 0);
    amxd_function_new(&func, "Func1", AMXC_VAR_ID_CSTRING, NULL);
    assert_int_equal(amxd_object_add_function(object, func), 0);
 
    assert_int_equal(amxd_object_new(&templ_obj, amxd_object_template, "TemplObject"), 0);
    assert_int_equal(amxd_param_new(&param, "Param1", AMXC_VAR_ID_CSTRING), 0);
    assert_int_equal(amxd_object_add_param(templ_obj, param), 0);
    amxd_function_new(&func, "Func1", AMXC_VAR_ID_CSTRING, NULL);
    assert_int_equal(amxd_object_add_function(templ_obj, func), 0);
    assert_int_equal(amxd_object_add_object(object, templ_obj), 0);
 
    return object;
}

test_can_add_multiple_mibs()

void test_can_add_multiple_mibs

(

UNUSED void **

state

)

Definition at line 330 of file test_amxd_mib.c.

                                                     {
    amxd_object_t* mib = NULL;
    amxd_object_t* object = NULL;
    amxd_param_t* param = NULL;
 
    object = test_build_dm();
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib2"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam2", AMXC_VAR_ID_CSTRING), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_equal(amxd_object_add_mib(object, "TestMib1"), 0);
    assert_int_equal(amxd_object_add_mib(object, "TestMib2"), 0);
    assert_true(amxd_object_has_mib(object, "TestMib1"));
    assert_true(amxd_object_has_mib(object, "TestMib2"));
    assert_false(amxd_object_has_mib(object, "NotExisting"));
    assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
    assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam2"), NULL);
 
    assert_int_equal(amxd_object_remove_mib(object, "TestMib1"), 0);
    assert_false(amxd_object_has_mib(object, "TestMib1"));
    assert_true(amxd_object_has_mib(object, "TestMib2"));
    assert_false(amxd_object_has_mib(object, "NotExisting"));
    assert_ptr_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
    assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam2"), NULL);
 
    assert_int_equal(amxd_object_add_mib(object, "TestMib1"), 0);
    assert_true(amxd_object_has_mib(object, "TestMib1"));
    assert_true(amxd_object_has_mib(object, "TestMib2"));
    assert_false(amxd_object_has_mib(object, "NotExisting"));
    assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
    assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam2"), NULL);
 
    assert_int_equal(amxd_object_remove_mib(object, "TestMib2"), 0);
    assert_true(amxd_object_has_mib(object, "TestMib1"));
    assert_false(amxd_object_has_mib(object, "TestMib2"));
    assert_false(amxd_object_has_mib(object, "NotExisting"));
    assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
    assert_ptr_equal(amxd_object_get_param_def(object, "MibParam2"), NULL);
 
    assert_int_not_equal(amxd_object_add_mib(object, "NotExisting"), 0);
 
    amxd_dm_clean(&dm);
}

test_can_add_remove_mib_to_from_object()

void test_can_add_remove_mib_to_from_object

(

UNUSED void **

state

)

Definition at line 208 of file test_amxd_mib.c.

                                                                 {
    amxd_object_t* mib = NULL;
    amxd_object_t* object = NULL;
    amxd_object_t* mibobject = NULL;
    amxd_object_t* child = NULL;
    amxd_param_t* param = NULL;
    amxd_function_t* func = NULL;
 
    object = test_build_dm();
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_function_new(&func, "MibFunc1", AMXC_VAR_ID_NULL, NULL), 0);
    assert_int_equal(amxd_object_add_function(mib, func), 0);
    assert_int_equal(amxd_object_new(&child, amxd_object_singleton, "MibObject"), 0);
    assert_int_equal(amxd_object_add_object(mib, child), 0);
 
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_equal(amxd_object_add_mib(object, "TestMib"), 0);
    assert_true(amxd_object_has_mib(object, "TestMib"));
    assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
    assert_ptr_not_equal(amxd_object_get_function(object, "MibFunc1"), NULL);
    assert_ptr_not_equal(amxd_object_get_child(object, "MibObject"), NULL);
    assert_int_not_equal(amxd_object_add_mib(object, "TestMib"), 0);
    assert_true(amxd_object_has_mib(object, "TestMib"));
 
    int count = 0;
    amxd_object_for_all(object, "MibObject", count_objects, &count);
    assert_int_equal(count, 1);
 
    assert_int_equal(amxd_object_remove_mib(object, "TestMib"), 0);
    assert_false(amxd_object_has_mib(object, "TestMib"));
    assert_ptr_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
    assert_ptr_equal(amxd_object_get_function(object, "MibFunc1"), NULL);
    assert_ptr_equal(amxd_object_get_child(object, "MibObject"), NULL);
    assert_int_equal(amxd_object_remove_mib(object, "TestMib"), 0);
 
    assert_int_equal(amxd_object_add_mib(object, "TestMib"), 0);
    assert_int_not_equal(amxd_object_add_mib(object, "TestMib"), 0);
    func = amxd_object_get_function(object, "MibFunc1");
    amxd_function_delete(&func);
    param = amxd_object_get_param_def(object, "MibParam1");
    amxd_param_delete(&param);
    mibobject = amxd_object_get_child(object, "MibObject");
    amxd_object_delete(&mibobject);
    assert_int_equal(amxd_object_remove_mib(object, "TestMib"), 0);
 
    amxd_dm_clean(&dm);
}

test_can_add_remove_mib_to_from_object2()

void test_can_add_remove_mib_to_from_object2

(

UNUSED void **

state

)

Definition at line 262 of file test_amxd_mib.c.

                                                                  {
    amxd_object_t* mib = NULL;
    amxd_object_t* object = NULL;
    amxd_object_t* mibobject = NULL;
    amxd_object_t* template = NULL;
    amxd_object_t* template2 = NULL;
    amxd_object_t* child = NULL;
    amxd_object_t* child2 = NULL;
    amxd_object_t* child3 = NULL;
    amxd_param_t* param = NULL;
    amxd_param_t* instParam = NULL;
    amxd_function_t* func = NULL;
 
    object = test_build_dm();
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_function_new(&func, "MibFunc1", AMXC_VAR_ID_NULL, NULL), 0);
    assert_int_equal(amxd_object_add_function(mib, func), 0);
    assert_int_equal(amxd_object_new(&template, amxd_object_template, "MibObject"), 0);
    assert_int_equal(amxd_object_add_object(mib, template), 0);
    assert_int_equal(amxd_param_new(&instParam, "InstParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(template, instParam), 0);
 
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_equal(amxd_object_new(&template2, amxd_object_template, "Templ"), 0);
    assert_int_equal(amxd_object_add_object(object, template2), 0);
    assert_int_equal(amxd_object_new_instance(&child2, amxd_object_get_child(object, "Templ"), "TestInst1", 0, NULL), 0);
    assert_int_equal(amxd_object_new_instance(&child3, amxd_object_get_child(object, "Templ"), "TestInst2", 0, NULL), 0);
 
    assert_int_equal(amxd_object_add_mib(child2, "TestMib"), 0);
    assert_true(amxd_object_has_mib(child2, "TestMib"));
    assert_ptr_not_equal(amxd_object_get_param_def(child2, "MibParam1"), NULL);
    assert_ptr_not_equal(amxd_object_get_function(child2, "MibFunc1"), NULL);
    assert_ptr_not_equal(amxd_object_get_child(child2, "MibObject"), NULL);
    assert_int_not_equal(amxd_object_add_mib(child2, "TestMib"), 0);
    assert_true(amxd_object_has_mib(child2, "TestMib"));
 
    assert_int_equal(amxd_object_new_instance(&child, amxd_object_get_child(child2, "MibObject"), "MibInst1", 0, NULL), 0);
 
    int count = 0;
    amxd_object_for_all(object, "Templ.*.MibObject.[InstParam1==0].", count_objects, &count);
    assert_int_equal(count, 1);
 
    assert_int_equal(amxd_object_remove_mib(child2, "TestMib"), 0);
    assert_false(amxd_object_has_mib(child2, "TestMib"));
    assert_ptr_equal(amxd_object_get_param_def(child2, "MibParam1"), NULL);
    assert_ptr_equal(amxd_object_get_function(child2, "MibFunc1"), NULL);
    assert_ptr_equal(amxd_object_get_child(child2, "MibObject"), NULL);
    assert_int_equal(amxd_object_remove_mib(child2, "TestMib"), 0);
 
    assert_int_equal(amxd_object_add_mib(child2, "TestMib"), 0);
    assert_int_not_equal(amxd_object_add_mib(child2, "TestMib"), 0);
    func = amxd_object_get_function(child2, "MibFunc1");
    amxd_function_delete(&func);
    param = amxd_object_get_param_def(child2, "MibParam1");
    amxd_param_delete(&param);
    mibobject = amxd_object_get_child(child2, "MibObject");
    amxd_object_delete(&mibobject);
    assert_int_equal(amxd_object_remove_mib(child2, "TestMib"), 0);
 
    amxd_dm_clean(&dm);
}

test_can_declare_event_in_mib()

void test_can_declare_event_in_mib

(

UNUSED void **

state

)

Definition at line 811 of file test_amxd_mib.c.

                                                        {
    amxd_object_t* mib = NULL;
    amxd_param_t* param = NULL;
    amxd_object_t* object = NULL;
    amxd_object_t* instance = NULL;
    amxc_var_t* event = NULL;
 
    test_build_dm();
 
    object = amxd_dm_findf(&dm, "TestObject.TemplObject");
    assert_ptr_not_equal(object, NULL);
    assert_int_equal(amxd_object_new_instance(&instance, object, NULL, 0, NULL), 0);
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "MibSubObject"), 0);
    assert_int_equal(amxd_object_add_object(mib, object), 0);
 
    assert_null(amxd_object_get_dm(mib));
 
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
    assert_int_equal(amxd_object_add_event_ext(mib, "Event1!", NULL), 0);
    assert_int_equal(amxd_object_add_event_ext(object, "Event2!", NULL), 0);
 
    assert_int_equal(amxd_object_add_mib(instance, "TestMib1"), 0);
    event = amxd_object_new_event_data(instance, "Event1!");
    assert_non_null(event);
    free(event);
    object = amxd_object_findf(instance, "MibSubObject");
    assert_non_null(object);
    event = amxd_object_new_event_data(object, "Event2!");
    assert_non_null(event);
    free(event);
 
    assert_int_equal(amxd_object_remove_mib(instance, "TestMib1"), 0);
    event = amxd_object_new_event_data(instance, "Event1!");
    assert_null(event);
 
    amxd_dm_clean(&dm);
}

test_can_define_and_store_mib()

void test_can_define_and_store_mib

(

UNUSED void **

state

)

Definition at line 156 of file test_amxd_mib.c.

                                                        {
    amxd_object_t* mib = NULL;
    amxd_object_t* fetch_mib = NULL;
    amxd_object_t* object = NULL;
    amxd_param_t* param = NULL;
 
    test_build_dm();
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
    fetch_mib = amxd_dm_get_mib(&dm, "TestMib");
    assert_ptr_not_equal(fetch_mib, NULL);
    assert_ptr_equal(fetch_mib, mib);
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
    assert_int_not_equal(amxd_dm_store_mib(&dm, mib), 0);
    amxd_mib_delete(&mib);
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib2"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
 
    assert_int_not_equal(amxd_dm_store_mib(NULL, mib), 0);
    assert_int_not_equal(amxd_dm_store_mib(&dm, NULL), 0);
    assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "NotAMib"), 0);
    assert_int_not_equal(amxd_dm_store_mib(&dm, object), 0);
 
    assert_ptr_equal(amxd_dm_get_mib(&dm, "NotStoredMib"), NULL);
    assert_ptr_equal(amxd_dm_get_mib(NULL, "TestMib"), NULL);
    assert_ptr_equal(amxd_dm_get_mib(&dm, ""), NULL);
    assert_ptr_equal(amxd_dm_get_mib(&dm, NULL), NULL);
 
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
    fetch_mib = amxd_dm_get_mib(&dm, "TestMib2");
    assert_ptr_not_equal(fetch_mib, NULL);
    assert_ptr_equal(fetch_mib, mib);
 
    amxd_object_delete(&mib);
    amxd_object_delete(&object);
    amxd_dm_clean(&dm);
}

test_can_fetch_dm_from_mib()

void test_can_fetch_dm_from_mib

(

UNUSED void **

state

)

Definition at line 786 of file test_amxd_mib.c.

                                                     {
    amxd_object_t* mib = NULL;
    amxd_param_t* param = NULL;
    amxd_object_t* object = NULL;
 
    test_build_dm();
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_object_new(&object, amxd_object_singleton, "MibSubObject"), 0);
    assert_int_equal(amxd_object_add_object(mib, object), 0);
 
    assert_null(amxd_object_get_dm(mib));
 
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_ptr_equal(&dm, amxd_object_get_dm(mib));
    assert_ptr_equal(&dm, amxd_object_get_dm(object));
 
    amxd_dm_clean(&dm);
}

test_event_handler()

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

static

Definition at line 86 of file test_amxd_mib.c.

                                                 {
    int* counter = (int*) priv;
 
    if(strcmp(sig_name, "dm:mib-added") == 0) {
        (*counter)++;
    }
 
    if(strcmp(sig_name, "dm:mib-removed") == 0) {
        (*counter)--;
    }
}

test_functions_check_input_args()

void test_functions_check_input_args

(

UNUSED void **

state

)

Definition at line 430 of file test_amxd_mib.c.

                                                          {
    amxd_object_t* mib = NULL;
    amxd_object_t* object = NULL;
 
    assert_int_not_equal(amxd_mib_new(NULL, "TestMib1"), 0);
    assert_int_not_equal(amxd_mib_new(&mib, ""), 0);
    assert_int_not_equal(amxd_mib_new(&mib, "12345"), 0);
    assert_int_not_equal(amxd_mib_new(&mib, "A.b,%t"), 0);
    assert_int_not_equal(amxd_mib_new(&mib, NULL), 0);
 
    object = test_build_dm();
    assert_false(amxd_object_has_mib(NULL, "TestMib1"));
    assert_false(amxd_object_has_mib(object, ""));
    assert_false(amxd_object_has_mib(object, NULL));
 
    assert_int_not_equal(amxd_object_add_mib(object, NULL), 0);
    assert_int_not_equal(amxd_object_add_mib(object, ""), 0);
    assert_int_not_equal(amxd_object_add_mib(NULL, ""), 0);
 
    assert_int_not_equal(amxd_object_remove_mib(object, NULL), 0);
    assert_int_not_equal(amxd_object_remove_mib(object, ""), 0);
    assert_int_not_equal(amxd_object_remove_mib(NULL, ""), 0);
 
    amxd_dm_clean(&dm);
}

test_get_root_of_mib_is_null()

void test_get_root_of_mib_is_null

(

UNUSED void **

state

)

Definition at line 456 of file test_amxd_mib.c.

                                                       {
    amxd_object_t* mib = NULL;
    amxd_object_t* mib_object = NULL;
    amxd_param_t* param = NULL;
 
    test_build_dm();
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_object_new(&mib_object, amxd_object_singleton, "MibChild"), 0);
    assert_int_equal(amxd_object_add_object(mib, mib_object), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_ptr_equal(amxd_object_get_root(mib), NULL);
 
    amxd_dm_clean(&dm);
}

test_mib_cleanup_data()

static amxd_status_t test_mib_cleanup_data ( amxd_object_t *const  object, amxd_param_t *const  param, amxd_action_t  reason, UNUSED const amxc_var_t *const  args, UNUSED amxc_var_t *const  retval, void *  priv  )

static

Definition at line 100 of file test_amxd_mib.c.

                                                       {
    amxd_status_t status = amxd_status_ok;
    amxc_var_t* data = (amxc_var_t*) priv;
 
    // action private data must not be removed when the action is used
    // on derivced objects.
    // only remove action data when the action is owned by the object or
    // parameter on which the action is called.
    if(reason == action_object_destroy) {
        if(amxd_object_has_action_cb(object, reason, test_mib_cleanup_data)) {
            amxc_var_delete(&data);
            amxd_object_set_action_cb_data(object, reason, test_mib_cleanup_data, NULL);
        }
    } else {
        if(amxd_param_has_action_cb(param, reason, test_mib_cleanup_data)) {
            amxc_var_delete(&data);
            amxd_param_set_action_cb_data(param, reason, test_mib_cleanup_data, NULL);
        }
    }
 
    return status;
}

test_mib_events()

void test_mib_events

(

UNUSED void **

state

)

Definition at line 751 of file test_amxd_mib.c.

                                          {
    amxd_object_t* mib = NULL;
    amxd_object_t* object = NULL;
    amxd_object_t* instance = NULL;
    amxd_param_t* param = NULL;
    int counter = 0;
 
    test_build_dm();
 
    amxp_slot_connect_filtered(&dm.sigmngr, "dm:mib-*", NULL, test_event_handler, &counter);
 
    object = amxd_dm_findf(&dm, "TestObject.TemplObject");
    assert_ptr_not_equal(object, NULL);
    assert_int_equal(amxd_object_new_instance(&instance, object, NULL, 0, NULL), 0);
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib1"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_equal(amxd_object_add_mib(instance, "TestMib1"), 0);
    while(amxp_signal_read() == 0) {
    }
    assert_int_equal(counter, 1);
 
    assert_int_equal(amxd_object_remove_mib(instance, "TestMib1"), 0);
    while(amxp_signal_read() == 0) {
    }
    assert_int_equal(counter, 0);
 
    amxd_dm_clean(&dm);
}

test_mib_not_removed_when_not_added()

void test_mib_not_removed_when_not_added

(

UNUSED void **

state

)

Definition at line 719 of file test_amxd_mib.c.

                                                              {
    amxd_object_t* mib = NULL;
    amxd_object_t* object = NULL;
    amxd_param_t* param = NULL;
 
    object = test_build_dm();
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib2"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_equal(amxd_object_add_mib(object, "TestMib"), 0);
    assert_true(amxd_object_has_mib(object, "TestMib"));
    assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
 
    assert_false(amxd_object_has_mib(object, "TestMib2"));
    assert_int_equal(amxd_object_remove_mib(object, "TestMib2"), 0);
    assert_ptr_not_equal(amxd_object_get_param_def(object, "MibParam1"), NULL);
 
    amxd_dm_clean(&dm);
}

test_object_get_mibs()

void test_object_get_mibs

(

UNUSED void **

state

)

Definition at line 897 of file test_amxd_mib.c.

                                               {
    amxd_object_t* mib = NULL;
    amxd_object_t* object = NULL;
    char* mib_names = NULL;
 
    object = test_build_dm();
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib2"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    mib_names = amxd_object_get_mibs(object);
    assert_null(mib_names);
 
    assert_int_equal(amxd_object_add_mib(object, "TestMib"), 0);
    assert_true(amxd_object_has_mib(object, "TestMib"));
 
    mib_names = amxd_object_get_mibs(object);
    assert_non_null(mib_names);
    assert_string_equal(mib_names, "TestMib");
    free(mib_names);
 
    assert_int_equal(amxd_object_add_mib(object, "TestMib2"), 0);
    assert_true(amxd_object_has_mib(object, "TestMib2"));
 
    mib_names = amxd_object_get_mibs(object);
    assert_non_null(mib_names);
    assert_string_equal(mib_names, "TestMib TestMib2");
    free(mib_names);
 
    assert_int_equal(amxd_object_remove_mib(object, "TestMib"), 0);
    assert_false(amxd_object_has_mib(object, "TestMib"));
 
    mib_names = amxd_object_get_mibs(object);
    assert_non_null(mib_names);
    assert_string_equal(mib_names, "TestMib2");
    free(mib_names);
 
    assert_int_equal(amxd_object_remove_mib(object, "TestMib2"), 0);
    assert_false(amxd_object_has_mib(object, "TestMib2"));
 
    mib_names = amxd_object_get_mibs(object);
    assert_null(mib_names);
 
    amxd_dm_clean(&dm);
}

test_set_attrs_on_mib_fails()

void test_set_attrs_on_mib_fails

(

UNUSED void **

state

)

Definition at line 477 of file test_amxd_mib.c.

                                                      {
    amxd_object_t* mib = NULL;
    amxd_object_t* mib_object = NULL;
    amxd_param_t* param = NULL;
 
    test_build_dm();
 
    assert_int_equal(amxd_mib_new(&mib, "TestMib"), 0);
    assert_ptr_not_equal(mib, NULL);
    assert_int_equal(amxd_object_get_type(mib), amxd_object_mib);
    assert_int_equal(amxd_param_new(&param, "MibParam1", AMXC_VAR_ID_UINT32), 0);
    assert_int_equal(amxd_object_add_param(mib, param), 0);
    assert_int_equal(amxd_object_new(&mib_object, amxd_object_singleton, "MibChild"), 0);
    assert_int_equal(amxd_object_add_object(mib, mib_object), 0);
    assert_int_equal(amxd_dm_store_mib(&dm, mib), 0);
 
    assert_int_not_equal(amxd_object_set_attr(mib, amxd_oattr_read_only, true), 0);
    assert_int_equal(amxd_object_set_attr(mib_object, amxd_oattr_read_only, true), 0);
 
    amxd_dm_clean(&dm);
}

Variable Documentation

dm

amxd_dm_t dm

static

Definition at line 84 of file test_amxd_mib.c.