void test__rb_tree_iterator_before__not_same_rb_tree(void** state)
{
    _rb_tree_t* pt_first = _create_rb_tree("int");
    _rb_tree_t* pt_second = _create_rb_tree("int");
    _rb_tree_iterator_t it_first;
    _rb_tree_iterator_t it_second;

    _rb_tree_init(pt_first, NULL);
    _rb_tree_init(pt_second, NULL);
    it_first = _rb_tree_begin(pt_first);
    it_second = _rb_tree_begin(pt_second);
    expect_assert_failure(_rb_tree_iterator_before(it_first, it_second));

    _rb_tree_destroy(pt_first);
    _rb_tree_destroy(pt_second);
}
void test__create_rb_tree_auxiliary__cstr(void** state)
{
    _rb_tree_t* pt_rb_tree = malloc(sizeof(_rb_tree_t));
    assert_true(_create_rb_tree_auxiliary(pt_rb_tree, "char*"));
    assert_true(_rb_tree_is_created(pt_rb_tree));

    _rb_tree_destroy(pt_rb_tree);
}
void test__create_rb_tree_auxiliary__libcstl_builtin(void** state)
{
    _rb_tree_t* pt_rb_tree = malloc(sizeof(_rb_tree_t));
    assert_true(_create_rb_tree_auxiliary(pt_rb_tree, "vector_t<int>"));
    assert_true(_rb_tree_is_created(pt_rb_tree));

    _rb_tree_destroy(pt_rb_tree);
}
Beispiel #4
0
/**
 * Destroy set.
 */
void set_destroy(set_t* pset_set)
{
    assert(pset_set != NULL);

#ifdef CSTL_SET_AVL_TREE
    _avl_tree_destroy(&pset_set->_t_tree);
#else
    _rb_tree_destroy(&pset_set->_t_tree);
#endif
}
void test__rb_tree_destroy_auxiliary__non_created(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("int");

    pt_rb_tree->_t_rbroot._t_color = _COLOR_BLACK;
    expect_assert_failure(_rb_tree_destroy_auxiliary(pt_rb_tree));
    pt_rb_tree->_t_rbroot._t_color = _COLOR_RED;

    _rb_tree_destroy(pt_rb_tree);
}
Beispiel #6
0
/**
 * Destroy multiset.
 */
