723 lines
23 KiB
C
723 lines
23 KiB
C
#ifndef CMC_TESTS_UNT_HASHBIDIMAP_H
|
|
#define CMC_TESTS_UNT_HASHBIDIMAP_H
|
|
|
|
#include "utl.h"
|
|
|
|
#define V size_t
|
|
#define K size_t
|
|
#define PFX hbm
|
|
#define SNAME hashbidimap
|
|
#include "cmc/hashbidimap.h"
|
|
|
|
struct hashbidimap_fkey *hbm_fkey = &(struct hashbidimap_fkey){
|
|
.cmp = cmc_size_cmp, .cpy = NULL, .str = cmc_size_str, .free = NULL, .hash = cmc_size_hash, .pri = cmc_size_cmp
|
|
};
|
|
|
|
struct hashbidimap_fval *hbm_fval = &(struct hashbidimap_fval){
|
|
.cmp = cmc_size_cmp, .cpy = NULL, .str = cmc_size_str, .free = NULL, .hash = cmc_size_hash, .pri = cmc_size_cmp
|
|
};
|
|
|
|
struct hashbidimap_fkey *hbm_fkey_counter = &(struct hashbidimap_fkey){
|
|
.cmp = k_c_cmp, .cpy = k_c_cpy, .str = k_c_str, .free = k_c_free, .hash = k_c_hash, .pri = k_c_pri
|
|
};
|
|
|
|
struct hashbidimap_fval *hbm_fval_counter = &(struct hashbidimap_fval){
|
|
.cmp = v_c_cmp, .cpy = v_c_cpy, .str = v_c_str, .free = v_c_free, .hash = v_c_hash, .pri = v_c_pri
|
|
};
|
|
|
|
struct cmc_alloc_node *hbm_alloc_node =
|
|
&(struct cmc_alloc_node){ .malloc = malloc, .calloc = calloc, .realloc = realloc, .free = free };
|
|
|
|
CMC_CREATE_UNIT(CMCHashBidiMap, true, {
|
|
CMC_CREATE_TEST(PFX##_new(), {
|
|
struct hashbidimap *map = hbm_new(943722, 0.6, hbm_fkey, hbm_fval);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
cmc_assert_not_equals(ptr, NULL, map->buffer);
|
|
cmc_assert_equals(size_t, 0, map->count);
|
|
cmc_assert_equals(double, 0.6, map->load);
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag);
|
|
cmc_assert_equals(ptr, hbm_fkey, map->f_key);
|
|
cmc_assert_equals(ptr, hbm_fval, map->f_val);
|
|
cmc_assert_equals(ptr, cmc_alloc_node_default.malloc, map->alloc->malloc);
|
|
cmc_assert_equals(ptr, cmc_alloc_node_default.calloc, map->alloc->calloc);
|
|
cmc_assert_equals(ptr, cmc_alloc_node_default.realloc, map->alloc->realloc);
|
|
cmc_assert_equals(ptr, cmc_alloc_node_default.free, map->alloc->free);
|
|
cmc_assert_equals(ptr, NULL, map->callbacks);
|
|
|
|
cmc_assert_greater_equals(size_t, (943722 / 0.6), hbm_capacity(map));
|
|
|
|
hbm_free(map);
|
|
|
|
map = hbm_new(100, 0.6, hbm_fkey, hbm_fval);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
for (size_t i = 0; i < map->capacity; i++)
|
|
{
|
|
cmc_assert_equals(ptr, NULL, map->buffer[i][0]);
|
|
cmc_assert_equals(ptr, NULL, map->buffer[i][1]);
|
|
}
|
|
|
|
hbm_free(map);
|
|
|
|
map = hbm_new(0, 0.6, hbm_fkey, hbm_fval);
|
|
cmc_assert_equals(ptr, NULL, map);
|
|
|
|
map = hbm_new(UINT64_MAX, 0.99, hbm_fkey, hbm_fval);
|
|
cmc_assert_equals(ptr, NULL, map);
|
|
|
|
map = hbm_new(1000, 0.6, hbm_fkey, NULL);
|
|
cmc_assert_equals(ptr, NULL, map);
|
|
|
|
map = hbm_new(1000, 0.6, NULL, hbm_fval);
|
|
cmc_assert_equals(ptr, NULL, map);
|
|
|
|
map = hbm_new(1000, 0.6, NULL, NULL);
|
|
cmc_assert_equals(ptr, NULL, map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(PFX##_new_custom(), {
|
|
struct hashbidimap *map = hbm_new_custom(943722, 0.6, hbm_fkey, hbm_fval, hbm_alloc_node, callbacks);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
cmc_assert_not_equals(ptr, NULL, map->buffer);
|
|
cmc_assert_equals(size_t, 0, map->count);
|
|
cmc_assert_equals(double, 0.6, map->load);
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag);
|
|
cmc_assert_equals(ptr, hbm_fkey, map->f_key);
|
|
cmc_assert_equals(ptr, hbm_fval, map->f_val);
|
|
cmc_assert_equals(ptr, hbm_alloc_node, map->alloc);
|
|
cmc_assert_equals(ptr, callbacks, map->callbacks);
|
|
|
|
cmc_assert_greater_equals(size_t, (943722 / 0.6), hbm_capacity(map));
|
|
|
|
hbm_free(map);
|
|
|
|
map = hbm_new_custom(0, 0.6, hbm_fkey, hbm_fval, NULL, NULL);
|
|
cmc_assert_equals(ptr, NULL, map);
|
|
|
|
map = hbm_new_custom(UINT64_MAX, 0.99, hbm_fkey, hbm_fval, NULL, NULL);
|
|
cmc_assert_equals(ptr, NULL, map);
|
|
|
|
map = hbm_new_custom(1000, 0.6, hbm_fkey, NULL, NULL, NULL);
|
|
cmc_assert_equals(ptr, NULL, map);
|
|
|
|
map = hbm_new_custom(1000, 0.6, NULL, hbm_fval, NULL, NULL);
|
|
cmc_assert_equals(ptr, NULL, map);
|
|
|
|
map = hbm_new_custom(1000, 0.6, NULL, NULL, NULL, NULL);
|
|
cmc_assert_equals(ptr, NULL, map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(PFX##_clear(), {
|
|
k_total_free = 0;
|
|
v_total_free = 0;
|
|
struct hashbidimap *map = hbm_new(100, 0.6, hbm_fkey_counter, hbm_fval_counter);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
for (size_t i = 1; i <= 1000; i++)
|
|
hbm_insert(map, i, i);
|
|
|
|
cmc_assert_equals(size_t, 1000, map->count);
|
|
|
|
map->flag = CMC_FLAG_ERROR;
|
|
hbm_clear(map);
|
|
|
|
cmc_assert_equals(size_t, 0, map->count);
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, map->flag);
|
|
cmc_assert_equals(int32_t, 1000, k_total_free);
|
|
cmc_assert_equals(int32_t, 1000, v_total_free);
|
|
|
|
hbm_free(map);
|
|
k_total_free = 0;
|
|
v_total_free = 0;
|
|
});
|
|
|
|
CMC_CREATE_TEST(PFX##_free(), {
|
|
k_total_free = 0;
|
|
v_total_free = 0;
|
|
struct hashbidimap *map = hbm_new(100, 0.6, hbm_fkey_counter, hbm_fval_counter);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
for (size_t i = 1; i <= 1000; i++)
|
|
hbm_insert(map, i, i);
|
|
|
|
cmc_assert_equals(size_t, 1000, map->count);
|
|
|
|
hbm_free(map);
|
|
|
|
cmc_assert_equals(int32_t, 1000, k_total_free);
|
|
cmc_assert_equals(int32_t, 1000, v_total_free);
|
|
|
|
map = hbm_new(1000, 0.6, hbm_fkey_counter, hbm_fval_counter);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
cmc_assert_not_equals(ptr, NULL, map->buffer);
|
|
|
|
hbm_free(map);
|
|
|
|
cmc_assert_equals(int32_t, 1000, k_total_free);
|
|
cmc_assert_equals(int32_t, 1000, v_total_free);
|
|
k_total_free = 0;
|
|
v_total_free = 0;
|
|
});
|
|
|
|
CMC_CREATE_TEST(customize, {
|
|
struct hashbidimap *map = hbm_new_custom(100, 0.6, hbm_fkey, hbm_fval, NULL, NULL);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
cmc_assert_equals(ptr, cmc_alloc_node_default.malloc, map->alloc->malloc);
|
|
cmc_assert_equals(ptr, cmc_alloc_node_default.calloc, map->alloc->calloc);
|
|
cmc_assert_equals(ptr, cmc_alloc_node_default.realloc, map->alloc->realloc);
|
|
cmc_assert_equals(ptr, cmc_alloc_node_default.free, map->alloc->free);
|
|
cmc_assert_equals(ptr, NULL, map->callbacks);
|
|
|
|
hbm_free(map);
|
|
|
|
struct cmc_alloc_node node;
|
|
node.malloc = malloc;
|
|
node.realloc = realloc;
|
|
node.free = free;
|
|
node.calloc = calloc;
|
|
|
|
map = hbm_new_custom(100, 0.6, hbm_fkey, hbm_fval, &node, callbacks);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
cmc_assert_equals(ptr, &node, map->alloc);
|
|
cmc_assert_equals(ptr, callbacks, map->callbacks);
|
|
|
|
hbm_free(map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(buffer_growth[capacity = 1], {
|
|
struct hashbidimap *map = hbm_new(1, 0.7, hbm_fkey, hbm_fval);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
for (size_t i = 1; i <= 10000; i++)
|
|
cmc_assert(hbm_insert(map, i, i));
|
|
|
|
size_t sum = 0;
|
|
|
|
for (size_t i = 0; i < hbm_capacity(map); i++)
|
|
{
|
|
if (map->buffer[i][0] && map->buffer[i][0] != CMC_ENTRY_DELETED)
|
|
{
|
|
sum += map->buffer[i][0]->key;
|
|
}
|
|
}
|
|
|
|
cmc_assert_equals(size_t, 50005000, sum);
|
|
|
|
hbm_free(map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(insert, {
|
|
struct hashbidimap *map = hbm_new(100, 0.7, hbm_fkey, hbm_fval);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
cmc_assert(hbm_insert(map, 1, 1));
|
|
cmc_assert(hbm_insert(map, 2, 2));
|
|
cmc_assert(hbm_insert(map, 3, 3));
|
|
|
|
cmc_assert_equals(size_t, 3, hbm_count(map));
|
|
|
|
hbm_free(map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(insert[duplicate], {
|
|
struct hashbidimap *map = hbm_new(100, 0.7, hbm_fkey, hbm_fval);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
cmc_assert(hbm_insert(map, 1, 1));
|
|
cmc_assert(!hbm_insert(map, 1, 1));
|
|
cmc_assert(!hbm_insert(map, 2, 1));
|
|
cmc_assert(!hbm_insert(map, 1, 2));
|
|
cmc_assert(hbm_insert(map, 2, 2));
|
|
|
|
cmc_assert_equals(size_t, 2, hbm_count(map));
|
|
|
|
hbm_free(map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(insert[references], {
|
|
struct hashbidimap *map = hbm_new(500, 0.7, hbm_fkey, hbm_fval);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
for (size_t i = 0; i < 500; i++)
|
|
cmc_assert(hbm_insert(map, i, i));
|
|
|
|
for (size_t i = 0; i < map->capacity; i++)
|
|
{
|
|
struct hashbidimap_entry *kentry = map->buffer[i][0];
|
|
struct hashbidimap_entry *ventry = map->buffer[i][1];
|
|
|
|
if (kentry && kentry != CMC_ENTRY_DELETED)
|
|
cmc_assert_equals(ptr, kentry, *(kentry->ref[0]));
|
|
if (ventry && ventry != CMC_ENTRY_DELETED)
|
|
cmc_assert_equals(ptr, ventry, *(ventry->ref[1]));
|
|
}
|
|
|
|
hbm_free(map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(insert[growth remove clear], {
|
|
struct hashbidimap *map = hbm_new(100, 0.7, hbm_fkey, hbm_fval);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
for (size_t i = 1; i <= 1000; i++)
|
|
cmc_assert(hbm_insert(map, i, i));
|
|
|
|
cmc_assert_equals(size_t, 1000, hbm_count(map));
|
|
|
|
size_t j = 1;
|
|
while (!hbm_empty(map))
|
|
{
|
|
if (hbm_count(map) % 2 == 0)
|
|
cmc_assert(hbm_remove_by_key(map, j++, NULL, NULL));
|
|
else
|
|
cmc_assert(hbm_remove_by_val(map, j++, NULL, NULL));
|
|
}
|
|
|
|
cmc_assert_equals(size_t, 0, hbm_count(map));
|
|
|
|
for (size_t i = 1; i <= 1000; i++)
|
|
cmc_assert(hbm_insert(map, i, i));
|
|
|
|
cmc_assert_equals(size_t, 1000, hbm_count(map));
|
|
|
|
hbm_clear(map);
|
|
|
|
cmc_assert_equals(size_t, 0, hbm_count(map));
|
|
|
|
hbm_free(map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(insert[ftab hash calls], {
|
|
struct hashbidimap *map = hbm_new(100, 0.7, hbm_fkey_counter, hbm_fval_counter);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
k_total_hash = 0;
|
|
v_total_hash = 0;
|
|
|
|
for (size_t i = 1; i <= 1000; i++)
|
|
cmc_assert(hbm_insert(map, i, i));
|
|
|
|
cmc_assert_greater_equals(int32_t, 1000, k_total_hash);
|
|
cmc_assert_greater_equals(int32_t, 1000, v_total_hash);
|
|
|
|
hbm_free(map);
|
|
|
|
k_total_hash = 0;
|
|
v_total_hash = 0;
|
|
});
|
|
|
|
CMC_CREATE_TEST(update_key, {
|
|
struct hashbidimap *map = hbm_new(100, 0.7, hbm_fkey, hbm_fval);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
for (size_t i = 1; i <= 100; i++)
|
|
cmc_assert(hbm_insert(map, i, i));
|
|
|
|
cmc_assert_equals(size_t, 100, hbm_count(map));
|
|
|
|
for (size_t i = 100; i > 0; i--)
|
|
cmc_assert(hbm_update_key(map, i, i + 10));
|
|
|
|
cmc_assert_equals(size_t, 100, hbm_count(map));
|
|
|
|
for (size_t i = 1; i <= 100; i++)
|
|
cmc_assert_equals(size_t, i + 10, hbm_get_key(map, i));
|
|
|
|
cmc_assert_equals(size_t, 100, hbm_count(map));
|
|
|
|
hbm_free(map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(update_key[empty], {
|
|
struct hashbidimap *map = hbm_new(100, 0.7, hbm_fkey, hbm_fval);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
cmc_assert_equals(size_t, 0, hbm_count(map));
|
|
|
|
cmc_assert(!hbm_update_key(map, 1, 1));
|
|
|
|
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hbm_flag(map));
|
|
|
|
hbm_free(map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(update_key[not_found duplicate], {
|
|
struct hashbidimap *map = hbm_new(100, 0.7, hbm_fkey, hbm_fval);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
cmc_assert(hbm_insert(map, 1, 1));
|
|
|
|
cmc_assert_equals(size_t, 1, hbm_count(map));
|
|
|
|
map->flag = CMC_FLAG_ERROR;
|
|
cmc_assert(hbm_update_key(map, 1, 1));
|
|
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map));
|
|
|
|
cmc_assert(!hbm_update_key(map, 2, 2));
|
|
|
|
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map));
|
|
|
|
cmc_assert(hbm_insert(map, 2, 2));
|
|
|
|
cmc_assert(!hbm_update_key(map, 1, 2));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map));
|
|
cmc_assert(!hbm_update_key(map, 2, 1));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map));
|
|
|
|
cmc_assert(hbm_update_key(map, 2, 2));
|
|
|
|
hbm_free(map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(update_val, {
|
|
struct hashbidimap *map = hbm_new(100, 0.7, hbm_fkey, hbm_fval);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
for (size_t i = 1; i <= 100; i++)
|
|
cmc_assert(hbm_insert(map, i, i));
|
|
|
|
cmc_assert_equals(size_t, 100, hbm_count(map));
|
|
|
|
for (size_t i = 100; i > 0; i--)
|
|
cmc_assert(hbm_update_val(map, i, i + 10));
|
|
|
|
cmc_assert_equals(size_t, 100, hbm_count(map));
|
|
|
|
for (size_t i = 1; i <= 100; i++)
|
|
cmc_assert_equals(size_t, i + 10, hbm_get_val(map, i));
|
|
|
|
cmc_assert_equals(size_t, 100, hbm_count(map));
|
|
|
|
hbm_free(map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(update_val[empty], {
|
|
struct hashbidimap *map = hbm_new(100, 0.7, hbm_fkey, hbm_fval);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
cmc_assert_equals(size_t, 0, hbm_count(map));
|
|
|
|
cmc_assert(!hbm_update_val(map, 1, 1));
|
|
|
|
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hbm_flag(map));
|
|
|
|
hbm_free(map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(update_val[not_found duplicate], {
|
|
struct hashbidimap *map = hbm_new(100, 0.7, hbm_fkey, hbm_fval);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
cmc_assert(hbm_insert(map, 1, 1));
|
|
|
|
cmc_assert_equals(size_t, 1, hbm_count(map));
|
|
|
|
map->flag = CMC_FLAG_ERROR;
|
|
cmc_assert(hbm_update_val(map, 1, 1));
|
|
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map));
|
|
|
|
cmc_assert(!hbm_update_val(map, 2, 2));
|
|
|
|
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map));
|
|
|
|
cmc_assert(hbm_insert(map, 2, 2));
|
|
|
|
cmc_assert(!hbm_update_val(map, 1, 2));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map));
|
|
cmc_assert(!hbm_update_val(map, 2, 1));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map));
|
|
|
|
cmc_assert(hbm_update_val(map, 2, 2));
|
|
|
|
hbm_free(map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(remove_by_key[cleanup custom], {
|
|
struct hashbidimap *map = hbm_new_custom(
|
|
10000, 0.6, hbm_fkey, hbm_fval,
|
|
&(struct cmc_alloc_node){ .malloc = malloc, .calloc = calloc, .realloc = realloc, .free = free },
|
|
callbacks);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
for (size_t i = 0; i < 10000; i++)
|
|
{
|
|
cmc_assert(hbm_insert(map, i, i));
|
|
}
|
|
|
|
for (size_t i = 0; i < 10000; i++)
|
|
{
|
|
cmc_assert(hbm_remove_by_key(map, i, NULL, NULL));
|
|
}
|
|
|
|
for (size_t i = 0; i < map->capacity; i++)
|
|
{
|
|
struct hashbidimap_entry *k = map->buffer[i][0];
|
|
struct hashbidimap_entry *v = map->buffer[i][1];
|
|
|
|
cmc_assert((k == NULL || k == CMC_ENTRY_DELETED) && (v == NULL || v == CMC_ENTRY_DELETED));
|
|
}
|
|
|
|
hbm_free(map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(remove_by_val[cleanup custom], {
|
|
struct hashbidimap *map = hbm_new_custom(
|
|
10000, 0.6, hbm_fkey, hbm_fval,
|
|
&(struct cmc_alloc_node){ .malloc = malloc, .calloc = calloc, .realloc = realloc, .free = free },
|
|
callbacks);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
|
|
for (size_t i = 0; i < 10000; i++)
|
|
{
|
|
cmc_assert(hbm_insert(map, i, i));
|
|
}
|
|
|
|
for (size_t i = 0; i < 10000; i++)
|
|
{
|
|
cmc_assert(hbm_remove_by_val(map, i, NULL, NULL));
|
|
}
|
|
|
|
for (size_t i = 0; i < map->capacity; i++)
|
|
{
|
|
struct hashbidimap_entry *k = map->buffer[i][0];
|
|
struct hashbidimap_entry *v = map->buffer[i][1];
|
|
|
|
cmc_assert((k == NULL || k == CMC_ENTRY_DELETED) && (v == NULL || v == CMC_ENTRY_DELETED));
|
|
}
|
|
|
|
hbm_free(map);
|
|
});
|
|
|
|
CMC_CREATE_TEST(copy_of, {
|
|
struct hashbidimap *map1 = hbm_new(100, 0.7, hbm_fkey, hbm_fval);
|
|
|
|
for (size_t i = 0; i < 100; i++)
|
|
cmc_assert(hbm_insert(map1, i, i));
|
|
|
|
struct hashbidimap *map2 = hbm_copy_of(map1);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map2);
|
|
cmc_assert_equals(size_t, hbm_count(map1), hbm_count(map2));
|
|
|
|
for (size_t i = 0; i < 100; i++)
|
|
{
|
|
cmc_assert(hbm_contains_key(map2, i) && hbm_contains_key(map1, i));
|
|
cmc_assert(hbm_contains_val(map2, i) && hbm_contains_val(map1, i));
|
|
}
|
|
|
|
hbm_free(map1);
|
|
hbm_free(map2);
|
|
});
|
|
|
|
CMC_CREATE_TEST(equals, {
|
|
struct hashbidimap *map1 = hbm_new(100, 0.7, hbm_fkey, hbm_fval);
|
|
struct hashbidimap *map2 = hbm_new(1000, 0.9, hbm_fkey, hbm_fval);
|
|
|
|
for (size_t i = 0; i < 100; i++)
|
|
{
|
|
cmc_assert(hbm_insert(map1, i, i));
|
|
cmc_assert(hbm_insert(map2, 99 - i, 99 - i));
|
|
}
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map1);
|
|
cmc_assert_not_equals(ptr, NULL, map2);
|
|
cmc_assert_equals(size_t, hbm_count(map1), hbm_count(map2));
|
|
|
|
for (size_t i = 0; i < 100; i++)
|
|
{
|
|
cmc_assert(hbm_contains_key(map2, i) && hbm_contains_key(map1, i));
|
|
cmc_assert(hbm_contains_val(map2, i) && hbm_contains_val(map1, i));
|
|
}
|
|
|
|
hbm_free(map1);
|
|
hbm_free(map2);
|
|
});
|
|
|
|
CMC_CREATE_TEST(equals[from copy], {
|
|
struct hashbidimap *map1 = hbm_new(100, 0.7, hbm_fkey, hbm_fval);
|
|
|
|
for (size_t i = 0; i < 100; i++)
|
|
cmc_assert(hbm_insert(map1, i, i));
|
|
|
|
struct hashbidimap *map2 = hbm_copy_of(map1);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map2);
|
|
|
|
cmc_assert(hbm_equals(map1, map2));
|
|
|
|
hbm_free(map1);
|
|
hbm_free(map2);
|
|
});
|
|
|
|
CMC_CREATE_TEST(flags, {
|
|
struct hashbidimap *map = hbm_new(100, 0.7, hbm_fkey, hbm_fval);
|
|
|
|
cmc_assert_not_equals(ptr, NULL, map);
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map));
|
|
|
|
// customize
|
|
hbm_customize(map, &cmc_alloc_node_default, callbacks);
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map));
|
|
|
|
// Insert
|
|
cmc_assert(hbm_insert(map, 1, 1));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map));
|
|
|
|
cmc_assert(!hbm_insert(map, 1, 2));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map));
|
|
map->flag = CMC_FLAG_ERROR;
|
|
cmc_assert(!hbm_insert(map, 2, 1));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map));
|
|
|
|
// clear
|
|
hbm_clear(map);
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map));
|
|
|
|
// hbm_update_key
|
|
cmc_assert(!hbm_update_key(map, 1, 1));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hbm_flag(map));
|
|
|
|
cmc_assert(hbm_insert(map, 1, 1));
|
|
cmc_assert(!hbm_update_key(map, 2, 1));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map));
|
|
|
|
cmc_assert(hbm_insert(map, 2, 2));
|
|
cmc_assert(!hbm_update_key(map, 2, 1));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map));
|
|
map->flag = CMC_FLAG_ERROR;
|
|
cmc_assert(!hbm_update_key(map, 1, 2));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map));
|
|
|
|
// clear
|
|
hbm_clear(map);
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map));
|
|
|
|
// hbm_update_val
|
|
cmc_assert(!hbm_update_val(map, 1, 1));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hbm_flag(map));
|
|
|
|
cmc_assert(hbm_insert(map, 1, 1));
|
|
cmc_assert(!hbm_update_val(map, 2, 1));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map));
|
|
|
|
cmc_assert(hbm_insert(map, 2, 2));
|
|
cmc_assert(!hbm_update_val(map, 2, 1));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map));
|
|
map->flag = CMC_FLAG_ERROR;
|
|
cmc_assert(!hbm_update_val(map, 1, 2));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_DUPLICATE, hbm_flag(map));
|
|
|
|
// remove_by_key
|
|
cmc_assert(hbm_remove_by_key(map, 1, NULL, NULL));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map));
|
|
|
|
cmc_assert(!hbm_remove_by_key(map, 1, NULL, NULL));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map));
|
|
|
|
cmc_assert(hbm_remove_by_key(map, 2, NULL, NULL));
|
|
cmc_assert(!hbm_remove_by_key(map, 2, NULL, NULL));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hbm_flag(map));
|
|
|
|
// remove_by_val
|
|
cmc_assert(hbm_insert(map, 1, 1) && hbm_insert(map, 2, 2));
|
|
|
|
cmc_assert(hbm_remove_by_val(map, 1, NULL, NULL));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map));
|
|
|
|
cmc_assert(!hbm_remove_by_val(map, 1, NULL, NULL));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map));
|
|
|
|
cmc_assert(hbm_remove_by_val(map, 2, NULL, NULL));
|
|
cmc_assert(!hbm_remove_by_val(map, 2, NULL, NULL));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_EMPTY, hbm_flag(map));
|
|
|
|
// get_key and get_val
|
|
cmc_assert(hbm_insert(map, 2, 1));
|
|
|
|
cmc_assert_equals(size_t, 2, hbm_get_key(map, 1));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map));
|
|
map->flag = CMC_FLAG_ERROR;
|
|
cmc_assert_equals(size_t, 1, hbm_get_val(map, 2));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map));
|
|
|
|
cmc_assert_equals(size_t, 0, hbm_get_key(map, 2));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map));
|
|
map->flag = CMC_FLAG_ERROR;
|
|
cmc_assert_equals(size_t, 0, hbm_get_val(map, 1));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map));
|
|
|
|
// contains_key
|
|
cmc_assert(hbm_contains_key(map, 2));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map));
|
|
|
|
// contains_val
|
|
map->flag = CMC_FLAG_ERROR;
|
|
cmc_assert(hbm_contains_val(map, 1));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map));
|
|
|
|
// copy_of
|
|
map->flag = CMC_FLAG_ERROR;
|
|
struct hashbidimap *map2 = hbm_copy_of(map);
|
|
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map2));
|
|
|
|
size_t tmp = map->capacity;
|
|
map->capacity = 0;
|
|
|
|
struct hashbidimap *map3 = hbm_copy_of(map);
|
|
cmc_assert_equals(ptr, NULL, map3);
|
|
cmc_assert_equals(int32_t, CMC_FLAG_ERROR, hbm_flag(map));
|
|
|
|
map->capacity = tmp;
|
|
|
|
// equals
|
|
hbm_get_key(map, 100);
|
|
hbm_get_key(map2, 100);
|
|
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_NOT_FOUND, hbm_flag(map2));
|
|
map->flag = CMC_FLAG_ERROR;
|
|
cmc_assert(hbm_equals(map, map2));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map));
|
|
cmc_assert_equals(int32_t, CMC_FLAG_OK, hbm_flag(map2));
|
|
|
|
hbm_free(map);
|
|
hbm_free(map2);
|
|
});
|
|
});
|
|
|
|
CMC_CREATE_UNIT(CMCHashBidiMapIter, true, {
|
|
CMC_CREATE_TEST(PFX##_iter_start, {
|
|
// WIP
|
|
cmc_assert(true);
|
|
cmc_assert(true);
|
|
});
|
|
});
|
|
|
|
#endif /* CMC_TESTS_UNT_HASHBIDIMAP_H */
|