void test__type_get_type__invalid(void** state)
{
_typeinfo_t t_info;
_type_get_type(&t_info, "abcdefg_t");
assert_true(t_info._t_style == _TYPE_INVALID);
assert_true(t_info._pt_type == NULL);
}
void _type_get_type_pair(_typeinfo_t* pt_typeinfofirst, _typeinfo_t* pt_typeinfosecond, const char* s_typename)
{
/* this function get type information for pair_t and relation container */
char s_firsttypename[_TYPE_NAME_SIZE + 1];
char s_secondtypename[_TYPE_NAME_SIZE + 1];
char* pc_commapos = NULL;
char* pc_newstart = NULL;
assert(pt_typeinfofirst != NULL);
assert(pt_typeinfosecond != NULL);
assert(s_typename != NULL);
pt_typeinfofirst->_t_style = _TYPE_INVALID;
pt_typeinfofirst->_pt_type = NULL;
pt_typeinfosecond->_t_style = _TYPE_INVALID;
pt_typeinfosecond->_pt_type = NULL;
/* the type name is separated in two section by comma */
pc_newstart = (char*)s_typename;
while ((pc_commapos = strchr(pc_newstart, _CSTL_COMMA)) != NULL) {
s_firsttypename[0] = s_firsttypename[_TYPE_NAME_SIZE] = '\0';
s_secondtypename[0] = s_secondtypename[_TYPE_NAME_SIZE] = '\0';
strncpy(s_firsttypename, s_typename, pc_commapos - s_typename);
s_firsttypename[pc_commapos - s_typename] = '\0';
strncpy(s_secondtypename, pc_commapos + 1, _TYPE_NAME_SIZE);
_type_get_type(pt_typeinfofirst, s_firsttypename);
_type_get_type(pt_typeinfosecond, s_secondtypename);
if (pt_typeinfofirst->_t_style != _TYPE_INVALID && pt_typeinfofirst->_pt_type != NULL &&
pt_typeinfosecond->_t_style != _TYPE_INVALID && pt_typeinfosecond->_pt_type != NULL) {
return;
}
pt_typeinfofirst->_t_style = _TYPE_INVALID;
pt_typeinfofirst->_pt_type = NULL;
pt_typeinfosecond->_t_style = _TYPE_INVALID;
pt_typeinfosecond->_pt_type = NULL;
pc_newstart = pc_commapos + 1;
}
}
void test__type_get_type__cstl_container(void** state)
{
_typeinfo_t t_info;
_type_get_type(&t_info, "deque_t<int>");
assert_true(t_info._t_style == _TYPE_CSTL_BUILTIN);
assert_true(strncmp(t_info._s_typename, "deque_t<int>", _TYPE_NAME_SIZE) == 0);
assert_true(t_info._pt_type != NULL);
assert_true(t_info._pt_type->_t_typesize == sizeof(deque_t));
assert_true(strncmp(t_info._pt_type->_s_typename, "deque_t", _TYPE_NAME_SIZE) == 0);
assert_true(t_info._pt_type->_t_typeinit == _type_init_deque);
assert_true(t_info._pt_type->_t_typeless == _type_less_deque);
assert_true(t_info._pt_type->_t_typecopy == _type_copy_deque);
assert_true(t_info._pt_type->_t_typedestroy == _type_destroy_deque);
}
void test__type_get_type__cstl_iterator(void** state)
{
_typeinfo_t t_info;
_type_get_type(&t_info, "vector_iterator_t");
assert_true(t_info._t_style == _TYPE_CSTL_BUILTIN);
assert_true(strncmp(t_info._s_typename, "vector_iterator_t", _TYPE_NAME_SIZE) == 0);
assert_true(t_info._pt_type != NULL);
assert_true(t_info._pt_type->_t_typesize == sizeof(iterator_t));
assert_true(strncmp(t_info._pt_type->_s_typename, "iterator_t", _TYPE_NAME_SIZE) == 0);
assert_true(t_info._pt_type->_t_typeinit == _type_init_iterator);
assert_true(t_info._pt_type->_t_typeless == _type_less_iterator);
assert_true(t_info._pt_type->_t_typecopy == _type_copy_iterator);
assert_true(t_info._pt_type->_t_typedestroy == _type_destroy_iterator);
}
void test__type_get_type__c_builtin(void** state)
{
_typeinfo_t t_info;
_type_get_type(&t_info, "unsigned int");
assert_true(t_info._t_style == _TYPE_C_BUILTIN);
assert_true(strncmp(t_info._s_typename, "unsigned int", _TYPE_NAME_SIZE) == 0);
assert_true(t_info._pt_type != NULL);
assert_true(t_info._pt_type->_t_typesize == sizeof(unsigned int));
assert_true(strncmp(t_info._pt_type->_s_typename, "unsigned int", _TYPE_NAME_SIZE) == 0);
assert_true(t_info._pt_type->_t_typeinit == _type_init_uint);
assert_true(t_info._pt_type->_t_typeless == _type_less_uint);
assert_true(t_info._pt_type->_t_typecopy == _type_copy_uint);
assert_true(t_info._pt_type->_t_typedestroy == _type_destroy_uint);
}
/**
* Create slist container auxiliary function.
*/
bool_t _create_slist_auxiliary(slist_t* pslist_slist, const char* s_typename)
{
assert(pslist_slist != NULL);
assert(s_typename != NULL);
_type_get_type(&pslist_slist->_t_typeinfo, s_typename);
if (pslist_slist->_t_typeinfo._t_style == _TYPE_INVALID) {
return false;
}
pslist_slist->_t_head._pt_next = NULL;
_alloc_init(&pslist_slist->_t_allocator);
return true;
}
void test__type_get_type__user_define(void** state)
{
_typeinfo_t t_info;
type_register(struct _test__type_get_type, NULL, NULL, NULL, NULL);
type_duplicate(struct _test__type_get_type, _test__type_get_type_t);
_type_get_type(&t_info, "_test__type_get_type_t");
assert_true(t_info._t_style == _TYPE_USER_DEFINE);
assert_true(strncmp(t_info._s_typename, "_test__type_get_type_t", _TYPE_NAME_SIZE) == 0);
assert_true(t_info._pt_type != NULL);
assert_true(t_info._pt_type->_t_typesize == sizeof(_test__type_get_type_t));
assert_true(strncmp(t_info._pt_type->_s_typename, "struct _test__type_get_type", _TYPE_NAME_SIZE) == 0);
assert_true(t_info._pt_type->_t_typeinit == _type_init_default);
assert_true(t_info._pt_type->_t_typeless == _type_less_default);
assert_true(t_info._pt_type->_t_typecopy == _type_copy_default);
assert_true(t_info._pt_type->_t_typedestroy == _type_destroy_default);
}
/**
* Create vector container auxiliary function.
*/
bool_t _create_vector_auxiliary(vector_t* pvec_vector, const char* s_typename)
{
assert(pvec_vector != NULL);
assert(s_typename != NULL);
_type_get_type(&pvec_vector->_t_typeinfo, s_typename);
if (pvec_vector->_t_typeinfo._t_style == _TYPE_INVALID) {
return false;
}
pvec_vector->_pby_start = NULL;
pvec_vector->_pby_finish = NULL;
pvec_vector->_pby_endofstorage = NULL;
_alloc_init(&pvec_vector->_t_allocator);
return true;
}
/**
* Create avl tree container auxiliary function.
*/
bool_t _create_avl_tree_auxiliary(_avl_tree_t* pt_avl_tree, const char* s_typename)
{
assert(pt_avl_tree != NULL);
assert(s_typename != NULL);
/* get type information */
_type_get_type(&pt_avl_tree->_t_typeinfo, s_typename);
if(pt_avl_tree->_t_typeinfo._t_style == _TYPE_INVALID)
{
return false;
}
pt_avl_tree->_t_avlroot._pt_parent = NULL;
pt_avl_tree->_t_avlroot._pt_left = NULL;
pt_avl_tree->_t_avlroot._pt_right = NULL;
pt_avl_tree->_t_avlroot._un_height = 0;
pt_avl_tree->_t_nodecount = 0;
pt_avl_tree->_t_compare = NULL;
_alloc_init(&pt_avl_tree->_t_allocator);
return true;
}
void test__type_get_type__null_typename(void** state)
{
_typeinfo_t t_info;
expect_assert_failure(_type_get_type(&t_info, NULL));
}
void test__type_get_type__null_typeinfo(void** state)
{
expect_assert_failure(_type_get_type(NULL, "int"));
}
