void test__create_slist_auxiliary__c_builtin(void** state)
{
    slist_t* pslist = malloc(sizeof(slist_t));
    assert_true(_create_slist_auxiliary(pslist, "double"));
    assert_true(strcmp(_GET_SLIST_TYPE_NAME(pslist), "double") == 0);
    assert_true(_slist_is_created(pslist));

    slist_destroy(pslist);
}
void test__create_slist__c_builtin_type(void** state)
{
    slist_t* pslist = _create_slist("unsigned int");
    assert_true(pslist != NULL);
    assert_true(strcmp(_GET_SLIST_TYPE_NAME(pslist), "unsigned int") == 0);
    assert_true(_slist_is_created(pslist));

    slist_destroy(pslist);
}
void test__create_slist_auxiliary__libcstl_builtin(void** state)
{
    slist_t* pslist = malloc(sizeof(slist_t));
    assert_true(_create_slist_auxiliary(pslist, "slist_t<   vector_t     <     string_t>>       "));
    assert_true(strcmp(_GET_SLIST_TYPE_NAME(pslist), "slist_t<vector_t<string_t>>") == 0);
    assert_true(_slist_is_created(pslist));

    slist_destroy(pslist);
}
Exemple #4
0
/**
 * Obtain data from variable argument slist, the data type and slist element data type are same.
 */
void _slist_get_varg_value_auxiliary(slist_t* pslist_slist, va_list val_elemlist, _slistnode_t* pt_node)
{
    assert(pslist_slist != NULL);
    assert(pt_node != NULL);
    assert(_slist_is_inited(pslist_slist) || _slist_is_created(pslist_slist));

    _slist_init_node_auxiliary(pslist_slist, pt_node);
    _type_get_varg_value(&pslist_slist->_t_typeinfo, val_elemlist, pt_node->_pby_data);
}
void test__create_slist_auxiliary__user_defined_dup(void** state)
{
    slist_t* pslist = NULL;
    type_duplicate(struct _tag_test__create_slist_auxiliary__user_defined, _test__create_slist_auxiliary__user_defined_t);
    pslist = malloc(sizeof(slist_t));
    assert_true(_create_slist_auxiliary(pslist, "_test__create_slist_auxiliary__user_defined_t"));
    assert_true(strcmp(_GET_SLIST_TYPE_NAME(pslist), "_test__create_slist_auxiliary__user_defined_t") == 0);
    assert_true(_slist_is_created(pslist));

    slist_destroy(pslist);
}
Exemple #6
0
/**
 * Initialize slist with specified element.
 */
void _slist_init_elem(slist_t* pslist_slist, size_t t_count, ...)
{
    va_list val_elemlist;

    assert(pslist_slist != NULL);
    assert(_slist_is_created(pslist_slist));

    va_start(val_elemlist, t_count);
    _slist_init_elem_varg(pslist_slist, t_count, val_elemlist);
    va_end(val_elemlist);
}
void test__create_slist__user_defined_type_dup(void** state)
{
    slist_t* pslist = NULL;

    type_duplicate(struct _tag_test__create_slist__user_defined_type, _test__create_slist__user_defined_type_t);
    pslist = _create_slist("_test__create_slist__user_defined_type_t");
    assert_true(pslist != NULL);
    assert_true(strcmp(_GET_SLIST_TYPE_NAME(pslist), "_test__create_slist__user_defined_type_t") == 0);
    assert_true(_slist_is_created(pslist));

    slist_destroy(pslist);
}
void test__create_slist__user_defined_type(void** state)
{
    slist_t* pslist = NULL;

    type_register(struct _tag_test__create_slist__user_defined_type, NULL, NULL, NULL, NULL);
    pslist = _create_slist("struct      _tag_test__create_slist__user_defined_type");
    assert_true(pslist != NULL);
    assert_true(strcmp(_GET_SLIST_TYPE_NAME(pslist), "struct _tag_test__create_slist__user_defined_type") == 0);
    assert_true(_slist_is_created(pslist));

    slist_destroy(pslist);
}
Exemple #9
0
/**
 * Destroy data, the data type and slist element data type are same.
 */
void _slist_destroy_varg_value_auxiliary(slist_t* pslist_slist, _slistnode_t* pt_node)
{
    bool_t b_result = false;

    assert(pslist_slist != NULL);
    assert(pt_node != NULL);
    assert(_slist_is_inited(pslist_slist) || _slist_is_created(pslist_slist));

    b_result = _GET_SLIST_TYPE_SIZE(pslist_slist);
    _GET_SLIST_TYPE_DESTROY_FUNCTION(pslist_slist)(pt_node->_pby_data, &b_result);
    assert(b_result);
}
Exemple #10
0
/**
 * Initialize element with slist element type auxiliary function.
 */
void _slist_init_elem_auxiliary(slist_t* pslist_slist, void* pv_value)
{
    assert(pslist_slist != NULL);
    assert(pv_value != NULL);
    assert(_slist_is_inited(pslist_slist) || _slist_is_created(pslist_slist));

    /* initialize new elements */
    if (_GET_SLIST_TYPE_STYLE(pslist_slist) == _TYPE_CSTL_BUILTIN) {
        /* get element type name */
        char s_elemtypename[_TYPE_NAME_SIZE + 1];
        _type_get_elem_typename(_GET_SLIST_TYPE_NAME(pslist_slist), s_elemtypename);

        _GET_SLIST_TYPE_INIT_FUNCTION(pslist_slist)(pv_value, s_elemtypename);
    } else {
        bool_t b_result = _GET_SLIST_TYPE_SIZE(pslist_slist);
        _GET_SLIST_TYPE_INIT_FUNCTION(pslist_slist)(pv_value, &b_result);
        assert(b_result);
    }
}
Exemple #11
0
/**
 * Initialize slist with variable argument slist of specified element.
 */
void _slist_init_elem_varg(slist_t* pslist_slist, size_t t_count, va_list val_elemlist)
{
    _slistnode_t* pt_varg = NULL;
    bool_t        b_result = false;

    assert(pslist_slist != NULL);
    assert(_slist_is_created(pslist_slist));

    /* allocate memory for n_elemcount slist node */
    if (t_count > 0) {
        size_t        i = 0;
        _slistnode_t* pt_node = NULL;

        /* get varg value only once */
        pt_varg = _alloc_allocate(&pslist_slist->_t_allocator, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1);
        assert(pt_varg != NULL);
        _slist_get_varg_value_auxiliary(pslist_slist, val_elemlist, pt_varg);

        for (i = 0; i < t_count; ++i) {
            pt_node = _alloc_allocate(&pslist_slist->_t_allocator, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1);
            assert(pt_node != NULL);
            _slist_init_node_auxiliary(pslist_slist, pt_node);
            /* copy value from varg */
            b_result = _GET_SLIST_TYPE_SIZE(pslist_slist);
            _GET_SLIST_TYPE_COPY_FUNCTION(pslist_slist)(pt_node->_pby_data, pt_varg->_pby_data, &b_result);
            assert(b_result);

            /* insert the new slist node after the head */
            pt_node->_pt_next = pslist_slist->_t_head._pt_next;
            pslist_slist->_t_head._pt_next = pt_node;
            pt_node = NULL;
        }

        _slist_destroy_varg_value_auxiliary(pslist_slist, pt_varg);
        _alloc_deallocate(&pslist_slist->_t_allocator, pt_varg, _SLIST_NODE_SIZE(_GET_SLIST_TYPE_SIZE(pslist_slist)), 1);
    }
}