void multiset_destroy(multiset_t* pmset_mset)
{
    assert(pmset_mset != NULL);

#ifdef CSTL_MULTISET_AVL_TREE
    _avl_tree_destroy(&pmset_mset->_t_tree);
#else
    _rb_tree_destroy(&pmset_mset->_t_tree);
#endif
}
void test__rb_tree_iterator_get_value__null_value(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("int");
    _rb_tree_iterator_t it_iter;
    _rb_tree_init(pt_rb_tree, NULL);

    it_iter = _rb_tree_end(pt_rb_tree);

    expect_assert_failure(_rb_tree_iterator_get_value(it_iter, NULL));

    _rb_tree_destroy(pt_rb_tree);
}
void test__create_rb_tree_auxiliary__user_define(void** state)
{
    _rb_tree_t* pt_rb_tree = NULL;

    type_register(_test__create_rb_tree_auxiliary__user_define_t, NULL, NULL, NULL, NULL);

    pt_rb_tree = malloc(sizeof(_rb_tree_t));
    assert_true(_create_rb_tree_auxiliary(pt_rb_tree, "_test__create_rb_tree_auxiliary__user_define_t"));
    assert_true(_rb_tree_is_created(pt_rb_tree));

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_next__end(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("int");
    _rb_tree_iterator_t it_iter;
    _rb_tree_init(pt_rb_tree, NULL);

    it_iter = _rb_tree_end(pt_rb_tree);

    expect_assert_failure(_rb_tree_iterator_next(it_iter));

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_get_pointer__c_builtin(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("int");
    _rb_tree_iterator_t it_iter;
    int elem = 12;
    _rb_tree_init(pt_rb_tree, NULL);
    _rb_tree_insert_unique(pt_rb_tree, &elem);

    it_iter = _rb_tree_begin(pt_rb_tree);
    assert_true(*(int*)_rb_tree_iterator_get_pointer(it_iter) == 12);

    _rb_tree_destroy(pt_rb_tree);
}
Beispiel #11
0
void multimap_destroy(multimap_t* pt_multimap)
{
    assert(pt_multimap != NULL);

    /* destroy pair */
    pair_destroy(&pt_multimap->_t_pair);
    /* destroy tree */
#ifdef CSTL_MULTIMAP_AVL_TREE
    _avl_tree_destroy(_GET_MULTIMAP_AVL_TREE(pt_multimap));
#else
    _rb_tree_destroy(_GET_MULTIMAP_RB_TREE(pt_multimap));
#endif
}
void test__rb_tree_iterator_prev__null_tree(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("int");
    _rb_tree_iterator_t it_iter;
    _rb_tree_init(pt_rb_tree, NULL);

    it_iter = _rb_tree_begin(pt_rb_tree);

    it_iter._t_pos._t_treepos._pt_tree = NULL;
    expect_assert_failure(_rb_tree_iterator_prev(it_iter));

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_get_pointer__cstr(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("char*");
    _rb_tree_iterator_t it_iter;
    string_t* pstr = create_string();
    string_init_cstr(pstr, "abc");
    _rb_tree_init(pt_rb_tree, NULL);
    _rb_tree_insert_unique(pt_rb_tree, pstr);

    it_iter = _rb_tree_begin(pt_rb_tree);
    assert_true(strcmp((char*)_rb_tree_iterator_get_pointer(it_iter), "abc") == 0);

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_get_pointer__libcstl_builtin(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("vector_t<int>");
    _rb_tree_iterator_t it_iter;
    vector_t* pvec = create_vector(int);
    _rb_tree_init(pt_rb_tree, NULL);
    vector_init_n(pvec, 10);
    _rb_tree_insert_unique(pt_rb_tree, pvec);

    it_iter = _rb_tree_begin(pt_rb_tree);
    assert_true(vector_size((vector_t*)_rb_tree_iterator_get_pointer(it_iter)) == 10);

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_get_value__null_tree(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("int");
    _rb_tree_iterator_t it_iter;
    int elem = 0;
    _rb_tree_init(pt_rb_tree, NULL);

    it_iter = _rb_tree_begin(pt_rb_tree);

    it_iter._t_pos._t_treepos._pt_tree = NULL;
    expect_assert_failure(_rb_tree_iterator_get_value(it_iter, &elem));

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_before__invalid_second(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("int");
    _rb_tree_iterator_t it_first;
    _rb_tree_iterator_t it_second;

    _rb_tree_init(pt_rb_tree, NULL);
    it_first = _rb_tree_begin(pt_rb_tree);
    it_second = _rb_tree_begin(pt_rb_tree);
    it_second._t_pos._t_treepos._pby_corepos = NULL;
    expect_assert_failure(_rb_tree_iterator_before(it_first, it_second));

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_prev__begin(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("int");
    _rb_tree_iterator_t it_iter;
    int elem = 100;
    _rb_tree_init(pt_rb_tree, NULL);
    _rb_tree_insert_unique(pt_rb_tree, &elem);

    it_iter = _rb_tree_begin(pt_rb_tree);

    expect_assert_failure(_rb_tree_iterator_prev(it_iter));

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_before__equal(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("int");
    _rb_tree_iterator_t it_first;
    _rb_tree_iterator_t it_second;
    int elem = 100;

    _rb_tree_init(pt_rb_tree, NULL);
    _rb_tree_insert_unique(pt_rb_tree, &elem);
    it_first = _rb_tree_begin(pt_rb_tree);
    it_second = _rb_tree_begin(pt_rb_tree);
    assert_false(_rb_tree_iterator_before(it_first, it_second));

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_distance__0(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("int");
    _rb_tree_iterator_t it_first;
    _rb_tree_iterator_t it_second;
    int elem = 100;

    _rb_tree_init(pt_rb_tree, NULL);
    _rb_tree_insert_unique(pt_rb_tree, &elem);
    it_first = _rb_tree_begin(pt_rb_tree);
    it_second = _rb_tree_begin(pt_rb_tree);
    assert_true(_rb_tree_iterator_distance(it_first, it_second) == 0);

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_prev__end(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("int");
    _rb_tree_iterator_t it_iter;
    int elem = 10;
    _rb_tree_init(pt_rb_tree, NULL);

    _rb_tree_insert_unique(pt_rb_tree, &elem);
    it_iter = _rb_tree_end(pt_rb_tree);

    it_iter = _rb_tree_iterator_prev(it_iter);
    assert_true(_rb_tree_iterator_equal(it_iter, _rb_tree_begin(pt_rb_tree)));

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_prev__last(void** state)
{
    _rb_tree_t* pt_rb_tree = _create_rb_tree("int");
    _rb_tree_iterator_t it_iter;
    int elem = 10;
    _rb_tree_init(pt_rb_tree, NULL);

    _rb_tree_insert_unique(pt_rb_tree, &elem);
    elem = 3;
    _rb_tree_insert_unique(pt_rb_tree, &elem);
    it_iter = _rb_tree_iterator_prev(_rb_tree_end(pt_rb_tree));
    assert_true(*(int*)_rb_tree_iterator_get_pointer(it_iter) == 10);
    it_iter = _rb_tree_iterator_prev(it_iter);
    assert_true(*(int*)_rb_tree_iterator_get_pointer(it_iter) == 3);

    _rb_tree_destroy(pt_rb_tree);
}
void test__rb_tree_iterator_get_pointer__user_define(void** state)
{
    _rb_tree_t* pt_rb_tree = NULL;
    _rb_tree_iterator_t it_iter;
    _test__rb_tree_iterator_get_pointer__user_define_t elem;

    type_register(_test__rb_tree_iterator_get_pointer__user_define_t, NULL, NULL, NULL, NULL);
    pt_rb_tree = _create_rb_tree("_test__rb_tree_iterator_get_pointer__user_define_t");
    _rb_tree_init(pt_rb_tree, NULL);
    elem.elem = 100;
    _rb_tree_insert_unique(pt_rb_tree, &elem);

    it_iter = _rb_tree_begin(pt_rb_tree);
    assert_true(((_test__rb_tree_iterator_get_pointer__user_define_t*)_rb_tree_iterator_get_pointer(it_iter))->elem == 100);

    _rb_tree_destroy(pt_rb_tree);
}