Merging tests codecov with main
This commit is contained in:
Leonardo committed
1 parent
1dd0f25ff8
commit
7701364f13
54 files changed
+83
-7581
No files matched your search
@@ -1,24 +0,0 @@
|
||||
CC = gcc
|
||||
CFLAGS = -std=c11 -Wall -Wextra
|
||||
CFLAGS += -Wno-unused-function -Wno-unused-parameter -Wno-unused-variable -Wno-unused-label
|
||||
CVFLAGS = --coverage -O0
|
||||
INCLUDE = ../../src/
|
||||
|
||||
main: FORCE
|
||||
$(CC) main.c -o main $(CFLAGS) $(CVFLAGS) -I $(INCLUDE)
|
||||
./main
|
||||
gcov ./main.c
|
||||
|
||||
dev: FORCE
|
||||
$(CC) main.c -o main $(CFLAGS) $(CVFLAGS) -I $(INCLUDE)
|
||||
./main
|
||||
gcov ./main.c -n
|
||||
rm *.gcda *.gcno *.exe
|
||||
|
||||
windev: FORCE
|
||||
$(CC) main.c -o main $(CFLAGS) $(CVFLAGS) -I $(INCLUDE)
|
||||
./main
|
||||
gcov ./main.c -n
|
||||
del *.gcda *.gcno *.exe
|
||||
|
||||
FORCE:
|
||||
@@ -1,7 +0,0 @@
|
||||
# codecov
|
||||
|
||||
In order to provide a good code coverage, all macros have been expanded and added to `src/*.c`.
|
||||
|
||||
* `src` - Since gcov fails to detect code that was expanded by macro, all collections where manually expanded and dumped into their respective source files;
|
||||
* `unt` - Unit Tests;
|
||||
* `main.c` - Where all tests are compiled together and called by main().
|
||||
@@ -1,49 +0,0 @@
|
||||
#include <utl/timer.h>
|
||||
|
||||
#include "unt/bidimap.c"
|
||||
#include "unt/deque.c"
|
||||
#include "unt/hashmap.c"
|
||||
#include "unt/hashset.c"
|
||||
#include "unt/heap.c"
|
||||
#include "unt/intervalheap.c"
|
||||
#include "unt/linkedlist.c"
|
||||
#include "unt/list.c"
|
||||
#include "unt/multimap.c"
|
||||
#include "unt/multiset.c"
|
||||
#include "unt/queue.c"
|
||||
#include "unt/sortedlist.c"
|
||||
#include "unt/stack.c"
|
||||
#include "unt/treemap.c"
|
||||
#include "unt/treeset.c"
|
||||
|
||||
int main(void)
|
||||
{
|
||||
struct cmc_timer timer;
|
||||
|
||||
cmc_timer_start(timer);
|
||||
uintmax_t failed = 0;
|
||||
|
||||
failed += bidimap_test();
|
||||
failed += deque_test();
|
||||
failed += hashmap_test();
|
||||
failed += hashset_test();
|
||||
failed += heap_test();
|
||||
failed += intervalheap_test();
|
||||
failed += linkedlist_test();
|
||||
failed += list_test();
|
||||
failed += multimap_test();
|
||||
failed += multiset_test();
|
||||
failed += queue_test();
|
||||
failed += sortedlist_test();
|
||||
failed += stack_test();
|
||||
failed += treemap_test();
|
||||
failed += treeset_test();
|
||||
|
||||
cmc_timer_stop(timer);
|
||||
|
||||
printf("+--------------------------------------------------+\n");
|
||||
printf("| Total running time : %14.0lf milliseconds |\n", timer.result);
|
||||
printf("+--------------------------------------------------+\n");
|
||||
|
||||
return failed;
|
||||
}
|
||||
@@ -1,827 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/bidimap.c"
|
||||
|
||||
struct bidimap_ftab_key *bm_ftab_key =
|
||||
&(struct bidimap_ftab_key){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
struct bidimap_ftab_val *bm_ftab_val =
|
||||
&(struct bidimap_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
struct bidimap_ftab_key *bm_ftab_key_counter =
|
||||
&(struct bidimap_ftab_key){ .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 bidimap_ftab_val *bm_ftab_val_counter =
|
||||
&(struct bidimap_ftab_val){ .cmp = v_c_cmp,
|
||||
.cpy = v_c_cpy,
|
||||
.str = v_c_str,
|
||||
.free = v_c_free,
|
||||
.hash = v_c_hash,
|
||||
.pri = v_c_pri };
|
||||
|
||||
CMC_CREATE_UNIT(bidimap_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct bidimap *map = bm_new(100, 0.6, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, map->flag);
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[null buffer], {
|
||||
struct bidimap *map = bm_new(100, 0.6, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
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]);
|
||||
}
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new_custom, {
|
||||
struct bidimap *map =
|
||||
bm_new_custom(100, 0.6, bm_ftab_key, bm_ftab_val,
|
||||
&(struct cmc_alloc_node){ .malloc = malloc,
|
||||
.calloc = calloc,
|
||||
.realloc = realloc,
|
||||
.free = free },
|
||||
&(struct cmc_callbacks){ 0 });
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new_custom[insert remove], {
|
||||
struct bidimap *map =
|
||||
bm_new_custom(500, 0.6, bm_ftab_key, bm_ftab_val,
|
||||
&(struct cmc_alloc_node){ .malloc = malloc,
|
||||
.calloc = calloc,
|
||||
.realloc = realloc,
|
||||
.free = free },
|
||||
&(struct cmc_callbacks){ 0 });
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 500; i++)
|
||||
cmc_assert(bm_insert(map, i, i));
|
||||
|
||||
cmc_assert_equals(size_t, 500, bm_count(map));
|
||||
|
||||
for (size_t i = 0; i < 500; i++)
|
||||
{
|
||||
if (i % 2 == 0)
|
||||
{
|
||||
cmc_assert(bm_remove_by_key(map, i, NULL, NULL));
|
||||
}
|
||||
else
|
||||
{
|
||||
cmc_assert(bm_remove_by_val(map, i, NULL, NULL));
|
||||
}
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 0, bm_count(map));
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[ftab free calls], {
|
||||
struct bidimap *map =
|
||||
bm_new(1000, 0.6, bm_ftab_key_counter, bm_ftab_val_counter);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
k_total_free = 0;
|
||||
v_total_free = 0;
|
||||
|
||||
bm_clear(map);
|
||||
|
||||
cmc_assert_equals(int32_t, 0, k_total_free);
|
||||
cmc_assert_equals(int32_t, 0, v_total_free);
|
||||
|
||||
for (size_t i = 0; i < 1000; i++)
|
||||
cmc_assert(bm_insert(map, i, i));
|
||||
|
||||
bm_clear(map);
|
||||
|
||||
cmc_assert_equals(int32_t, 1000, k_total_free);
|
||||
cmc_assert_equals(int32_t, 1000, v_total_free);
|
||||
|
||||
bm_ftab_val_counter->free = NULL;
|
||||
|
||||
for (size_t i = 0; i < 1000; i++)
|
||||
cmc_assert(bm_insert(map, i, i));
|
||||
|
||||
bm_clear(map);
|
||||
|
||||
cmc_assert_equals(int32_t, 2000, k_total_free);
|
||||
cmc_assert_equals(int32_t, 1000, v_total_free);
|
||||
|
||||
bm_ftab_val_counter->free = v_c_free;
|
||||
bm_ftab_key_counter->free = NULL;
|
||||
|
||||
for (size_t i = 0; i < 1000; i++)
|
||||
cmc_assert(bm_insert(map, i, i));
|
||||
|
||||
bm_clear(map);
|
||||
|
||||
cmc_assert_equals(int32_t, 2000, k_total_free);
|
||||
cmc_assert_equals(int32_t, 2000, v_total_free);
|
||||
|
||||
bm_ftab_key_counter->free = k_c_free;
|
||||
|
||||
bm_free(map);
|
||||
|
||||
k_total_free = 0;
|
||||
v_total_free = 0;
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count], {
|
||||
struct bidimap *map = bm_new(100, 0.6, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 500; i++)
|
||||
cmc_assert(bm_insert(map, i, i));
|
||||
|
||||
cmc_assert_equals(size_t, 500, bm_count(map));
|
||||
|
||||
bm_clear(map);
|
||||
|
||||
cmc_assert_equals(size_t, 0, bm_count(map));
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(customize, {
|
||||
struct bidimap *map =
|
||||
bm_new_custom(100, 0.6, bm_ftab_key, bm_ftab_val, NULL, NULL);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert_equals(ptr, &cmc_alloc_node_default, map->alloc);
|
||||
cmc_assert_equals(ptr, NULL, map->callbacks);
|
||||
|
||||
bm_free(map);
|
||||
|
||||
struct cmc_alloc_node node;
|
||||
node.malloc = malloc;
|
||||
node.realloc = realloc;
|
||||
node.free = free;
|
||||
node.calloc = calloc;
|
||||
|
||||
map =
|
||||
bm_new_custom(100, 0.6, bm_ftab_key, bm_ftab_val, &node, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert_equals(ptr, &node, map->alloc);
|
||||
cmc_assert_equals(ptr, callbacks, map->callbacks);
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(buffer_growth[capacity = 1], {
|
||||
struct bidimap *map = bm_new(1, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 1; i <= 10000; i++)
|
||||
cmc_assert(bm_insert(map, i, i));
|
||||
|
||||
size_t sum = 0;
|
||||
|
||||
for (size_t i = 0; i < bm_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);
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert, {
|
||||
struct bidimap *map = bm_new(100, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert(bm_insert(map, 1, 1));
|
||||
cmc_assert(bm_insert(map, 2, 2));
|
||||
cmc_assert(bm_insert(map, 3, 3));
|
||||
|
||||
cmc_assert_equals(size_t, 3, bm_count(map));
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[duplicate], {
|
||||
struct bidimap *map = bm_new(100, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert(bm_insert(map, 1, 1));
|
||||
cmc_assert(!bm_insert(map, 1, 1));
|
||||
cmc_assert(!bm_insert(map, 2, 1));
|
||||
cmc_assert(!bm_insert(map, 1, 2));
|
||||
cmc_assert(bm_insert(map, 2, 2));
|
||||
|
||||
cmc_assert_equals(size_t, 2, bm_count(map));
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[references], {
|
||||
struct bidimap *map = bm_new(500, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 500; i++)
|
||||
cmc_assert(bm_insert(map, i, i));
|
||||
|
||||
for (size_t i = 0; i < map->capacity; i++)
|
||||
{
|
||||
struct bidimap_entry *kentry = map->buffer[i][0];
|
||||
struct bidimap_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]));
|
||||
}
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[growth remove clear], {
|
||||
struct bidimap *map = bm_new(100, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 1; i <= 1000; i++)
|
||||
cmc_assert(bm_insert(map, i, i));
|
||||
|
||||
cmc_assert_equals(size_t, 1000, bm_count(map));
|
||||
|
||||
size_t j = 1;
|
||||
while (!bm_empty(map))
|
||||
{
|
||||
if (bm_count(map) % 2 == 0)
|
||||
cmc_assert(bm_remove_by_key(map, j++, NULL, NULL));
|
||||
else
|
||||
cmc_assert(bm_remove_by_val(map, j++, NULL, NULL));
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 0, bm_count(map));
|
||||
|
||||
for (size_t i = 1; i <= 1000; i++)
|
||||
cmc_assert(bm_insert(map, i, i));
|
||||
|
||||
cmc_assert_equals(size_t, 1000, bm_count(map));
|
||||
|
||||
bm_clear(map);
|
||||
|
||||
cmc_assert_equals(size_t, 0, bm_count(map));
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[ftab hash calls], {
|
||||
struct bidimap *map =
|
||||
bm_new(100, 0.7, bm_ftab_key_counter, bm_ftab_val_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(bm_insert(map, i, i));
|
||||
|
||||
cmc_assert_greater_equals(int32_t, 1000, k_total_hash);
|
||||
cmc_assert_greater_equals(int32_t, 1000, v_total_hash);
|
||||
|
||||
bm_free(map);
|
||||
|
||||
k_total_hash = 0;
|
||||
v_total_hash = 0;
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(update_key, {
|
||||
struct bidimap *map = bm_new(100, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
cmc_assert(bm_insert(map, i, i));
|
||||
|
||||
cmc_assert_equals(size_t, 100, bm_count(map));
|
||||
|
||||
for (size_t i = 100; i > 0; i--)
|
||||
cmc_assert(bm_update_key(map, i, i + 10));
|
||||
|
||||
cmc_assert_equals(size_t, 100, bm_count(map));
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
cmc_assert_equals(size_t, i + 10, bm_get_key(map, i));
|
||||
|
||||
cmc_assert_equals(size_t, 100, bm_count(map));
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(update_key[empty], {
|
||||
struct bidimap *map = bm_new(100, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert_equals(size_t, 0, bm_count(map));
|
||||
|
||||
cmc_assert(!bm_update_key(map, 1, 1));
|
||||
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, bm_flag(map));
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(update_key[not_found duplicate], {
|
||||
struct bidimap *map = bm_new(100, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert(bm_insert(map, 1, 1));
|
||||
|
||||
cmc_assert_equals(size_t, 1, bm_count(map));
|
||||
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(bm_update_key(map, 1, 1));
|
||||
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
|
||||
|
||||
cmc_assert(!bm_update_key(map, 2, 2));
|
||||
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, bm_flag(map));
|
||||
|
||||
cmc_assert(bm_insert(map, 2, 2));
|
||||
|
||||
cmc_assert(!bm_update_key(map, 1, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
|
||||
cmc_assert(!bm_update_key(map, 2, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
|
||||
|
||||
cmc_assert(bm_update_key(map, 2, 2));
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(update_val, {
|
||||
struct bidimap *map = bm_new(100, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
cmc_assert(bm_insert(map, i, i));
|
||||
|
||||
cmc_assert_equals(size_t, 100, bm_count(map));
|
||||
|
||||
for (size_t i = 100; i > 0; i--)
|
||||
cmc_assert(bm_update_val(map, i, i + 10));
|
||||
|
||||
cmc_assert_equals(size_t, 100, bm_count(map));
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
cmc_assert_equals(size_t, i + 10, bm_get_val(map, i));
|
||||
|
||||
cmc_assert_equals(size_t, 100, bm_count(map));
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(update_val[empty], {
|
||||
struct bidimap *map = bm_new(100, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert_equals(size_t, 0, bm_count(map));
|
||||
|
||||
cmc_assert(!bm_update_val(map, 1, 1));
|
||||
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, bm_flag(map));
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(update_val[not_found duplicate], {
|
||||
struct bidimap *map = bm_new(100, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert(bm_insert(map, 1, 1));
|
||||
|
||||
cmc_assert_equals(size_t, 1, bm_count(map));
|
||||
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(bm_update_val(map, 1, 1));
|
||||
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
|
||||
|
||||
cmc_assert(!bm_update_val(map, 2, 2));
|
||||
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, bm_flag(map));
|
||||
|
||||
cmc_assert(bm_insert(map, 2, 2));
|
||||
|
||||
cmc_assert(!bm_update_val(map, 1, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
|
||||
cmc_assert(!bm_update_val(map, 2, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
|
||||
|
||||
cmc_assert(bm_update_val(map, 2, 2));
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove_by_key[cleanup custom], {
|
||||
struct bidimap *map =
|
||||
bm_new_custom(10000, 0.6, bm_ftab_key, bm_ftab_val,
|
||||
&(struct cmc_alloc_node){ .malloc = malloc,
|
||||
.calloc = calloc,
|
||||
.realloc = realloc,
|
||||
.free = free },
|
||||
&(struct cmc_callbacks){ 0 });
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 10000; i++)
|
||||
{
|
||||
cmc_assert(bm_insert(map, i, i));
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < 10000; i++)
|
||||
{
|
||||
cmc_assert(bm_remove_by_key(map, i, NULL, NULL));
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < map->capacity; i++)
|
||||
{
|
||||
struct bidimap_entry *k = map->buffer[i][0];
|
||||
struct bidimap_entry *v = map->buffer[i][1];
|
||||
|
||||
cmc_assert((k == NULL || k == CMC_ENTRY_DELETED) &&
|
||||
(v == NULL || v == CMC_ENTRY_DELETED));
|
||||
}
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove_by_val[cleanup custom], {
|
||||
struct bidimap *map =
|
||||
bm_new_custom(10000, 0.6, bm_ftab_key, bm_ftab_val,
|
||||
&(struct cmc_alloc_node){ .malloc = malloc,
|
||||
.calloc = calloc,
|
||||
.realloc = realloc,
|
||||
.free = free },
|
||||
&(struct cmc_callbacks){ 0 });
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 10000; i++)
|
||||
{
|
||||
cmc_assert(bm_insert(map, i, i));
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < 10000; i++)
|
||||
{
|
||||
cmc_assert(bm_remove_by_val(map, i, NULL, NULL));
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < map->capacity; i++)
|
||||
{
|
||||
struct bidimap_entry *k = map->buffer[i][0];
|
||||
struct bidimap_entry *v = map->buffer[i][1];
|
||||
|
||||
cmc_assert((k == NULL || k == CMC_ENTRY_DELETED) &&
|
||||
(v == NULL || v == CMC_ENTRY_DELETED));
|
||||
}
|
||||
|
||||
bm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(copy_of, {
|
||||
struct bidimap *map1 = bm_new(100, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(bm_insert(map1, i, i));
|
||||
|
||||
struct bidimap *map2 = bm_copy_of(map1);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map2);
|
||||
cmc_assert_equals(size_t, bm_count(map1), bm_count(map2));
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
{
|
||||
cmc_assert(bm_contains_key(map2, i) && bm_contains_key(map1, i));
|
||||
cmc_assert(bm_contains_val(map2, i) && bm_contains_val(map1, i));
|
||||
}
|
||||
|
||||
bm_free(map1);
|
||||
bm_free(map2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(equals, {
|
||||
struct bidimap *map1 = bm_new(100, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
struct bidimap *map2 = bm_new(1000, 0.9, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
{
|
||||
cmc_assert(bm_insert(map1, i, i));
|
||||
cmc_assert(bm_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, bm_count(map1), bm_count(map2));
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
{
|
||||
cmc_assert(bm_contains_key(map2, i) && bm_contains_key(map1, i));
|
||||
cmc_assert(bm_contains_val(map2, i) && bm_contains_val(map1, i));
|
||||
}
|
||||
|
||||
bm_free(map1);
|
||||
bm_free(map2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(equals[from copy], {
|
||||
struct bidimap *map1 = bm_new(100, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(bm_insert(map1, i, i));
|
||||
|
||||
struct bidimap *map2 = bm_copy_of(map1);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map2);
|
||||
|
||||
cmc_assert(bm_equals(map1, map2));
|
||||
|
||||
bm_free(map1);
|
||||
bm_free(map2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct bidimap *map = bm_new(100, 0.7, bm_ftab_key, bm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
|
||||
|
||||
// customize
|
||||
bm_customize(map, &cmc_alloc_node_default,
|
||||
&(struct cmc_callbacks){ 0 });
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
|
||||
|
||||
// Insert
|
||||
cmc_assert(bm_insert(map, 1, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
|
||||
|
||||
cmc_assert(!bm_insert(map, 1, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!bm_insert(map, 2, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
|
||||
|
||||
// clear
|
||||
bm_clear(map);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
|
||||
|
||||
// bm_update_key
|
||||
cmc_assert(!bm_update_key(map, 1, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, bm_flag(map));
|
||||
|
||||
cmc_assert(bm_insert(map, 1, 1));
|
||||
cmc_assert(!bm_update_key(map, 2, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, bm_flag(map));
|
||||
|
||||
cmc_assert(bm_insert(map, 2, 2));
|
||||
cmc_assert(!bm_update_key(map, 2, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!bm_update_key(map, 1, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
|
||||
|
||||
// clear
|
||||
bm_clear(map);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
|
||||
|
||||
// bm_update_val
|
||||
cmc_assert(!bm_update_val(map, 1, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, bm_flag(map));
|
||||
|
||||
cmc_assert(bm_insert(map, 1, 1));
|
||||
cmc_assert(!bm_update_val(map, 2, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, bm_flag(map));
|
||||
|
||||
cmc_assert(bm_insert(map, 2, 2));
|
||||
cmc_assert(!bm_update_val(map, 2, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!bm_update_val(map, 1, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, bm_flag(map));
|
||||
|
||||
// remove_by_key
|
||||
cmc_assert(bm_remove_by_key(map, 1, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
|
||||
|
||||
cmc_assert(!bm_remove_by_key(map, 1, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, bm_flag(map));
|
||||
|
||||
cmc_assert(bm_remove_by_key(map, 2, NULL, NULL));
|
||||
cmc_assert(!bm_remove_by_key(map, 2, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, bm_flag(map));
|
||||
|
||||
// remove_by_val
|
||||
cmc_assert(bm_insert(map, 1, 1) && bm_insert(map, 2, 2));
|
||||
|
||||
cmc_assert(bm_remove_by_val(map, 1, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
|
||||
|
||||
cmc_assert(!bm_remove_by_val(map, 1, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, bm_flag(map));
|
||||
|
||||
cmc_assert(bm_remove_by_val(map, 2, NULL, NULL));
|
||||
cmc_assert(!bm_remove_by_val(map, 2, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, bm_flag(map));
|
||||
|
||||
// get_key and get_val
|
||||
cmc_assert(bm_insert(map, 2, 1));
|
||||
|
||||
cmc_assert_equals(size_t, 2, bm_get_key(map, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert_equals(size_t, 1, bm_get_val(map, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
|
||||
|
||||
cmc_assert_equals(size_t, 0, bm_get_key(map, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, bm_flag(map));
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert_equals(size_t, 0, bm_get_val(map, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, bm_flag(map));
|
||||
|
||||
// contains_key
|
||||
cmc_assert(bm_contains_key(map, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
|
||||
|
||||
// contains_val
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(bm_contains_val(map, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
|
||||
|
||||
// copy_of
|
||||
map->flag = cmc_flags.ERROR;
|
||||
struct bidimap *map2 = bm_copy_of(map);
|
||||
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map2));
|
||||
|
||||
size_t tmp = map->capacity;
|
||||
map->capacity = 0;
|
||||
|
||||
struct bidimap *map3 = bm_copy_of(map);
|
||||
cmc_assert_equals(ptr, NULL, map3);
|
||||
cmc_assert_equals(int32_t, cmc_flags.ERROR, bm_flag(map));
|
||||
|
||||
map->capacity = tmp;
|
||||
|
||||
// equals
|
||||
bm_get_key(map, 100);
|
||||
bm_get_key(map2, 100);
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, bm_flag(map));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, bm_flag(map2));
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(bm_equals(map, map2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, bm_flag(map2));
|
||||
|
||||
bm_free(map);
|
||||
bm_free(map2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct bidimap *map =
|
||||
bm_new_custom(100, 0.7, bm_ftab_key, bm_ftab_val, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
cmc_assert_equals(ptr, callbacks, map->callbacks);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(bm_insert(map, 10, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(bm_update_key(map, 10, 5));
|
||||
cmc_assert_equals(int32_t, 1, total_update);
|
||||
|
||||
cmc_assert(bm_update_val(map, 5, 5));
|
||||
cmc_assert_equals(int32_t, 2, total_update);
|
||||
|
||||
cmc_assert(bm_insert(map, 10, 10));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert(bm_remove_by_key(map, 5, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(bm_remove_by_val(map, 10, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
|
||||
cmc_assert(bm_insert(map, 1, 2));
|
||||
cmc_assert_equals(int32_t, 3, total_create);
|
||||
|
||||
cmc_assert_equals(size_t, 1, bm_get_key(map, 2));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 2, bm_get_val(map, 1));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert(bm_resize(map, 1000));
|
||||
cmc_assert_equals(int32_t, 1, total_resize);
|
||||
|
||||
cmc_assert(bm_resize(map, 200));
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert(bm_contains_key(map, 1));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert(bm_contains_val(map, 2));
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
|
||||
cmc_assert_equals(int32_t, 3, total_create);
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
cmc_assert_equals(int32_t, 2, total_update);
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
bm_customize(map, NULL, NULL);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, map->callbacks);
|
||||
|
||||
bm_clear(map);
|
||||
cmc_assert(bm_insert(map, 10, 10));
|
||||
cmc_assert(bm_update_key(map, 10, 5));
|
||||
cmc_assert(bm_update_val(map, 5, 5));
|
||||
cmc_assert(bm_insert(map, 10, 10));
|
||||
cmc_assert(bm_remove_by_key(map, 5, NULL, NULL));
|
||||
cmc_assert(bm_remove_by_val(map, 10, NULL, NULL));
|
||||
cmc_assert(bm_insert(map, 1, 2));
|
||||
cmc_assert_equals(size_t, 1, bm_get_key(map, 2));
|
||||
cmc_assert_equals(size_t, 2, bm_get_val(map, 1));
|
||||
cmc_assert(bm_resize(map, 1000));
|
||||
cmc_assert(bm_resize(map, 200));
|
||||
cmc_assert(bm_contains_key(map, 1));
|
||||
cmc_assert(bm_contains_val(map, 2));
|
||||
|
||||
cmc_assert_equals(int32_t, 3, total_create);
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
cmc_assert_equals(int32_t, 2, total_update);
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, map->callbacks);
|
||||
|
||||
bm_free(map);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
});
|
||||
@@ -1,819 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/deque.c"
|
||||
|
||||
struct deque_ftab_val *d_ftab_val =
|
||||
&(struct deque_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
CMC_CREATE_UNIT(deque_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct deque *d = d_new(1000000, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
cmc_assert_not_equals(ptr, NULL, d->buffer);
|
||||
cmc_assert_equals(size_t, 1000000, d->capacity);
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = 0], {
|
||||
struct deque *d = d_new(0, d_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = UINT64_MAX], {
|
||||
struct deque *d = d_new(UINT64_MAX, d_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count capacity], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
d_push_back(d, i);
|
||||
|
||||
cmc_assert_equals(size_t, 50, d_count(d));
|
||||
|
||||
d_clear(d);
|
||||
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
cmc_assert_equals(size_t, 100, d_capacity(d));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(buffer_growth[capacity = 1], {
|
||||
struct deque *d = d_new(1, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
d_push_back(d, i);
|
||||
|
||||
cmc_assert_equals(size_t, 50, d_count(d));
|
||||
cmc_assert_lesser_equals(size_t, d_capacity(d), d_count(d));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(buffer_growth[item preservation], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
for (size_t i = 1; i <= 1200; i++)
|
||||
{
|
||||
if (i % 2 == 0)
|
||||
d_push_front(d, i);
|
||||
else
|
||||
d_push_back(d, i);
|
||||
}
|
||||
|
||||
size_t sum = 0;
|
||||
for (size_t i = d->front, j = 0; j < d->count;
|
||||
i = (i + 1) % d->capacity, j++)
|
||||
sum += d->buffer[i];
|
||||
|
||||
cmc_assert_equals(size_t, 1200, d_count(d));
|
||||
cmc_assert_equals(size_t, 720600, sum);
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_front[count capacity], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
for (size_t i = 0; i < 150; i++)
|
||||
cmc_assert(d_push_front(d, i));
|
||||
|
||||
cmc_assert_equals(size_t, 150, d_count(d));
|
||||
cmc_assert_greater(size_t, 100, d_capacity(d));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_front[item preservation], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
cmc_assert(d_push_front(d, i));
|
||||
|
||||
size_t sum = 0;
|
||||
|
||||
for (size_t i = d->front, j = 0; j < d->count;
|
||||
i = (i + 1) % d->capacity, j++)
|
||||
{
|
||||
sum += d->buffer[i];
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 5050, sum);
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_back[count capacity], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
for (size_t i = 0; i < 150; i++)
|
||||
cmc_assert(d_push_back(d, i));
|
||||
|
||||
cmc_assert_equals(size_t, 150, d_count(d));
|
||||
cmc_assert_greater(size_t, 100, d_capacity(d));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_back[item preservation], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
cmc_assert(d_push_back(d, i));
|
||||
|
||||
size_t sum = 0;
|
||||
|
||||
for (size_t i = d->front, j = 0; j < d->count;
|
||||
i = (i + 1) % d->capacity, j++)
|
||||
{
|
||||
sum += d->buffer[i];
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 5050, sum);
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop_front[count capacity], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
cmc_assert(d_push_front(d, 10));
|
||||
cmc_assert(d_pop_front(d));
|
||||
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
|
||||
cmc_assert(d_push_back(d, 10));
|
||||
cmc_assert(d_pop_front(d));
|
||||
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop_front[item preservation], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
for (size_t i = 1; i <= 200; i++)
|
||||
cmc_assert(d_push_front(d, i));
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(d_pop_front(d));
|
||||
|
||||
size_t sum = 0;
|
||||
|
||||
for (size_t i = d->front, j = 0; j < d->count;
|
||||
i = (i + 1) % d->capacity, j++)
|
||||
{
|
||||
sum += d->buffer[i];
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 5050, sum);
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop_back[count capacity], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
cmc_assert(d_push_front(d, 10));
|
||||
cmc_assert(d_pop_back(d));
|
||||
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
|
||||
cmc_assert(d_push_back(d, 10));
|
||||
cmc_assert(d_pop_back(d));
|
||||
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop_back[item preservation], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
for (size_t i = 1; i <= 200; i++)
|
||||
cmc_assert(d_push_back(d, i));
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(d_pop_back(d));
|
||||
|
||||
size_t sum = 0;
|
||||
|
||||
for (size_t i = d->front, j = 0; j < d->count;
|
||||
i = (i + 1) % d->capacity, j++)
|
||||
{
|
||||
sum += d->buffer[i];
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 5050, sum);
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(Mixed IO, {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
cmc_assert(d_push_front(d, 10));
|
||||
cmc_assert(d_push_front(d, 10));
|
||||
cmc_assert(d_pop_back(d));
|
||||
cmc_assert(d_pop_back(d));
|
||||
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
|
||||
cmc_assert(d_push_back(d, 10));
|
||||
cmc_assert(d_push_back(d, 10));
|
||||
cmc_assert(d_pop_back(d));
|
||||
cmc_assert(d_pop_back(d));
|
||||
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
|
||||
cmc_assert(d_push_front(d, 10));
|
||||
cmc_assert(d_push_front(d, 10));
|
||||
cmc_assert(d_pop_front(d));
|
||||
cmc_assert(d_pop_front(d));
|
||||
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
|
||||
cmc_assert(d_push_back(d, 10));
|
||||
cmc_assert(d_push_back(d, 10));
|
||||
cmc_assert(d_pop_front(d));
|
||||
cmc_assert(d_pop_front(d));
|
||||
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
// ----------
|
||||
cmc_assert(d_push_back(d, 10));
|
||||
cmc_assert(d_push_front(d, 10));
|
||||
cmc_assert(d_pop_back(d));
|
||||
cmc_assert(d_pop_front(d));
|
||||
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
|
||||
cmc_assert(d_push_back(d, 10));
|
||||
cmc_assert(d_push_front(d, 10));
|
||||
cmc_assert(d_pop_front(d));
|
||||
cmc_assert(d_pop_back(d));
|
||||
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
|
||||
cmc_assert(d_push_front(d, 10));
|
||||
cmc_assert(d_push_back(d, 10));
|
||||
cmc_assert(d_pop_back(d));
|
||||
cmc_assert(d_pop_front(d));
|
||||
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
|
||||
cmc_assert(d_push_front(d, 10));
|
||||
cmc_assert(d_push_back(d, 10));
|
||||
cmc_assert(d_pop_front(d));
|
||||
cmc_assert(d_pop_back(d));
|
||||
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(front[count = 0], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
size_t r = d_front(d);
|
||||
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, r);
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(front[sum], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
size_t sum = 0;
|
||||
|
||||
for (size_t i = 0; i <= 100; i++)
|
||||
{
|
||||
if (i % 2 == 0)
|
||||
cmc_assert(d_push_back(d, i));
|
||||
else
|
||||
cmc_assert(d_push_front(d, i));
|
||||
}
|
||||
|
||||
while (!d_empty(d))
|
||||
{
|
||||
size_t r = d_front(d);
|
||||
|
||||
sum += r;
|
||||
|
||||
cmc_assert(d_pop_front(d));
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 5050, sum);
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(back[count = 0], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
size_t r = d_back(d);
|
||||
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, r);
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(back[sum], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
size_t sum = 0;
|
||||
|
||||
for (size_t i = 0; i <= 100; i++)
|
||||
{
|
||||
if (i % 2 == 0)
|
||||
cmc_assert(d_push_back(d, i));
|
||||
else
|
||||
cmc_assert(d_push_front(d, i));
|
||||
}
|
||||
|
||||
while (!d_empty(d))
|
||||
{
|
||||
size_t r = d_back(d);
|
||||
|
||||
sum += r;
|
||||
|
||||
cmc_assert(d_pop_back(d));
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 5050, sum);
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(contains, {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
for (size_t i = 1; i <= 20; i++)
|
||||
cmc_assert(d_push_back(d, i));
|
||||
|
||||
for (size_t i = 1; i <= 20; i++)
|
||||
cmc_assert(d_contains(d, i));
|
||||
|
||||
d_clear(d);
|
||||
|
||||
for (size_t i = 1; i <= 20; i++)
|
||||
cmc_assert(d_push_front(d, i));
|
||||
|
||||
for (size_t i = 1; i <= 20; i++)
|
||||
cmc_assert(d_contains(d, i));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(contains[count = 0], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
cmc_assert(!d_contains(d, 10));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(contains[count = 1], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
cmc_assert(!d_contains(d, 10));
|
||||
|
||||
cmc_assert(d_push_back(d, 100));
|
||||
|
||||
cmc_assert(d_contains(d, 100));
|
||||
cmc_assert(!d_contains(d, 101));
|
||||
|
||||
cmc_assert(d_pop_front(d));
|
||||
cmc_assert(d_push_front(d, 100));
|
||||
|
||||
cmc_assert(d_contains(d, 100));
|
||||
cmc_assert(!d_contains(d, 101));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(empty, {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
cmc_assert(d_empty(d));
|
||||
|
||||
cmc_assert(d_push_front(d, 1));
|
||||
|
||||
cmc_assert(!d_empty(d));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(full, {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
cmc_assert(!d_full(d));
|
||||
|
||||
for (size_t i = 0; i != d_capacity(d); i++)
|
||||
cmc_assert(d_push_front(d, i));
|
||||
|
||||
cmc_assert(d_full(d));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(count, {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
cmc_assert_equals(size_t, 0, d_count(d));
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(d_push_back(d, i));
|
||||
|
||||
cmc_assert_equals(size_t, 100, d_count(d));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(capacity, {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
cmc_assert_equals(size_t, 100, d_capacity(d));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(resize, {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
for (size_t i = 0; i < 150; i++)
|
||||
{
|
||||
if (i % 2 == 0)
|
||||
cmc_assert(d_push_back(d, i));
|
||||
else
|
||||
cmc_assert(d_push_front(d, i));
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 150, d_count(d));
|
||||
cmc_assert(d_resize(d, d_count(d)));
|
||||
cmc_assert_equals(size_t, 150, d_capacity(d));
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(resize[item preservation], {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
|
||||
for (size_t i = 1; i <= 150; i++)
|
||||
{
|
||||
if (i % 2 != 0)
|
||||
cmc_assert(d_push_back(d, i));
|
||||
else
|
||||
cmc_assert(d_push_front(d, i));
|
||||
}
|
||||
|
||||
cmc_assert(d_resize(d, d_count(d)));
|
||||
|
||||
size_t sum = 0;
|
||||
|
||||
for (size_t i = d->front, j = 0; j < d->count;
|
||||
i = (i + 1) % d->capacity, j++)
|
||||
{
|
||||
sum += d->buffer[i];
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 11325, sum);
|
||||
|
||||
d_free(d);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(copy_of, {
|
||||
struct deque *d1 = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d1);
|
||||
|
||||
for (size_t i = 1; i <= 150; i++)
|
||||
{
|
||||
if (i % 2 != 0)
|
||||
cmc_assert(d_push_back(d1, i));
|
||||
else
|
||||
cmc_assert(d_push_front(d1, i));
|
||||
}
|
||||
|
||||
struct deque *d2 = d_copy_of(d1);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d2);
|
||||
cmc_assert_equals(size_t, d_count(d1), d_count(d2));
|
||||
|
||||
for (size_t i1 = d1->front, i2 = d2->front, j = 0; j < d1->count; j++)
|
||||
{
|
||||
cmc_assert_equals(size_t, d1->buffer[i1], d2->buffer[i2]);
|
||||
|
||||
i1 = (i1 + 1) % d1->capacity;
|
||||
i2 = (i2 + 1) % d2->capacity;
|
||||
}
|
||||
|
||||
cmc_assert(d_push_front(d1, 10));
|
||||
cmc_assert(d_push_front(d2, 10));
|
||||
cmc_assert(d_push_back(d1, 11));
|
||||
cmc_assert(d_push_back(d2, 11));
|
||||
|
||||
cmc_assert(d_equals(d1, d2));
|
||||
|
||||
d_free(d1);
|
||||
d_free(d2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(equals, {
|
||||
struct deque *d1 = d_new(100, d_ftab_val);
|
||||
struct deque *d2 = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d1);
|
||||
cmc_assert_not_equals(ptr, NULL, d2);
|
||||
|
||||
for (size_t i = 1; i <= 150; i++)
|
||||
{
|
||||
if (i % 2 != 0)
|
||||
{
|
||||
cmc_assert(d_push_back(d1, i));
|
||||
cmc_assert(d_push_back(d2, i));
|
||||
}
|
||||
else
|
||||
{
|
||||
cmc_assert(d_push_front(d1, i));
|
||||
cmc_assert(d_push_front(d2, i));
|
||||
}
|
||||
}
|
||||
|
||||
cmc_assert(d_equals(d1, d2));
|
||||
|
||||
d_free(d1);
|
||||
d_free(d2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(equals[from copy], {
|
||||
struct deque *d1 = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d1);
|
||||
|
||||
for (size_t i = 1; i <= 150; i++)
|
||||
{
|
||||
if (i % 2 != 0)
|
||||
cmc_assert(d_push_back(d1, i));
|
||||
else
|
||||
cmc_assert(d_push_front(d1, i));
|
||||
}
|
||||
|
||||
struct deque *d2 = d_copy_of(d1);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d2);
|
||||
|
||||
cmc_assert(d_equals(d1, d2));
|
||||
|
||||
d_free(d1);
|
||||
d_free(d2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(equals[count = 0], {
|
||||
struct deque *d1 = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d1);
|
||||
|
||||
struct deque *d2 = d_copy_of(d1);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d2);
|
||||
|
||||
cmc_assert(d_equals(d1, d2));
|
||||
|
||||
d_free(d1);
|
||||
d_free(d2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct deque *d = d_new(100, d_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d));
|
||||
|
||||
// customize
|
||||
d->flag = cmc_flags.ERROR;
|
||||
d_customize(d, &cmc_alloc_node_default, &(struct cmc_callbacks){ 0 });
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d));
|
||||
|
||||
// push_front
|
||||
d->flag = cmc_flags.ERROR;
|
||||
cmc_assert(d_push_front(d, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d));
|
||||
|
||||
// pop_front
|
||||
d->flag = cmc_flags.ERROR;
|
||||
cmc_assert(d_pop_front(d));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d));
|
||||
cmc_assert(!d_pop_front(d));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d));
|
||||
|
||||
// push_back
|
||||
cmc_assert(d_push_back(d, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d));
|
||||
|
||||
// pop_back
|
||||
d->flag = cmc_flags.ERROR;
|
||||
cmc_assert(d_pop_back(d));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d));
|
||||
cmc_assert(!d_pop_back(d));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d));
|
||||
|
||||
// front
|
||||
d->flag = cmc_flags.ERROR;
|
||||
cmc_assert(d_front(d) == 0);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d));
|
||||
|
||||
cmc_assert(d_push_back(d, 1));
|
||||
d->flag = cmc_flags.ERROR;
|
||||
cmc_assert(d_front(d) == 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d));
|
||||
|
||||
// clear
|
||||
d->flag = cmc_flags.ERROR;
|
||||
d_clear(d);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d));
|
||||
|
||||
// back
|
||||
cmc_assert(d_back(d) == 0);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d));
|
||||
|
||||
cmc_assert(d_push_front(d, 1));
|
||||
cmc_assert(d_back(d) == 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d));
|
||||
|
||||
// contains
|
||||
d->flag = cmc_flags.ERROR;
|
||||
cmc_assert(d_contains(d, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d));
|
||||
|
||||
// copy_of
|
||||
d->flag = cmc_flags.ERROR;
|
||||
struct deque *d2 = d_copy_of(d);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d2));
|
||||
|
||||
// equals
|
||||
cmc_assert(d_pop_back(d));
|
||||
cmc_assert(d_pop_back(d2));
|
||||
d->flag = cmc_flags.ERROR;
|
||||
d2->flag = cmc_flags.ERROR;
|
||||
d_front(d);
|
||||
d_front(d2);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d2));
|
||||
cmc_assert(d_equals(d, d2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d2));
|
||||
|
||||
d_free(d);
|
||||
d_free(d2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct deque *d = d_new_custom(100, d_ftab_val, NULL, callbacks);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(d_push_front(d, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(d_push_back(d, 10));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert(d_pop_front(d));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(d_pop_back(d));
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
|
||||
cmc_assert(d_push_front(d, 10));
|
||||
cmc_assert(d_push_front(d, 5));
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
|
||||
cmc_assert_equals(size_t, 5, d_front(d));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 10, d_back(d));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert(d_contains(d, 10));
|
||||
cmc_assert(!d_contains(d, 1));
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
|
||||
cmc_assert(d_resize(d, 1000));
|
||||
cmc_assert_equals(int32_t, 1, total_resize);
|
||||
|
||||
cmc_assert(d_resize(d, 10));
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
d_customize(d, NULL, NULL);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, d->callbacks);
|
||||
|
||||
d_clear(d);
|
||||
cmc_assert(d_push_front(d, 10));
|
||||
cmc_assert(d_push_back(d, 10));
|
||||
cmc_assert(d_pop_front(d));
|
||||
cmc_assert(d_pop_back(d));
|
||||
cmc_assert(d_push_front(d, 10));
|
||||
cmc_assert(d_push_front(d, 5));
|
||||
cmc_assert_equals(size_t, 5, d_front(d));
|
||||
cmc_assert_equals(size_t, 10, d_back(d));
|
||||
cmc_assert(d_contains(d, 10));
|
||||
cmc_assert(!d_contains(d, 1));
|
||||
cmc_assert(d_resize(d, 1000));
|
||||
cmc_assert(d_resize(d, 10));
|
||||
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, d->callbacks);
|
||||
|
||||
d_free(d);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
});
|
||||
@@ -1,682 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/hashmap.c"
|
||||
|
||||
struct hashmap_ftab_key *hm_ftab_key =
|
||||
&(struct hashmap_ftab_key){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
struct hashmap_ftab_val *hm_ftab_val =
|
||||
&(struct hashmap_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
CMC_CREATE_UNIT(hashmap_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct hashmap *map = hm_new(943722, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
cmc_assert_not_equals(ptr, NULL, map->buffer);
|
||||
cmc_assert_equals(size_t, 0, hm_count(map));
|
||||
cmc_assert_greater_equals(size_t, (943722 / 0.6), hm_capacity(map));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = 0], {
|
||||
struct hashmap *map = hm_new(0, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = UINT64_MAX], {
|
||||
struct hashmap *map =
|
||||
hm_new(UINT64_MAX, 0.99, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count capacity], {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
hm_insert(map, i, i);
|
||||
|
||||
cmc_assert_equals(size_t, 50, hm_count(map));
|
||||
|
||||
hm_clear(map);
|
||||
|
||||
cmc_assert_equals(size_t, 0, hm_count(map));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert, {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert(hm_insert(map, 1, 1));
|
||||
cmc_assert_equals(size_t, 1, hm_count(map));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[smallest capacity], {
|
||||
struct hashmap *map = hm_new(1, 0.99, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[0], hm_capacity(map));
|
||||
cmc_assert(hm_insert(map, 1, 1));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[element position], {
|
||||
struct hashmap *map = hm_new(1, 0.99, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
// Temporary change
|
||||
// Using the numhash the key is the hash itself
|
||||
hm_ftab_key->hash = numhash;
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
size_t capacity = hm_capacity(map);
|
||||
|
||||
cmc_assert_greater(size_t, 0, capacity);
|
||||
|
||||
cmc_assert(hm_insert(map, capacity - 1, capacity - 1));
|
||||
cmc_assert(hm_insert(map, capacity, capacity));
|
||||
|
||||
cmc_assert_equals(size_t, capacity - 1, map->buffer[capacity - 1].key);
|
||||
cmc_assert_equals(size_t, capacity, map->buffer[0].key);
|
||||
|
||||
hm_ftab_key->hash = hash;
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[distance], {
|
||||
struct hashmap *map = hm_new(500, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
// Temporary change
|
||||
hm_ftab_key->hash = hash0;
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 200; i++)
|
||||
cmc_assert(hm_insert(map, i, i));
|
||||
|
||||
// Everything is hashed to 0 so key 0 should have dist 0, key 1 dist 1,
|
||||
// etc
|
||||
for (size_t i = 0; i < 200; i++)
|
||||
cmc_assert_equals(size_t, i, map->buffer[i].dist);
|
||||
|
||||
hm_ftab_key->hash = hash;
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[distance wrap], {
|
||||
struct hashmap *map = hm_new(1, 0.99, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
// Temporary change
|
||||
hm_ftab_key->hash = hashcapminus1;
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
size_t capacity = hm_capacity(map);
|
||||
|
||||
// Just to be sure, not part of the test
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[0] - 1,
|
||||
hashcapminus1(0));
|
||||
cmc_assert_equals(size_t, capacity - 1, hashcapminus1(0));
|
||||
|
||||
cmc_assert(hm_insert(map, 0, 0));
|
||||
cmc_assert(hm_insert(map, 1, 1));
|
||||
|
||||
cmc_assert_equals(size_t, 0, map->buffer[capacity - 1].dist);
|
||||
cmc_assert_equals(size_t, 1, map->buffer[0].dist);
|
||||
|
||||
hm_ftab_key->hash = hash;
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[distances], {
|
||||
struct hashmap *map = hm_new(1, 0.99, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
// Temporary change
|
||||
hm_ftab_key->hash = hashcapminus4;
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[0], hm_capacity(map));
|
||||
|
||||
for (size_t i = 0; i < 6; i++)
|
||||
cmc_assert(hm_insert(map, i, i));
|
||||
|
||||
for (size_t i = 0; i < 6; i++)
|
||||
cmc_assert_equals(size_t, i, hm_impl_get_entry(map, i)->dist);
|
||||
|
||||
hm_ftab_key->hash = hash;
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[buffer growth and item preservation], {
|
||||
struct hashmap *map = hm_new(1, 0.99, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[0], hm_capacity(map));
|
||||
|
||||
size_t p = 0;
|
||||
for (size_t i = 0; i < 100000; i++)
|
||||
{
|
||||
if (hm_full(map))
|
||||
p++;
|
||||
|
||||
cmc_assert(hm_insert(map, i, i));
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[p], hm_capacity(map));
|
||||
|
||||
for (size_t i = 0; i < 100000; i++)
|
||||
cmc_assert(hm_contains(map, i));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(update, {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert(hm_insert(map, 1, 1));
|
||||
|
||||
size_t old;
|
||||
cmc_assert(hm_update(map, 1, 2, &old));
|
||||
|
||||
cmc_assert_equals(size_t, 1, old);
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(update[key not found], {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(hm_insert(map, i, i));
|
||||
|
||||
cmc_assert(!hm_update(map, 120, 120, NULL));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove, {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(hm_insert(map, i, i));
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(hm_remove(map, i, NULL));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove[count = 0], {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 100; i < 200; i++)
|
||||
cmc_assert(!hm_remove(map, i, NULL));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove[key not found], {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(hm_insert(map, i, i));
|
||||
|
||||
for (size_t i = 100; i < 200; i++)
|
||||
cmc_assert(!hm_remove(map, i, NULL));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(max, {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
cmc_assert(hm_insert(map, i, i));
|
||||
|
||||
size_t key;
|
||||
size_t val;
|
||||
cmc_assert(hm_max(map, &key, &val));
|
||||
|
||||
cmc_assert_equals(size_t, 100, key);
|
||||
cmc_assert_equals(size_t, 100, val);
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(max[count = 0], {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert(!hm_min(map, NULL, NULL));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(min, {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
cmc_assert(hm_insert(map, i, i));
|
||||
|
||||
size_t key;
|
||||
size_t val;
|
||||
cmc_assert(hm_min(map, &key, &val));
|
||||
|
||||
cmc_assert_equals(size_t, 1, key);
|
||||
cmc_assert_equals(size_t, 1, val);
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(min[count = 0], {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert(!hm_min(map, NULL, NULL));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(get, {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert(hm_insert(map, 4321, 1234));
|
||||
|
||||
cmc_assert_equals(size_t, 1234, hm_get(map, 4321));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(get[count = 0], {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, hm_get(map, 4321));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(get_ref, {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert(hm_insert(map, 4321, 1234));
|
||||
|
||||
size_t *result = hm_get_ref(map, 4321);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, result);
|
||||
cmc_assert_equals(size_t, 1234, *result);
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(get_ref[count = 0], {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, hm_get_ref(map, 4321));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(contains, {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert(hm_insert(map, 987654321, 1));
|
||||
|
||||
cmc_assert(hm_contains(map, 987654321));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(contains[count = 0], {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert(!hm_contains(map, 987654321));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(contains[sum], {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 101; i <= 200; i++)
|
||||
cmc_assert(hm_insert(map, i, i));
|
||||
|
||||
size_t sum = 0;
|
||||
for (size_t i = 1; i <= 300; i++)
|
||||
if (hm_contains(map, i))
|
||||
sum += i;
|
||||
|
||||
cmc_assert_equals(size_t, 15050, sum);
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(empty, {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert(hm_empty(map));
|
||||
|
||||
cmc_assert(hm_insert(map, 1, 1));
|
||||
|
||||
cmc_assert(!hm_empty(map));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(full, {
|
||||
struct hashmap *map =
|
||||
hm_new(cmc_hashtable_primes[0], 0.99999, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[0], hm_capacity(map));
|
||||
|
||||
for (size_t i = 0; i < hm_capacity(map); i++)
|
||||
cmc_assert(hm_insert(map, i, i));
|
||||
|
||||
cmc_assert(hm_full(map));
|
||||
|
||||
cmc_assert(hm_insert(map, 10000, 10000));
|
||||
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[1], hm_capacity(map));
|
||||
|
||||
cmc_assert(!hm_full(map));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(count, {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 1; i < 100; i++)
|
||||
{
|
||||
cmc_assert(hm_insert(map, i, i));
|
||||
cmc_assert_equals(size_t, i, hm_count(map));
|
||||
}
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(capacity, {
|
||||
struct hashmap *map = hm_new(2500, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert_greater_equals(size_t, (size_t)(2500 / 0.6),
|
||||
hm_capacity(map));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(capacity[small], {
|
||||
struct hashmap *map = hm_new(1, 0.99, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[0], hm_capacity(map));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(load, {
|
||||
struct hashmap *map = hm_new(1, 0.99, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert_in_range(double, 0.99 - 0.0001, 0.99 + 0.0001, hm_load(map));
|
||||
|
||||
hm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct hashmap *map = hm_new(100, 0.6, hm_ftab_key, hm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map));
|
||||
|
||||
// insert
|
||||
cmc_assert(hm_insert(map, 1, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map));
|
||||
cmc_assert(!hm_insert(map, 1, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, hm_flag(map));
|
||||
|
||||
// clear
|
||||
hm_clear(map);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map));
|
||||
|
||||
// update
|
||||
cmc_assert(!hm_update(map, 1, 2, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, hm_flag(map));
|
||||
|
||||
cmc_assert(hm_insert(map, 1, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map));
|
||||
|
||||
cmc_assert(!hm_update(map, 2, 1, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hm_flag(map));
|
||||
|
||||
cmc_assert(hm_update(map, 1, 2, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map));
|
||||
|
||||
// remove
|
||||
cmc_assert(!hm_remove(map, 2, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hm_flag(map));
|
||||
|
||||
cmc_assert(hm_remove(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map));
|
||||
|
||||
cmc_assert(!hm_remove(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, hm_flag(map));
|
||||
|
||||
// max
|
||||
cmc_assert(hm_insert(map, 1, 1));
|
||||
cmc_assert(hm_max(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map));
|
||||
|
||||
cmc_assert(hm_remove(map, 1, NULL));
|
||||
cmc_assert(!hm_max(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, hm_flag(map));
|
||||
|
||||
// min
|
||||
cmc_assert(hm_insert(map, 1, 1));
|
||||
cmc_assert(hm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map));
|
||||
|
||||
cmc_assert(hm_remove(map, 1, NULL));
|
||||
cmc_assert(!hm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, hm_flag(map));
|
||||
|
||||
// get
|
||||
hm_get(map, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, hm_flag(map));
|
||||
|
||||
cmc_assert(hm_insert(map, 1, 1));
|
||||
hm_get(map, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map));
|
||||
|
||||
hm_get(map, 2);
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hm_flag(map));
|
||||
|
||||
hm_clear(map);
|
||||
|
||||
// get_ref
|
||||
hm_get_ref(map, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, hm_flag(map));
|
||||
|
||||
cmc_assert(hm_insert(map, 1, 1));
|
||||
hm_get_ref(map, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map));
|
||||
|
||||
hm_get_ref(map, 2);
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hm_flag(map));
|
||||
|
||||
// contains
|
||||
hm_contains(map, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map));
|
||||
|
||||
// copy
|
||||
struct hashmap *map2 = hm_copy_of(map);
|
||||
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map2));
|
||||
|
||||
size_t tmp = map->capacity;
|
||||
map->capacity = 0;
|
||||
|
||||
struct hashmap *map3 = hm_copy_of(map);
|
||||
cmc_assert_equals(ptr, NULL, map3);
|
||||
|
||||
cmc_assert_equals(int32_t, cmc_flags.ERROR, hm_flag(map));
|
||||
|
||||
map->capacity = tmp;
|
||||
|
||||
cmc_assert(hm_equals(map, map2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hm_flag(map2));
|
||||
|
||||
hm_free(map);
|
||||
hm_free(map2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct hashmap *map =
|
||||
hm_new_custom(100, 0.6, hm_ftab_key, hm_ftab_val, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
cmc_assert(hm_insert(map, 1, 2));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(hm_update(map, 1, 10, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_update);
|
||||
|
||||
cmc_assert(hm_remove(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(hm_insert(map, 1, 2));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert(hm_max(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert(hm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 2, hm_get(map, 1));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, hm_get_ref(map, 1));
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
|
||||
cmc_assert(hm_contains(map, 1));
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
|
||||
cmc_assert(hm_resize(map, 10000));
|
||||
cmc_assert_equals(int32_t, 1, total_resize);
|
||||
|
||||
cmc_assert(hm_resize(map, 500));
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 1, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
hm_customize(map, NULL, NULL);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, map->callbacks);
|
||||
|
||||
hm_clear(map);
|
||||
cmc_assert(hm_insert(map, 1, 2));
|
||||
cmc_assert(hm_update(map, 1, 10, NULL));
|
||||
cmc_assert(hm_remove(map, 1, NULL));
|
||||
cmc_assert(hm_insert(map, 1, 2));
|
||||
cmc_assert(hm_max(map, NULL, NULL));
|
||||
cmc_assert(hm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(size_t, 2, hm_get(map, 1));
|
||||
cmc_assert_not_equals(ptr, NULL, hm_get_ref(map, 1));
|
||||
cmc_assert(hm_contains(map, 1));
|
||||
cmc_assert(hm_resize(map, 10000));
|
||||
cmc_assert(hm_resize(map, 500));
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 1, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, map->callbacks);
|
||||
|
||||
hm_free(map);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
});
|
||||
@@ -1,555 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/hashset.c"
|
||||
|
||||
struct hashset_ftab_val *hs_ftab_val =
|
||||
&(struct hashset_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
CMC_CREATE_UNIT(hashset_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct hashset *set = hs_new(943722, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
cmc_assert_not_equals(ptr, NULL, set->buffer);
|
||||
cmc_assert_equals(size_t, 0, hs_count(set));
|
||||
cmc_assert_greater_equals(size_t, (943722 / 0.6), hs_capacity(set));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = 0], {
|
||||
struct hashset *set = hs_new(0, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = UINT64_MAX], {
|
||||
struct hashset *set = hs_new(UINT64_MAX, 0.99, hs_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count capacity], {
|
||||
struct hashset *set = hs_new(100, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
hs_insert(set, i);
|
||||
|
||||
cmc_assert_equals(size_t, 50, hs_count(set));
|
||||
|
||||
hs_clear(set);
|
||||
|
||||
cmc_assert_equals(size_t, 0, hs_count(set));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert, {
|
||||
struct hashset *set = hs_new(100, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert(hs_insert(set, 1));
|
||||
cmc_assert_equals(size_t, 1, hs_count(set));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[smallest capacity], {
|
||||
struct hashset *set = hs_new(1, 0.99, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[0], hs_capacity(set));
|
||||
cmc_assert(hs_insert(set, 1));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[element position], {
|
||||
struct hashset *set = hs_new(1, 0.99, hs_ftab_val);
|
||||
|
||||
// Temporary change
|
||||
// Using the numhash the key is the hash itself
|
||||
hs_ftab_val->hash = numhash;
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
size_t capacity = hs_capacity(set);
|
||||
|
||||
cmc_assert_greater(size_t, 0, capacity);
|
||||
|
||||
cmc_assert(hs_insert(set, capacity - 1));
|
||||
cmc_assert(hs_insert(set, capacity));
|
||||
|
||||
cmc_assert_equals(size_t, capacity - 1,
|
||||
set->buffer[capacity - 1].value);
|
||||
cmc_assert_equals(size_t, capacity, set->buffer[0].value);
|
||||
|
||||
hs_ftab_val->hash = hash;
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[distance], {
|
||||
struct hashset *set = hs_new(500, 0.6, hs_ftab_val);
|
||||
|
||||
// Temporary change
|
||||
hs_ftab_val->hash = hash0;
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
for (size_t i = 0; i < 200; i++)
|
||||
cmc_assert(hs_insert(set, i));
|
||||
|
||||
// Everything is hashed to 0 so key 0 should have dist 0, key 1 dist 1,
|
||||
// etc
|
||||
for (size_t i = 0; i < 200; i++)
|
||||
cmc_assert_equals(size_t, i, set->buffer[i].dist);
|
||||
|
||||
hs_ftab_val->hash = hash;
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[distance wrap], {
|
||||
struct hashset *set = hs_new(1, 0.99, hs_ftab_val);
|
||||
|
||||
// Temporary change
|
||||
hs_ftab_val->hash = hashcapminus1;
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
size_t capacity = hs_capacity(set);
|
||||
|
||||
// Just to be sure, not part of the test
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[0] - 1,
|
||||
hashcapminus1(0));
|
||||
cmc_assert_equals(size_t, capacity - 1, hashcapminus1(0));
|
||||
|
||||
cmc_assert(hs_insert(set, 0));
|
||||
cmc_assert(hs_insert(set, 1));
|
||||
|
||||
cmc_assert_equals(size_t, 0, set->buffer[capacity - 1].dist);
|
||||
cmc_assert_equals(size_t, 1, set->buffer[0].dist);
|
||||
|
||||
hs_ftab_val->hash = hash;
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[distances], {
|
||||
struct hashset *set = hs_new(1, 0.99, hs_ftab_val);
|
||||
|
||||
// Temporary change
|
||||
hs_ftab_val->hash = hashcapminus4;
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[0], hs_capacity(set));
|
||||
|
||||
for (size_t i = 0; i < 6; i++)
|
||||
cmc_assert(hs_insert(set, i));
|
||||
|
||||
for (size_t i = 0; i < 6; i++)
|
||||
cmc_assert_equals(size_t, i, hs_impl_get_entry(set, i)->dist);
|
||||
|
||||
hs_ftab_val->hash = hash;
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[buffer growth and item preservation], {
|
||||
struct hashset *set = hs_new(1, 0.99, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[0], hs_capacity(set));
|
||||
|
||||
size_t p = 0;
|
||||
for (size_t i = 0; i < 100000; i++)
|
||||
{
|
||||
if (hs_full(set))
|
||||
p++;
|
||||
|
||||
cmc_assert(hs_insert(set, i));
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[p], hs_capacity(set));
|
||||
|
||||
for (size_t i = 0; i < 100000; i++)
|
||||
cmc_assert(hs_contains(set, i));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove, {
|
||||
struct hashset *set = hs_new(100, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(hs_insert(set, i));
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(hs_remove(set, i));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove[count = 0], {
|
||||
struct hashset *set = hs_new(100, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
for (size_t i = 100; i < 200; i++)
|
||||
cmc_assert(!hs_remove(set, i));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove[key not found], {
|
||||
struct hashset *set = hs_new(100, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(hs_insert(set, i));
|
||||
|
||||
for (size_t i = 100; i < 200; i++)
|
||||
cmc_assert(!hs_remove(set, i));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(max, {
|
||||
struct hashset *set = hs_new(100, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
cmc_assert(hs_insert(set, i));
|
||||
|
||||
size_t val;
|
||||
cmc_assert(hs_max(set, &val));
|
||||
|
||||
cmc_assert_equals(size_t, 100, val);
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(max[count = 0], {
|
||||
struct hashset *set = hs_new(100, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert(!hs_min(set, NULL));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(min, {
|
||||
struct hashset *set = hs_new(100, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
cmc_assert(hs_insert(set, i));
|
||||
|
||||
size_t val;
|
||||
cmc_assert(hs_min(set, &val));
|
||||
|
||||
cmc_assert_equals(size_t, 1, val);
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(min[count = 0], {
|
||||
struct hashset *set = hs_new(100, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert(!hs_min(set, NULL));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(contains, {
|
||||
struct hashset *set = hs_new(100, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert(hs_insert(set, 987654321));
|
||||
|
||||
cmc_assert(hs_contains(set, 987654321));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(contains[count = 0], {
|
||||
struct hashset *set = hs_new(100, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert(!hs_contains(set, 987654321));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(contains[sum], {
|
||||
struct hashset *set = hs_new(100, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
for (size_t i = 101; i <= 200; i++)
|
||||
cmc_assert(hs_insert(set, i));
|
||||
|
||||
size_t sum = 0;
|
||||
for (size_t i = 1; i <= 300; i++)
|
||||
if (hs_contains(set, i))
|
||||
sum += i;
|
||||
|
||||
cmc_assert_equals(size_t, 15050, sum);
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(empty, {
|
||||
struct hashset *set = hs_new(100, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert(hs_empty(set));
|
||||
|
||||
cmc_assert(hs_insert(set, 1));
|
||||
|
||||
cmc_assert(!hs_empty(set));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(full, {
|
||||
struct hashset *set =
|
||||
hs_new(cmc_hashtable_primes[0], 0.99999, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[0], hs_capacity(set));
|
||||
|
||||
for (size_t i = 0; i < hs_capacity(set); i++)
|
||||
cmc_assert(hs_insert(set, i));
|
||||
|
||||
cmc_assert(hs_full(set));
|
||||
|
||||
cmc_assert(hs_insert(set, 10000));
|
||||
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[1], hs_capacity(set));
|
||||
|
||||
cmc_assert(!hs_full(set));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(count, {
|
||||
struct hashset *set = hs_new(100, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
for (size_t i = 1; i < 100; i++)
|
||||
{
|
||||
cmc_assert(hs_insert(set, i));
|
||||
cmc_assert_equals(size_t, i, hs_count(set));
|
||||
}
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(capacity, {
|
||||
struct hashset *set = hs_new(2500, 0.6, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert_greater_equals(size_t, (size_t)(2500 / 0.6),
|
||||
hs_capacity(set));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(capacity[small], {
|
||||
struct hashset *set = hs_new(1, 0.99, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert_equals(size_t, cmc_hashtable_primes[0], hs_capacity(set));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(load, {
|
||||
struct hashset *set = hs_new(1, 0.99, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert_in_range(double, 0.99 - 0.0001, 0.99 + 0.0001, hs_load(set));
|
||||
|
||||
hs_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct hashset *set = hs_new(1, 0.99, hs_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set));
|
||||
|
||||
// insert
|
||||
cmc_assert(hs_insert(set, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set));
|
||||
cmc_assert(!hs_insert(set, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.DUPLICATE, hs_flag(set));
|
||||
|
||||
// clear
|
||||
hs_clear(set);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set));
|
||||
|
||||
cmc_assert(hs_insert(set, 1));
|
||||
|
||||
// remove
|
||||
cmc_assert(!hs_remove(set, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, hs_flag(set));
|
||||
|
||||
cmc_assert(hs_remove(set, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set));
|
||||
|
||||
cmc_assert(!hs_remove(set, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, hs_flag(set));
|
||||
|
||||
// max
|
||||
cmc_assert(hs_insert(set, 1));
|
||||
cmc_assert(hs_max(set, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set));
|
||||
|
||||
cmc_assert(hs_remove(set, 1));
|
||||
cmc_assert(!hs_max(set, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, hs_flag(set));
|
||||
|
||||
// min
|
||||
cmc_assert(hs_insert(set, 1));
|
||||
cmc_assert(hs_min(set, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set));
|
||||
|
||||
cmc_assert(hs_remove(set, 1));
|
||||
cmc_assert(!hs_min(set, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, hs_flag(set));
|
||||
|
||||
// contains
|
||||
hs_contains(set, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set));
|
||||
|
||||
// copy
|
||||
set->flag = cmc_flags.ERROR;
|
||||
struct hashset *set2 = hs_copy_of(set);
|
||||
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set2));
|
||||
|
||||
size_t tmp = set->capacity;
|
||||
set->capacity = 0;
|
||||
|
||||
struct hashset *set3 = hs_copy_of(set);
|
||||
cmc_assert_equals(ptr, NULL, set3);
|
||||
|
||||
cmc_assert_equals(int32_t, cmc_flags.ERROR, hs_flag(set));
|
||||
|
||||
set->capacity = tmp;
|
||||
|
||||
cmc_assert(hs_equals(set, set2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set2));
|
||||
|
||||
hs_free(set);
|
||||
hs_free(set2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct hashset *set =
|
||||
hs_new_custom(100, 0.6, hs_ftab_val, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(hs_insert(set, 1));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(hs_remove(set, 1));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(hs_insert(set, 1));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert(hs_max(set, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert(hs_min(set, NULL));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert(hs_contains(set, 1));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert(hs_resize(set, 10000));
|
||||
cmc_assert_equals(int32_t, 1, total_resize);
|
||||
|
||||
cmc_assert(hs_resize(set, 500));
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
hs_customize(set, NULL, NULL);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, set->callbacks);
|
||||
|
||||
hs_clear(set);
|
||||
cmc_assert(hs_resize(set, 10000));
|
||||
cmc_assert(hs_resize(set, 500));
|
||||
cmc_assert(hs_insert(set, 1));
|
||||
cmc_assert(hs_remove(set, 1));
|
||||
cmc_assert(hs_insert(set, 1));
|
||||
cmc_assert(hs_max(set, NULL));
|
||||
cmc_assert(hs_min(set, NULL));
|
||||
cmc_assert(hs_contains(set, 1));
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, set->callbacks);
|
||||
|
||||
hs_free(set);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
});
|
||||
@@ -1,293 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/heap.c"
|
||||
|
||||
struct heap_ftab_val *h_ftab_val = &(struct heap_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
CMC_CREATE_UNIT(heap_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct heap *h = h_new(1000000, cmc_max_heap, h_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, h);
|
||||
cmc_assert_not_equals(ptr, NULL, h->buffer);
|
||||
cmc_assert_equals(size_t, 1000000, h_capacity(h));
|
||||
cmc_assert_equals(size_t, 0, h_count(h));
|
||||
|
||||
h_free(h);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[edge_case capacity = 0], {
|
||||
struct heap *h = h_new(0, cmc_max_heap, h_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, h);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[edge_case capacity = UINT64_MAX], {
|
||||
struct heap *h = h_new(UINT64_MAX, cmc_max_heap, h_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, h);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count capacity], {
|
||||
struct heap *h = h_new(100, cmc_max_heap, h_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, h);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
h_insert(h, i);
|
||||
|
||||
cmc_assert_equals(size_t, 50, h_count(h));
|
||||
|
||||
h_clear(h);
|
||||
|
||||
cmc_assert_equals(size_t, 0, h_count(h));
|
||||
cmc_assert_equals(size_t, 100, h_capacity(h));
|
||||
|
||||
h_free(h);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(buffer_growth[edge_case capacity = 1], {
|
||||
struct heap *h = h_new(1, cmc_max_heap, h_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, h);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
cmc_assert(h_insert(h, i));
|
||||
|
||||
cmc_assert_equals(size_t, 50, h_count(h));
|
||||
|
||||
h_free(h);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert, {
|
||||
struct heap *h = h_new(100, cmc_max_heap, h_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, h);
|
||||
|
||||
cmc_assert(h_insert(h, 10));
|
||||
|
||||
h_free(h);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[item preservation], {
|
||||
struct heap *h = h_new(50, cmc_max_heap, h_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, h);
|
||||
|
||||
for (size_t i = 0; i <= 100; i++)
|
||||
cmc_assert(h_insert(h, i));
|
||||
|
||||
size_t sum = 0;
|
||||
for (size_t i = 0; i < h_count(h); i++)
|
||||
sum += h->buffer[i];
|
||||
|
||||
cmc_assert_equals(size_t, 5050, sum);
|
||||
|
||||
h_free(h);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove, {
|
||||
struct heap *h = h_new(50, cmc_max_heap, h_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, h);
|
||||
|
||||
for (size_t i = 0; i <= 100; i++)
|
||||
cmc_assert(h_insert(h, i));
|
||||
|
||||
cmc_assert_equals(size_t, 100, h_peek(h));
|
||||
cmc_assert(h_remove(h));
|
||||
cmc_assert_equals(size_t, 99, h_peek(h));
|
||||
|
||||
h_free(h);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove[count = 0], {
|
||||
struct heap *h = h_new(100, cmc_max_heap, h_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, h);
|
||||
|
||||
cmc_assert(!h_remove(h));
|
||||
|
||||
h_free(h);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove[sorted], {
|
||||
struct heap *h = h_new(100, cmc_min_heap, h_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, h);
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
cmc_assert(h_insert(h, i));
|
||||
|
||||
size_t r;
|
||||
size_t i = 0;
|
||||
size_t arr[100];
|
||||
while (!h_empty(h))
|
||||
{
|
||||
arr[i++] = h_peek(h);
|
||||
cmc_assert(h_remove(h));
|
||||
}
|
||||
|
||||
cmc_assert_array_sorted_any(size_t, arr, cmp, 0, 99);
|
||||
|
||||
h_free(h);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(peek, {
|
||||
struct heap *h = h_new(100, cmc_max_heap, h_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, h);
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
cmc_assert(h_insert(h, i));
|
||||
|
||||
cmc_assert_equals(size_t, 100, h_peek(h));
|
||||
|
||||
h_free(h);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(peek[count = 0], {
|
||||
struct heap *h = h_new(100, cmc_max_heap, h_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, h);
|
||||
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, h_peek(h));
|
||||
|
||||
h_free(h);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct heap *h = h_new(100, cmc_max_heap, h_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, h);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h));
|
||||
|
||||
h->flag = cmc_flags.ERROR;
|
||||
|
||||
// insert
|
||||
cmc_assert(h_insert(h, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h));
|
||||
|
||||
h->flag = cmc_flags.ERROR;
|
||||
|
||||
// remove
|
||||
cmc_assert(h_remove(h));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h));
|
||||
|
||||
cmc_assert(!h_remove(h));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, h_flag(h));
|
||||
|
||||
// peek
|
||||
cmc_assert(h_insert(h, 10));
|
||||
h_peek(h);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h));
|
||||
cmc_assert(h_remove(h));
|
||||
h_peek(h);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, h_flag(h));
|
||||
|
||||
// clear
|
||||
h_clear(h);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h));
|
||||
|
||||
h->flag = cmc_flags.ERROR;
|
||||
|
||||
// contains
|
||||
h_contains(h, 10);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h));
|
||||
|
||||
h->flag = cmc_flags.ERROR;
|
||||
|
||||
// copy of
|
||||
struct heap *h2 = h_copy_of(h);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h2));
|
||||
|
||||
h->flag = cmc_flags.ERROR;
|
||||
h2->flag = cmc_flags.ERROR;
|
||||
|
||||
// equals
|
||||
cmc_assert(h_equals(h, h2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h2));
|
||||
|
||||
h_free(h);
|
||||
h_free(h2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct heap *h =
|
||||
h_new_custom(100, cmc_max_heap, h_ftab_val, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, h);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(h_insert(h, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(h_remove(h));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(h_insert(h, 10));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert_equals(size_t, 10, h_peek(h));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert(h_contains(h, 10));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert(h_resize(h, 1000));
|
||||
cmc_assert_equals(int32_t, 1, total_resize);
|
||||
|
||||
cmc_assert(h_resize(h, 100));
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
h_customize(h, NULL, NULL);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, h->callbacks);
|
||||
|
||||
h_clear(h);
|
||||
cmc_assert(h_insert(h, 10));
|
||||
cmc_assert(h_remove(h));
|
||||
cmc_assert(h_insert(h, 10));
|
||||
cmc_assert_equals(size_t, 10, h_peek(h));
|
||||
cmc_assert(h_contains(h, 10));
|
||||
cmc_assert(h_resize(h, 1000));
|
||||
cmc_assert(h_resize(h, 100));
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, h->callbacks);
|
||||
|
||||
h_free(h);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
});
|
||||
@@ -1,352 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/intervalheap.c"
|
||||
|
||||
struct intervalheap_ftab_val *ih_ftab_val =
|
||||
&(struct intervalheap_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
CMC_CREATE_UNIT(intervalheap_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct intervalheap *ih = ih_new(1000000, ih_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ih);
|
||||
cmc_assert_not_equals(ptr, NULL, ih->buffer);
|
||||
cmc_assert_equals(size_t, 500000, ih_capacity(ih));
|
||||
cmc_assert_equals(size_t, 0, ih_count(ih));
|
||||
|
||||
ih_free(ih);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = 0], {
|
||||
struct intervalheap *ih = ih_new(0, ih_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, ih);
|
||||
|
||||
if (ih)
|
||||
ih_free(ih);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity], {
|
||||
struct intervalheap *ih = ih_new(1, ih_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ih);
|
||||
cmc_assert_equals(size_t, 1, ih_capacity(ih));
|
||||
|
||||
ih_free(ih);
|
||||
|
||||
ih = ih_new(2, ih_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ih);
|
||||
cmc_assert_equals(size_t, 1, ih_capacity(ih));
|
||||
|
||||
ih_free(ih);
|
||||
|
||||
ih = ih_new(3, ih_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ih);
|
||||
cmc_assert_equals(size_t, 2, ih_capacity(ih));
|
||||
|
||||
ih_free(ih);
|
||||
|
||||
ih = ih_new(4, ih_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ih);
|
||||
cmc_assert_equals(size_t, 2, ih_capacity(ih));
|
||||
|
||||
ih_free(ih);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = UINT64_MAX], {
|
||||
struct intervalheap *ih = ih_new(UINT64_MAX, ih_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, ih);
|
||||
|
||||
if (ih)
|
||||
ih_free(ih);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count capacity], {
|
||||
struct intervalheap *ih = ih_new(100, ih_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ih);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
cmc_assert(ih_insert(ih, i));
|
||||
|
||||
cmc_assert_equals(size_t, 50, ih_count(ih));
|
||||
|
||||
ih_clear(ih);
|
||||
|
||||
cmc_assert_equals(size_t, 0, ih_count(ih));
|
||||
cmc_assert_equals(size_t, 50, ih_capacity(ih));
|
||||
|
||||
ih_free(ih);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(buffer_growth[capacity = 1], {
|
||||
struct intervalheap *ih = ih_new(1, ih_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ih);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
cmc_assert(ih_insert(ih, i));
|
||||
|
||||
cmc_assert_equals(size_t, 50, ih_count(ih));
|
||||
cmc_assert_greater(size_t, 50, ih_capacity(ih) * 2);
|
||||
|
||||
ih_free(ih);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[count], {
|
||||
struct intervalheap *ih = ih_new(100, ih_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ih);
|
||||
|
||||
cmc_assert(ih_insert(ih, 1));
|
||||
cmc_assert(ih_insert(ih, 0));
|
||||
|
||||
cmc_assert_equals(size_t, 2, ih_count(ih));
|
||||
|
||||
ih_free(ih);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[max], {
|
||||
struct intervalheap *ih = ih_new(1, ih_ftab_val);
|
||||
|
||||
cmc_assert(ih_insert(ih, 0));
|
||||
cmc_assert(ih_insert(ih, 1));
|
||||
cmc_assert(ih_insert(ih, 2));
|
||||
|
||||
cmc_assert_equals(size_t, 2, ih_max(ih));
|
||||
|
||||
ih_free(ih);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[min], {
|
||||
struct intervalheap *ih = ih_new(1, ih_ftab_val);
|
||||
|
||||
cmc_assert(ih_insert(ih, 0));
|
||||
cmc_assert(ih_insert(ih, 1));
|
||||
cmc_assert(ih_insert(ih, 2));
|
||||
|
||||
cmc_assert_equals(size_t, 0, ih_min(ih));
|
||||
|
||||
ih_free(ih);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[remove_max remove_min], {
|
||||
struct intervalheap *ih = ih_new(100, ih_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ih);
|
||||
|
||||
cmc_assert(ih_insert(ih, 2));
|
||||
cmc_assert_equals(size_t, 2, ih->buffer[0].data[0]);
|
||||
|
||||
cmc_assert(ih_insert(ih, 1));
|
||||
cmc_assert_equals(size_t, 1, ih->buffer[0].data[0]);
|
||||
cmc_assert_equals(size_t, 2, ih->buffer[0].data[1]);
|
||||
|
||||
cmc_assert(ih_remove_min(ih));
|
||||
cmc_assert_equals(size_t, 2, ih->buffer[0].data[0]);
|
||||
|
||||
cmc_assert(ih_insert(ih, 1));
|
||||
cmc_assert_equals(size_t, 1, ih->buffer[0].data[0]);
|
||||
cmc_assert_equals(size_t, 2, ih->buffer[0].data[1]);
|
||||
|
||||
cmc_assert(ih_remove_max(ih));
|
||||
cmc_assert_equals(size_t, 1, ih->buffer[0].data[0]);
|
||||
|
||||
ih_free(ih);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct intervalheap *ih = ih_new(100, ih_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ih);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih));
|
||||
|
||||
ih->flag = cmc_flags.ERROR;
|
||||
|
||||
// clear
|
||||
ih_clear(ih);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih));
|
||||
|
||||
// customize
|
||||
ih->flag = cmc_flags.ERROR;
|
||||
ih_customize(ih, NULL, NULL);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih));
|
||||
|
||||
// insert
|
||||
ih->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ih_insert(ih, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih));
|
||||
|
||||
// remove_max
|
||||
cmc_assert(ih_remove_max(ih));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih));
|
||||
cmc_assert(!ih_remove_max(ih));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih));
|
||||
|
||||
// remove min
|
||||
cmc_assert(ih_insert(ih, 10));
|
||||
cmc_assert(ih_remove_min(ih));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih));
|
||||
cmc_assert(!ih_remove_min(ih));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih));
|
||||
|
||||
// update_max
|
||||
cmc_assert(!ih_update_max(ih, 20));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih));
|
||||
cmc_assert(ih_insert(ih, 10));
|
||||
ih->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ih_update_max(ih, 20));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih));
|
||||
|
||||
// update_min
|
||||
ih->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ih_update_min(ih, 20));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih));
|
||||
cmc_assert(ih_remove_min(ih));
|
||||
ih->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!ih_update_max(ih, 20));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih));
|
||||
|
||||
// max min
|
||||
ih->flag = cmc_flags.ERROR;
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, ih_max(ih));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih));
|
||||
|
||||
ih->flag = cmc_flags.ERROR;
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, ih_min(ih));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih));
|
||||
|
||||
cmc_assert(ih_insert(ih, 10));
|
||||
ih->flag = cmc_flags.ERROR;
|
||||
cmc_assert_equals(size_t, 10, ih_max(ih));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih));
|
||||
|
||||
ih->flag = cmc_flags.ERROR;
|
||||
cmc_assert_equals(size_t, 10, ih_min(ih));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih));
|
||||
|
||||
// contains
|
||||
ih->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ih_contains(ih, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih));
|
||||
|
||||
// copy_of
|
||||
ih->flag = cmc_flags.ERROR;
|
||||
struct intervalheap *ih2 = ih_copy_of(ih);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih2));
|
||||
|
||||
// equals
|
||||
ih->flag = cmc_flags.ERROR;
|
||||
ih2->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ih_equals(ih, ih2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih2));
|
||||
|
||||
ih_free(ih);
|
||||
ih_free(ih2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct intervalheap *ih =
|
||||
ih_new_custom(100, ih_ftab_val, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ih);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(ih_insert(ih, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(ih_remove_max(ih));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(ih_insert(ih, 10));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert(ih_remove_min(ih));
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
|
||||
cmc_assert(ih_insert(ih, 1));
|
||||
cmc_assert(ih_insert(ih, 2));
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
|
||||
cmc_assert(ih_update_max(ih, 1));
|
||||
cmc_assert_equals(int32_t, 1, total_update);
|
||||
|
||||
cmc_assert(ih_update_min(ih, 2));
|
||||
cmc_assert_equals(int32_t, 2, total_update);
|
||||
|
||||
cmc_assert_equals(size_t, 2, ih_max(ih));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 1, ih_min(ih));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert(ih_contains(ih, 1));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert(ih_resize(ih, 1000));
|
||||
cmc_assert_equals(int32_t, 1, total_resize);
|
||||
|
||||
cmc_assert(ih_resize(ih, 50));
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
cmc_assert_equals(int32_t, 2, total_update);
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
ih_customize(ih, NULL, NULL);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, ih->callbacks);
|
||||
|
||||
ih_clear(ih);
|
||||
cmc_assert(ih_insert(ih, 10));
|
||||
cmc_assert(ih_remove_max(ih));
|
||||
cmc_assert(ih_insert(ih, 10));
|
||||
cmc_assert(ih_remove_min(ih));
|
||||
cmc_assert(ih_insert(ih, 1));
|
||||
cmc_assert(ih_insert(ih, 2));
|
||||
cmc_assert(ih_update_max(ih, 1));
|
||||
cmc_assert(ih_update_min(ih, 2));
|
||||
cmc_assert_equals(size_t, 2, ih_max(ih));
|
||||
cmc_assert_equals(size_t, 1, ih_min(ih));
|
||||
cmc_assert(ih_contains(ih, 1));
|
||||
cmc_assert(ih_resize(ih, 1000));
|
||||
cmc_assert(ih_resize(ih, 50));
|
||||
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
cmc_assert_equals(int32_t, 2, total_update);
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, ih->callbacks);
|
||||
|
||||
ih_free(ih);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
});
|
||||
@@ -1,345 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/linkedlist.c"
|
||||
|
||||
struct linkedlist_ftab_val *ll_ftab_val =
|
||||
&(struct linkedlist_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
CMC_CREATE_UNIT(linkedlist_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct linkedlist *ll = ll_new(ll_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
cmc_assert_equals(size_t, 0, ll_count(ll));
|
||||
cmc_assert_equals(ptr, NULL, ll->head);
|
||||
cmc_assert_equals(ptr, NULL, ll->tail);
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count capacity], {
|
||||
struct linkedlist *ll = ll_new(ll_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
ll_push_back(ll, i);
|
||||
|
||||
cmc_assert_equals(size_t, 50, ll_count(ll));
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
cmc_assert_equals(size_t, 0, ll_count(ll));
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count = 0], {
|
||||
struct linkedlist *ll = ll_new(ll_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
cmc_assert_equals(size_t, 0, ll_count(ll));
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_front[count], {
|
||||
struct linkedlist *ll = ll_new(ll_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
ll_push_front(ll, 1);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll->head);
|
||||
cmc_assert_not_equals(ptr, NULL, ll->tail);
|
||||
cmc_assert_equals(size_t, 1, ll_count(ll));
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_front[item preservation], {
|
||||
struct linkedlist *ll = ll_new(ll_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
for (size_t i = 0; i < 200; i++)
|
||||
ll_push_front(ll, i);
|
||||
|
||||
for (size_t i = 0; i < ll_count(ll); i++)
|
||||
cmc_assert_equals(size_t, ll_get(ll, i), ll_count(ll) - i - 1);
|
||||
|
||||
ll_free(ll);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct linkedlist *ll = ll_new(ll_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
// clear
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
ll_clear(ll);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
// customize
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
ll_customize(ll, NULL, NULL);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
// push_front
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ll_push_front(ll, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
// push_at
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ll_push_at(ll, 10, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
cmc_assert(!ll_push_at(ll, 10, 300));
|
||||
cmc_assert_equals(int32_t, cmc_flags.RANGE, ll_flag(ll));
|
||||
|
||||
// push_back
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
// pop_front
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!ll_pop_front(ll));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll));
|
||||
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
cmc_assert(ll_pop_front(ll));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
// pop_at
|
||||
cmc_assert(!ll_pop_at(ll, 0));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll));
|
||||
cmc_assert(ll_push_front(ll, 10));
|
||||
cmc_assert(!ll_pop_at(ll, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.RANGE, ll_flag(ll));
|
||||
cmc_assert(ll_pop_at(ll, 0));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
// pop_back
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!ll_pop_front(ll));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll));
|
||||
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
cmc_assert(ll_pop_front(ll));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
// front
|
||||
ll_front(ll);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll));
|
||||
cmc_assert(ll_push_front(ll, 10));
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
ll_front(ll);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
// back
|
||||
ll_back(ll);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll));
|
||||
cmc_assert(ll_push_front(ll, 10));
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
ll_back(ll);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
// get get_ref
|
||||
ll_get(ll, 0);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll));
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
ll_get_ref(ll, 0);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll));
|
||||
|
||||
cmc_assert(ll_push_at(ll, 10, 0));
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
ll_get(ll, 0);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
ll_get(ll, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.RANGE, ll_flag(ll));
|
||||
ll_get_ref(ll, 0);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
ll_get_ref(ll, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.RANGE, ll_flag(ll));
|
||||
|
||||
// contains
|
||||
cmc_assert(ll_contains(ll, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
// copy_of
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
struct linkedlist *ll2 = ll_copy_of(ll);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll2));
|
||||
|
||||
// equals
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
ll2->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ll_equals(ll, ll2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll2));
|
||||
|
||||
ll_clear(ll);
|
||||
|
||||
// get_node
|
||||
struct linkedlist_node *n = ll_get_node(ll, 0);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ll_flag(ll));
|
||||
|
||||
cmc_assert(ll_push_at(ll, 10, 0));
|
||||
n = ll_get_node(ll, 0);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
n = ll_get_node(ll, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.RANGE, ll_flag(ll));
|
||||
|
||||
// functions relative to node
|
||||
ll_clear(ll);
|
||||
cmc_assert(ll_push_front(ll, 10));
|
||||
n = ll_get_node(ll, 0);
|
||||
cmc_assert_not_equals(ptr, NULL, n);
|
||||
|
||||
// add_next
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ll_add_next(ll, n, 11));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
// add_prev
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ll_add_prev(ll, n, 9));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
// del_next
|
||||
n = ll_next_node(n);
|
||||
cmc_assert(!ll_del_next(ll, n));
|
||||
cmc_assert_equals(int32_t, cmc_flags.INVALID, ll_flag(ll));
|
||||
n = ll_prev_node(n);
|
||||
cmc_assert(ll_del_next(ll, n));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
// del_prev
|
||||
n = ll_prev_node(n);
|
||||
cmc_assert(!ll_del_prev(ll, n));
|
||||
cmc_assert_equals(int32_t, cmc_flags.INVALID, ll_flag(ll));
|
||||
n = ll_next_node(n);
|
||||
cmc_assert(ll_del_prev(ll, n));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
// del_curr
|
||||
ll->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ll_del_curr(ll, n));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ll_flag(ll));
|
||||
|
||||
ll_free(ll);
|
||||
ll_free(ll2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct linkedlist *ll = ll_new_custom(ll_ftab_val, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(ll_push_front(ll, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert(ll_push_at(ll, 10, 1));
|
||||
cmc_assert_equals(int32_t, 3, total_create);
|
||||
|
||||
cmc_assert(ll_pop_at(ll, 1));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(ll_pop_front(ll));
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
|
||||
cmc_assert(ll_pop_back(ll));
|
||||
cmc_assert_equals(int32_t, 3, total_delete);
|
||||
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
|
||||
cmc_assert_equals(size_t, 10, ll_front(ll));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 10, ll_back(ll));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 10, ll_get(ll, 0));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, ll_get_ref(ll, 0));
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
|
||||
cmc_assert(ll_contains(ll, 10));
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 3, total_delete);
|
||||
cmc_assert_equals(int32_t, 0, total_resize);
|
||||
|
||||
ll_customize(ll, NULL, NULL);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, ll->callbacks);
|
||||
|
||||
ll_clear(ll);
|
||||
cmc_assert(ll_push_front(ll, 10));
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
cmc_assert(ll_push_at(ll, 10, 1));
|
||||
cmc_assert(ll_pop_at(ll, 1));
|
||||
cmc_assert(ll_pop_front(ll));
|
||||
cmc_assert(ll_pop_back(ll));
|
||||
cmc_assert(ll_push_back(ll, 10));
|
||||
cmc_assert_equals(size_t, 10, ll_front(ll));
|
||||
cmc_assert_equals(size_t, 10, ll_back(ll));
|
||||
cmc_assert_equals(size_t, 10, ll_get(ll, 0));
|
||||
cmc_assert_not_equals(ptr, NULL, ll_get_ref(ll, 0));
|
||||
cmc_assert(ll_contains(ll, 10));
|
||||
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 3, total_delete);
|
||||
cmc_assert_equals(int32_t, 0, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, ll->callbacks);
|
||||
|
||||
ll_free(ll);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
});
|
||||
@@ -1,615 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/list.c"
|
||||
|
||||
struct list_ftab_val *l_ftab_val = &(struct list_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
CMC_CREATE_UNIT(list_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct list *l = l_new(1000000, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
cmc_assert_not_equals(ptr, NULL, l->buffer);
|
||||
cmc_assert_equals(size_t, 1000000, l_capacity(l));
|
||||
cmc_assert_equals(size_t, 0, l_count(l));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = 0], {
|
||||
struct list *l = l_new(0, l_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = UINT64_MAX], {
|
||||
struct list *l = l_new(UINT64_MAX, l_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count capacity], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
l_push_back(l, i);
|
||||
|
||||
cmc_assert_equals(size_t, 50, l_count(l));
|
||||
|
||||
l_clear(l);
|
||||
|
||||
cmc_assert_equals(size_t, 0, l_count(l));
|
||||
cmc_assert_equals(size_t, 100, l_capacity(l));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(buffer_growth[capacity = 1], {
|
||||
struct list *l = l_new(1, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
l_push_back(l, i);
|
||||
|
||||
cmc_assert_equals(size_t, 100, l_count(l));
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert_equals(size_t, i, l_get(l, i));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_front[count], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
cmc_assert(l_push_front(l, i));
|
||||
|
||||
cmc_assert_equals(size_t, 250, l_count(l));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_front[capacity], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
cmc_assert(l_push_front(l, i));
|
||||
|
||||
cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_front[item preservation], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
cmc_assert(l_push_front(l, i));
|
||||
|
||||
for (size_t i = 0; i < l_count(l); i++)
|
||||
cmc_assert_equals(size_t, l_get(l, i), l_count(l) - i - 1);
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_at[count], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
|
||||
cmc_assert(l_push_back(l, 0));
|
||||
cmc_assert(l_push_back(l, 249));
|
||||
|
||||
for (size_t i = 1; i < 249; i++)
|
||||
cmc_assert(l_push_at(l, i, l_count(l) - 1));
|
||||
|
||||
cmc_assert_equals(size_t, 250, l_count(l));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_at[capacity], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
|
||||
cmc_assert(l_push_back(l, 0));
|
||||
cmc_assert(l_push_back(l, 249));
|
||||
|
||||
for (size_t i = 1; i < 249; i++)
|
||||
cmc_assert(l_push_at(l, i, l_count(l) - 1));
|
||||
|
||||
cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_at[item preservation], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
|
||||
cmc_assert(l_push_back(l, 0));
|
||||
cmc_assert(l_push_back(l, 249));
|
||||
|
||||
for (size_t i = 1; i < 249; i++)
|
||||
cmc_assert(l_push_at(l, i, l_count(l) - 1));
|
||||
|
||||
for (size_t i = 0; i < l_count(l); i++)
|
||||
cmc_assert_equals(size_t, l_get(l, i), i);
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_back[count], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
cmc_assert(l_push_back(l, i));
|
||||
|
||||
cmc_assert_equals(size_t, 250, l_count(l));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_back[capacity], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
cmc_assert(l_push_back(l, i));
|
||||
|
||||
cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push_back[item preservation], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
cmc_assert(l_push_back(l, i));
|
||||
|
||||
for (size_t i = 0; i < l_count(l); i++)
|
||||
cmc_assert_equals(size_t, l_get(l, i), i);
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop_front[count], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
l_push_back(l, i);
|
||||
|
||||
cmc_assert(l_pop_front(l));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop_front[item preservation], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
l_push_back(l, i);
|
||||
|
||||
cmc_assert(l_pop_front(l));
|
||||
|
||||
for (size_t i = 0; i < l_count(l); i++)
|
||||
cmc_assert_equals(size_t, l_get(l, i), i + 1);
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop_front[count = 0], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
cmc_assert(!l_pop_front(l));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop_front[count = 1], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
cmc_assert(l_push_back(l, 10));
|
||||
cmc_assert(l_pop_front(l));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop_front[buffer_clear], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
cmc_assert(l_push_back(l, 1));
|
||||
cmc_assert(l_push_front(l, 2));
|
||||
|
||||
cmc_assert(l_pop_front(l));
|
||||
|
||||
cmc_assert_equals(size_t, 0, l->buffer[1]);
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop_at[count = 0], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
cmc_assert(!l_pop_at(l, 1));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop_at[count = 1], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
cmc_assert(l_push_back(l, 1));
|
||||
cmc_assert(l_pop_at(l, 0));
|
||||
|
||||
cmc_assert_equals(size_t, 0, l->buffer[0]);
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop_at[buffer_clear], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
cmc_assert(l_push_back(l, 1));
|
||||
cmc_assert(l_push_back(l, 2));
|
||||
cmc_assert(l_push_back(l, 3));
|
||||
cmc_assert(l_pop_at(l, 1));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop_back[count = 0], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
cmc_assert(!l_pop_back(l));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop_back[count = 1], {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
cmc_assert(l_push_back(l, 10));
|
||||
cmc_assert(l_pop_back(l));
|
||||
|
||||
l_free(l);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct list *l = l_new(100, l_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
// clear
|
||||
l->flag = cmc_flags.ERROR;
|
||||
l_clear(l);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
// customize
|
||||
l->flag = cmc_flags.ERROR;
|
||||
l_customize(l, NULL, NULL);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
// push_front
|
||||
l->flag = cmc_flags.ERROR;
|
||||
cmc_assert(l_push_front(l, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
// push_at
|
||||
cmc_assert(!l_push_at(l, 5, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.RANGE, l_flag(l));
|
||||
cmc_assert(l_push_at(l, 5, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
// push_back
|
||||
l->flag = cmc_flags.ERROR;
|
||||
cmc_assert(l_push_back(l, 0));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
// pop_front
|
||||
l->flag = cmc_flags.ERROR;
|
||||
cmc_assert(l_pop_front(l));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
l_clear(l);
|
||||
cmc_assert(!l_pop_front(l));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, l_flag(l));
|
||||
|
||||
// pop_back
|
||||
cmc_assert(l_push_front(l, 10));
|
||||
l->flag = cmc_flags.ERROR;
|
||||
cmc_assert(l_pop_back(l));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
cmc_assert(!l_pop_front(l));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, l_flag(l));
|
||||
|
||||
// pop_at
|
||||
l->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!l_pop_at(l, 0));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, l_flag(l));
|
||||
|
||||
cmc_assert(l_push_back(l, 10));
|
||||
cmc_assert(!l_pop_at(l, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.RANGE, l_flag(l));
|
||||
|
||||
cmc_assert(l_pop_at(l, 0));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
// seq_push_front
|
||||
cmc_assert(!l_seq_push_front(l, NULL, 0));
|
||||
cmc_assert_equals(int32_t, cmc_flags.INVALID, l_flag(l));
|
||||
|
||||
cmc_assert(l_seq_push_front(l, (size_t[2]){ 1, 2 }, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
// seq_push_at
|
||||
cmc_assert(!l_seq_push_at(l, NULL, 0, 0));
|
||||
cmc_assert_equals(int32_t, cmc_flags.INVALID, l_flag(l));
|
||||
|
||||
cmc_assert(!l_seq_push_at(l, (size_t[2]){ 1, 2 }, 2, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.RANGE, l_flag(l));
|
||||
|
||||
cmc_assert(l_seq_push_at(l, (size_t[2]){ 1, 2 }, 2, l_count(l) - 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
// seq_push_back
|
||||
cmc_assert(!l_seq_push_back(l, NULL, 0));
|
||||
cmc_assert_equals(int32_t, cmc_flags.INVALID, l_flag(l));
|
||||
|
||||
cmc_assert(l_seq_push_back(l, (size_t[2]){ 1, 2 }, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
// seq_pop_at
|
||||
cmc_assert(!l_seq_pop_at(l, 10, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.INVALID, l_flag(l));
|
||||
|
||||
cmc_assert(!l_seq_pop_at(l, 100, 200));
|
||||
cmc_assert_equals(int32_t, cmc_flags.RANGE, l_flag(l));
|
||||
|
||||
cmc_assert(l_seq_pop_at(l, 1, l_count(l) - 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
// seq_sublist
|
||||
struct list *l2 = l_seq_sublist(l, 10, 1);
|
||||
cmc_assert_equals(ptr, NULL, l2);
|
||||
cmc_assert_equals(int32_t, cmc_flags.INVALID, l_flag(l));
|
||||
|
||||
l2 = l_seq_sublist(l, 100, 200);
|
||||
cmc_assert_equals(ptr, NULL, l2);
|
||||
cmc_assert_equals(int32_t, cmc_flags.RANGE, l_flag(l));
|
||||
|
||||
l2 = l_seq_sublist(l, 0, l_count(l) - 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l2));
|
||||
|
||||
l_clear(l);
|
||||
|
||||
// l_front
|
||||
l_front(l);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, l_flag(l));
|
||||
|
||||
cmc_assert(l_push_back(l, 10));
|
||||
l->flag = cmc_flags.ERROR;
|
||||
l_front(l);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
l_clear(l);
|
||||
|
||||
// l_back
|
||||
l_back(l);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, l_flag(l));
|
||||
|
||||
cmc_assert(l_push_back(l, 10));
|
||||
l->flag = cmc_flags.ERROR;
|
||||
l_back(l);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
l_clear(l);
|
||||
|
||||
// get, get_ref
|
||||
l_get(l, 0);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, l_flag(l));
|
||||
l->flag = cmc_flags.ERROR;
|
||||
l_get_ref(l, 0);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, l_flag(l));
|
||||
|
||||
cmc_assert(l_push_back(l, 10));
|
||||
|
||||
l_get(l, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.RANGE, l_flag(l));
|
||||
l->flag = cmc_flags.ERROR;
|
||||
l_get_ref(l, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.RANGE, l_flag(l));
|
||||
|
||||
l_get(l, 0);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
l->flag = cmc_flags.ERROR;
|
||||
l_get_ref(l, 0);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
// index_of
|
||||
l->flag = cmc_flags.ERROR;
|
||||
l_index_of(l, 10, false);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
// contains
|
||||
l->flag = cmc_flags.ERROR;
|
||||
cmc_assert(l_contains(l, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
|
||||
// copy_of
|
||||
l->flag = cmc_flags.ERROR;
|
||||
struct list *l3 = l_copy_of(l);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l3));
|
||||
|
||||
// equals
|
||||
l->flag = cmc_flags.ERROR;
|
||||
l3->flag = cmc_flags.ERROR;
|
||||
cmc_assert(l_equals(l, l3));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, l_flag(l3));
|
||||
|
||||
l_free(l);
|
||||
l_free(l2);
|
||||
l_free(l3);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct list *l = l_new_custom(100, l_ftab_val, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(l_push_front(l, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(l_push_back(l, 10));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert(l_push_at(l, 10, 1));
|
||||
cmc_assert_equals(int32_t, 3, total_create);
|
||||
|
||||
cmc_assert(l_pop_at(l, 1));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(l_pop_front(l));
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
|
||||
cmc_assert(l_pop_back(l));
|
||||
cmc_assert_equals(int32_t, 3, total_delete);
|
||||
|
||||
cmc_assert(l_push_back(l, 10));
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
|
||||
cmc_assert_equals(size_t, 10, l_front(l));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 10, l_back(l));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 10, l_get(l, 0));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, l_get_ref(l, 0));
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
|
||||
cmc_assert(l_contains(l, 10));
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
|
||||
cmc_assert(l_seq_push_front(l, (size_t[]){ 7, 8, 9 }, 3));
|
||||
cmc_assert_equals(int32_t, 5, total_create);
|
||||
|
||||
cmc_assert(l_seq_push_back(l, (size_t[]){ 14, 15, 16 }, 3));
|
||||
cmc_assert_equals(int32_t, 6, total_create);
|
||||
|
||||
cmc_assert(l_seq_push_at(l, (size_t[]){ 11, 12, 13 }, 3, 4));
|
||||
cmc_assert_equals(int32_t, 7, total_create);
|
||||
|
||||
cmc_assert(l_seq_pop_at(l, 1, 4));
|
||||
cmc_assert_equals(int32_t, 4, total_delete);
|
||||
|
||||
struct list *l2 = l_seq_sublist(l, 0, 4);
|
||||
cmc_assert_equals(int32_t, 5, total_delete);
|
||||
|
||||
cmc_assert(l_resize(l, 1000));
|
||||
cmc_assert_equals(int32_t, 1, total_resize);
|
||||
|
||||
cmc_assert(l_resize(l2, 1000));
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(int32_t, 7, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 5, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
l_customize(l, NULL, NULL);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, l->callbacks);
|
||||
|
||||
l_clear(l);
|
||||
cmc_assert(l_push_front(l, 10));
|
||||
cmc_assert(l_push_back(l, 10));
|
||||
cmc_assert(l_push_at(l, 10, 1));
|
||||
cmc_assert(l_pop_at(l, 1));
|
||||
cmc_assert(l_pop_front(l));
|
||||
cmc_assert(l_pop_back(l));
|
||||
cmc_assert(l_push_back(l, 10));
|
||||
cmc_assert_equals(size_t, 10, l_front(l));
|
||||
cmc_assert_equals(size_t, 10, l_back(l));
|
||||
cmc_assert_equals(size_t, 10, l_get(l, 0));
|
||||
cmc_assert_not_equals(ptr, NULL, l_get_ref(l, 0));
|
||||
cmc_assert(l_contains(l, 10));
|
||||
cmc_assert(l_seq_push_front(l, (size_t[]){ 7, 8, 9 }, 3));
|
||||
cmc_assert(l_seq_push_back(l, (size_t[]){ 14, 15, 16 }, 3));
|
||||
cmc_assert(l_seq_push_at(l, (size_t[]){ 11, 12, 13 }, 3, 4));
|
||||
cmc_assert(l_seq_pop_at(l, 1, 4));
|
||||
struct list *l3 = l_seq_sublist(l, 0, 4);
|
||||
cmc_assert(l_resize(l, 1000));
|
||||
cmc_assert(l_resize(l3, 1000));
|
||||
|
||||
cmc_assert_equals(int32_t, 7, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 5, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, l->callbacks);
|
||||
|
||||
l_free(l);
|
||||
l_free(l2);
|
||||
l_free(l3);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
})
|
||||
@@ -1,374 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/multimap.c"
|
||||
|
||||
struct multimap_ftab_key *mm_ftab_key =
|
||||
&(struct multimap_ftab_key){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
struct multimap_ftab_val *mm_ftab_val =
|
||||
&(struct multimap_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
CMC_CREATE_UNIT(multimap_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct multimap *map = mm_new(943722, 0.8, mm_ftab_key, mm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
cmc_assert_not_equals(ptr, NULL, map->buffer);
|
||||
cmc_assert_equals(size_t, 0, mm_count(map));
|
||||
cmc_assert_greater_equals(size_t, (943722 / 0.8), mm_capacity(map));
|
||||
|
||||
mm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = 0], {
|
||||
struct multimap *map = mm_new(0, 0.8, mm_ftab_key, mm_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = UINT64_MAX], {
|
||||
struct multimap *map =
|
||||
mm_new(UINT64_MAX, 0.99, mm_ftab_key, mm_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count capacity], {
|
||||
struct multimap *map = mm_new(100, 0.8, mm_ftab_key, mm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
cmc_assert(mm_insert(map, i, i));
|
||||
|
||||
cmc_assert_equals(size_t, 50, mm_count(map));
|
||||
|
||||
mm_clear(map);
|
||||
|
||||
cmc_assert_equals(size_t, 0, mm_count(map));
|
||||
|
||||
mm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[count], {
|
||||
struct multimap *map = mm_new(100, 0.8, mm_ftab_key, mm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(mm_insert(map, i % 20, i % 20));
|
||||
|
||||
cmc_assert_equals(size_t, 100, mm_count(map));
|
||||
|
||||
mm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove[count], {
|
||||
struct multimap *map = mm_new(100, 0.8, mm_ftab_key, mm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 200; i++)
|
||||
cmc_assert(mm_insert(map, i % 20, i % 20));
|
||||
|
||||
size_t r;
|
||||
|
||||
for (size_t i = 0; i < 60; i++)
|
||||
cmc_assert(mm_remove(map, i % 20, &r));
|
||||
|
||||
cmc_assert_equals(size_t, 140, mm_count(map));
|
||||
|
||||
mm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove[count = 0], {
|
||||
struct multimap *map = mm_new(100, 0.8, mm_ftab_key, mm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
size_t r;
|
||||
|
||||
cmc_assert(!mm_remove(map, 10, &r));
|
||||
|
||||
mm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove[count = 1], {
|
||||
struct multimap *map = mm_new(100, 0.8, mm_ftab_key, mm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
size_t r;
|
||||
|
||||
cmc_assert(mm_insert(map, 10, 11));
|
||||
cmc_assert(mm_remove(map, 10, &r));
|
||||
|
||||
mm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(get[key ordering], {
|
||||
struct multimap *map = mm_new(100, 0.8, mm_ftab_key, mm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
/* Assert that the value 100 is accessed before the value 101 for */
|
||||
/* the same key */
|
||||
cmc_assert(mm_insert(map, 10, 100));
|
||||
cmc_assert(mm_insert(map, 20, 102));
|
||||
cmc_assert(mm_insert(map, 10, 101));
|
||||
|
||||
cmc_assert_equals(size_t, 100, mm_get(map, 10));
|
||||
|
||||
mm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(key_count, {
|
||||
struct multimap *map = mm_new(50, 0.8, mm_ftab_key, mm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 1000; i++)
|
||||
cmc_assert(mm_insert(map, i % 20, i % 20));
|
||||
|
||||
cmc_assert_equals(size_t, 1000, mm_count(map));
|
||||
|
||||
for (size_t i = 0; i < 20; i++)
|
||||
cmc_assert_equals(size_t, 50, mm_key_count(map, i));
|
||||
|
||||
mm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct multimap *map = mm_new(100, 0.8, mm_ftab_key, mm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
|
||||
// clear
|
||||
map->flag = cmc_flags.ERROR;
|
||||
mm_clear(map);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
|
||||
// customize
|
||||
map->flag = cmc_flags.ERROR;
|
||||
mm_customize(map, NULL, NULL);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
|
||||
// insert
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(mm_insert(map, 1, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
|
||||
// update
|
||||
cmc_assert(!mm_update(map, 9, 10, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, mm_flag(map));
|
||||
|
||||
cmc_assert(mm_update(map, 1, 20, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
|
||||
// update_all
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert_equals(size_t, 1, mm_update_all(map, 1, 2, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert_equals(size_t, 0, mm_update_all(map, 2, 4, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, mm_flag(map));
|
||||
|
||||
mm_clear(map);
|
||||
cmc_assert_equals(size_t, 0, mm_update_all(map, 1, 2, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, mm_flag(map));
|
||||
|
||||
// remove
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!mm_remove(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, mm_flag(map));
|
||||
|
||||
cmc_assert(mm_insert(map, 1, 1));
|
||||
cmc_assert(!mm_remove(map, 2, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, mm_flag(map));
|
||||
|
||||
cmc_assert(mm_remove(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
|
||||
// remove_all
|
||||
cmc_assert(!mm_remove_all(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, mm_flag(map));
|
||||
|
||||
cmc_assert(mm_insert(map, 1, 1) && mm_insert(map, 1, 1));
|
||||
cmc_assert_equals(size_t, 0, mm_remove_all(map, 2, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, mm_flag(map));
|
||||
|
||||
cmc_assert_equals(size_t, 2, mm_remove_all(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
|
||||
// max min
|
||||
cmc_assert(!mm_max(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, mm_flag(map));
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!mm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, mm_flag(map));
|
||||
|
||||
cmc_assert(mm_insert(map, 1, 1));
|
||||
cmc_assert(mm_max(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(mm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
|
||||
// get get_ref
|
||||
mm_get(map, 2);
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, mm_flag(map));
|
||||
map->flag = cmc_flags.ERROR;
|
||||
mm_get_ref(map, 2);
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, mm_flag(map));
|
||||
|
||||
mm_get(map, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
map->flag = cmc_flags.ERROR;
|
||||
mm_get_ref(map, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
|
||||
mm_clear(map);
|
||||
mm_get(map, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, mm_flag(map));
|
||||
map->flag = cmc_flags.ERROR;
|
||||
mm_get_ref(map, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, mm_flag(map));
|
||||
|
||||
// contains
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!mm_contains(map, 1000));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
|
||||
// copy_of
|
||||
map->flag = cmc_flags.ERROR;
|
||||
struct multimap *map2 = mm_copy_of(map);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map2));
|
||||
|
||||
// equals
|
||||
map->flag = cmc_flags.ERROR;
|
||||
map2->flag = cmc_flags.ERROR;
|
||||
cmc_assert(mm_equals(map, map2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, mm_flag(map2));
|
||||
|
||||
mm_free(map);
|
||||
mm_free(map2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct multimap *map =
|
||||
mm_new_custom(100, 0.8, mm_ftab_key, mm_ftab_val, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(mm_insert(map, 1, 1));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(mm_update(map, 1, 2, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_update);
|
||||
|
||||
cmc_assert(mm_insert(map, 1, 1));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert_equals(size_t, 2, mm_update_all(map, 1, 3, NULL));
|
||||
cmc_assert_equals(int32_t, 2, total_update);
|
||||
|
||||
cmc_assert(mm_remove(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(mm_insert(map, 1, 2));
|
||||
cmc_assert_equals(int32_t, 3, total_create);
|
||||
|
||||
cmc_assert_equals(size_t, 2, mm_remove_all(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
|
||||
cmc_assert(mm_insert(map, 1, 2));
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
|
||||
cmc_assert(mm_max(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert(mm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 2, mm_get(map, 1));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, mm_get_ref(map, 1));
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
|
||||
cmc_assert(mm_contains(map, 1));
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
|
||||
cmc_assert(mm_resize(map, 1000));
|
||||
cmc_assert_equals(int32_t, 1, total_resize);
|
||||
|
||||
cmc_assert(mm_resize(map, 100));
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 2, total_update);
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
mm_customize(map, NULL, NULL);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, map->callbacks);
|
||||
|
||||
mm_clear(map);
|
||||
cmc_assert(mm_insert(map, 1, 1));
|
||||
cmc_assert(mm_update(map, 1, 2, NULL));
|
||||
cmc_assert(mm_insert(map, 1, 1));
|
||||
cmc_assert_equals(size_t, 2, mm_update_all(map, 1, 3, NULL));
|
||||
cmc_assert(mm_remove(map, 1, NULL));
|
||||
cmc_assert(mm_insert(map, 1, 2));
|
||||
cmc_assert_equals(size_t, 2, mm_remove_all(map, 1, NULL));
|
||||
cmc_assert(mm_insert(map, 1, 2));
|
||||
cmc_assert(mm_max(map, NULL, NULL));
|
||||
cmc_assert(mm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(size_t, 2, mm_get(map, 1));
|
||||
cmc_assert_not_equals(ptr, NULL, mm_get_ref(map, 1));
|
||||
cmc_assert(mm_contains(map, 1));
|
||||
cmc_assert(mm_resize(map, 1000));
|
||||
cmc_assert(mm_resize(map, 100));
|
||||
|
||||
cmc_assert_equals(int32_t, 4, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 2, total_update);
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, map->callbacks);
|
||||
|
||||
mm_free(map);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
});
|
||||
@@ -1,352 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/multiset.c"
|
||||
|
||||
struct multiset_ftab_val *ms_ftab_val =
|
||||
&(struct multiset_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
CMC_CREATE_UNIT(multiset_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct multiset *set = ms_new(943722, 0.6, ms_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
cmc_assert_not_equals(ptr, NULL, set->buffer);
|
||||
cmc_assert_equals(size_t, 0, ms_count(set));
|
||||
cmc_assert_greater_equals(size_t, ((size_t)(943722 / 0.6)),
|
||||
ms_capacity(set));
|
||||
|
||||
ms_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = 0], {
|
||||
struct multiset *set = ms_new(0, 0.6, ms_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = UINT64_MAX], {
|
||||
struct multiset *set = ms_new(UINT64_MAX, 0.99, ms_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count capacity], {
|
||||
struct multiset *set = ms_new(100, 0.6, ms_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
cmc_assert(ms_insert(set, i));
|
||||
|
||||
cmc_assert_equals(size_t, 50, ms_count(set));
|
||||
|
||||
ms_clear(set);
|
||||
|
||||
cmc_assert_equals(size_t, 0, ms_count(set));
|
||||
|
||||
ms_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert[count cardinality multiplicity], {
|
||||
struct multiset *set = ms_new(100, 0.6, ms_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert(ms_insert(set, 1));
|
||||
cmc_assert(ms_insert(set, 2));
|
||||
cmc_assert(ms_insert(set, 2));
|
||||
cmc_assert(ms_insert(set, 3));
|
||||
cmc_assert(ms_insert(set, 3));
|
||||
cmc_assert(ms_insert(set, 3));
|
||||
|
||||
cmc_assert_equals(size_t, 3, ms_count(set));
|
||||
cmc_assert_equals(size_t, 6, ms_cardinality(set));
|
||||
|
||||
for (size_t i = 0; i <= 3; i++)
|
||||
cmc_assert_equals(size_t, i, ms_multiplicity_of(set, i));
|
||||
|
||||
ms_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove[count cardinality multiplicity], {
|
||||
struct multiset *set = ms_new(100, 0.6, ms_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert(ms_insert(set, 1));
|
||||
cmc_assert(ms_insert(set, 2));
|
||||
cmc_assert(ms_insert(set, 2));
|
||||
cmc_assert(ms_insert(set, 3));
|
||||
cmc_assert(ms_insert(set, 3));
|
||||
cmc_assert(ms_insert(set, 3));
|
||||
|
||||
cmc_assert_equals(size_t, 3, ms_count(set));
|
||||
cmc_assert_equals(size_t, 6, ms_cardinality(set));
|
||||
|
||||
for (size_t i = 0; i <= 3; i++)
|
||||
cmc_assert_equals(size_t, i, ms_multiplicity_of(set, i));
|
||||
|
||||
cmc_assert(ms_remove(set, 1));
|
||||
cmc_assert(ms_remove(set, 2));
|
||||
cmc_assert(ms_remove(set, 3));
|
||||
|
||||
cmc_assert_equals(size_t, 2, ms_count(set));
|
||||
cmc_assert_equals(size_t, 3, ms_cardinality(set));
|
||||
|
||||
cmc_assert_equals(size_t, 0, ms_multiplicity_of(set, 0));
|
||||
cmc_assert_equals(size_t, 0, ms_multiplicity_of(set, 1));
|
||||
cmc_assert_equals(size_t, 1, ms_multiplicity_of(set, 2));
|
||||
cmc_assert_equals(size_t, 2, ms_multiplicity_of(set, 3));
|
||||
|
||||
ms_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove_all[count cardinality multiplicity], {
|
||||
struct multiset *set = ms_new(100, 0.6, ms_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
cmc_assert(ms_insert(set, 1));
|
||||
cmc_assert(ms_insert(set, 2));
|
||||
cmc_assert(ms_insert(set, 2));
|
||||
cmc_assert(ms_insert(set, 3));
|
||||
cmc_assert(ms_insert(set, 3));
|
||||
cmc_assert(ms_insert(set, 3));
|
||||
|
||||
cmc_assert_equals(size_t, 3, ms_count(set));
|
||||
cmc_assert_equals(size_t, 6, ms_cardinality(set));
|
||||
|
||||
for (size_t i = 0; i <= 3; i++)
|
||||
cmc_assert_equals(size_t, i, ms_multiplicity_of(set, i));
|
||||
|
||||
cmc_assert(ms_remove_all(set, 1));
|
||||
cmc_assert(ms_remove_all(set, 3));
|
||||
|
||||
cmc_assert_equals(size_t, 1, ms_count(set));
|
||||
cmc_assert_equals(size_t, 2, ms_cardinality(set));
|
||||
|
||||
cmc_assert_equals(size_t, 0, ms_multiplicity_of(set, 0));
|
||||
cmc_assert_equals(size_t, 0, ms_multiplicity_of(set, 1));
|
||||
cmc_assert_equals(size_t, 2, ms_multiplicity_of(set, 2));
|
||||
cmc_assert_equals(size_t, 0, ms_multiplicity_of(set, 3));
|
||||
|
||||
ms_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(multiplicity, {
|
||||
struct multiset *set = ms_new(50, 0.6, ms_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
for (size_t i = 0; i < 1000; i++)
|
||||
cmc_assert(ms_insert(set, i % 20));
|
||||
|
||||
cmc_assert_equals(size_t, 20, ms_count(set));
|
||||
cmc_assert_equals(size_t, 1000, ms_cardinality(set));
|
||||
|
||||
for (size_t i = 0; i < 20; i++)
|
||||
cmc_assert_equals(size_t, 50, ms_multiplicity_of(set, i));
|
||||
|
||||
ms_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct multiset *set = ms_new(100, 0.6, ms_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
|
||||
// clear
|
||||
set->flag = cmc_flags.ERROR;
|
||||
ms_clear(set);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
|
||||
// customize
|
||||
set->flag = cmc_flags.ERROR;
|
||||
ms_customize(set, NULL, NULL);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
|
||||
// insert
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ms_insert(set, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ms_insert(set, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
|
||||
// insert_many
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ms_insert_many(set, 1, 0));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ms_insert_many(set, 1, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
|
||||
// update
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ms_update(set, 1, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ms_update(set, 10, 0));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
|
||||
// remove
|
||||
cmc_assert(!ms_remove(set, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, ms_flag(set));
|
||||
|
||||
cmc_assert(ms_remove(set, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
|
||||
// remove_all
|
||||
cmc_assert_equals(size_t, 0, ms_remove_all(set, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ms_flag(set));
|
||||
|
||||
cmc_assert(ms_insert_many(set, 1, 10));
|
||||
cmc_assert_equals(size_t, 0, ms_remove_all(set, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, ms_flag(set));
|
||||
|
||||
cmc_assert_equals(size_t, 10, ms_remove_all(set, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
|
||||
// max min
|
||||
cmc_assert(!ms_max(set, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ms_flag(set));
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!ms_min(set, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ms_flag(set));
|
||||
|
||||
cmc_assert(ms_insert(set, 1));
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ms_max(set, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ms_min(set, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
|
||||
// multiplicity_of
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert_equals(size_t, 0, ms_multiplicity_of(set, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
|
||||
// contains
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!ms_contains(set, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
|
||||
// copy_of
|
||||
set->flag = cmc_flags.ERROR;
|
||||
struct multiset *set2 = ms_copy_of(set);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set2));
|
||||
|
||||
// equals
|
||||
set->flag = cmc_flags.ERROR;
|
||||
set2->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ms_equals(set, set2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ms_flag(set2));
|
||||
|
||||
ms_free(set);
|
||||
ms_free(set2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct multiset *set =
|
||||
ms_new_custom(100, 0.8, ms_ftab_val, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(ms_insert(set, 1));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(ms_insert_many(set, 1, 3));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert(ms_update(set, 1, 0));
|
||||
cmc_assert_equals(int32_t, 1, total_update);
|
||||
|
||||
cmc_assert(ms_update(set, 1, 10));
|
||||
cmc_assert_equals(int32_t, 2, total_update);
|
||||
|
||||
cmc_assert(ms_remove(set, 1));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(ms_remove_all(set, 1));
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
|
||||
cmc_assert(ms_update(set, 1, 10));
|
||||
cmc_assert_equals(int32_t, 3, total_update);
|
||||
|
||||
cmc_assert(ms_max(set, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert(ms_min(set, NULL));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert(ms_contains(set, 1));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert(ms_resize(set, 1000));
|
||||
cmc_assert_equals(int32_t, 1, total_resize);
|
||||
|
||||
cmc_assert(ms_resize(set, 100));
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
cmc_assert_equals(int32_t, 3, total_update);
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
ms_customize(set, NULL, NULL);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, set->callbacks);
|
||||
|
||||
ms_clear(set);
|
||||
cmc_assert(ms_insert(set, 1));
|
||||
cmc_assert(ms_insert_many(set, 1, 3));
|
||||
cmc_assert(ms_update(set, 1, 0));
|
||||
cmc_assert(ms_update(set, 1, 10));
|
||||
cmc_assert(ms_remove(set, 1));
|
||||
cmc_assert(ms_remove_all(set, 1));
|
||||
cmc_assert(ms_update(set, 1, 10));
|
||||
cmc_assert(ms_max(set, NULL));
|
||||
cmc_assert(ms_min(set, NULL));
|
||||
cmc_assert(ms_contains(set, 1));
|
||||
cmc_assert(ms_resize(set, 1000));
|
||||
cmc_assert(ms_resize(set, 100));
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
cmc_assert_equals(int32_t, 3, total_update);
|
||||
cmc_assert_equals(int32_t, 2, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, set->callbacks);
|
||||
|
||||
ms_free(set);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
});
|
||||
@@ -1,547 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/queue.c"
|
||||
|
||||
struct queue_ftab_val *q_ftab_val =
|
||||
&(struct queue_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
CMC_CREATE_UNIT(queue_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct queue *q = q_new(1000000, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
cmc_assert_not_equals(ptr, NULL, q->buffer);
|
||||
cmc_assert_equals(size_t, 1000000, q_capacity(q));
|
||||
cmc_assert_equals(size_t, 0, q_count(q));
|
||||
cmc_assert_not_equals(ptr, NULL, q->buffer);
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = 0], {
|
||||
struct queue *q = q_new(0, q_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = UINT64_MAX], {
|
||||
struct queue *q = q_new(UINT64_MAX, q_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count capacity], {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
cmc_assert(q_enqueue(q, i));
|
||||
|
||||
cmc_assert_equals(size_t, 50, q_count(q));
|
||||
|
||||
q_clear(q);
|
||||
|
||||
cmc_assert_equals(size_t, 0, q_count(q));
|
||||
cmc_assert_equals(size_t, 100, q_capacity(q));
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(buffer_growth[capacity = 1], {
|
||||
struct queue *q = q_new(1, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
cmc_assert(q_enqueue(q, i));
|
||||
|
||||
cmc_assert_equals(size_t, 50, q_count(q));
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(buffer_growth[item preservation], {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
for (size_t i = 1; i <= 1200; i++)
|
||||
{
|
||||
q_enqueue(q, i);
|
||||
}
|
||||
|
||||
size_t sum = 0;
|
||||
for (size_t i = q->front, j = 0; j < q->count;
|
||||
i = (i + 1) % q->capacity, j++)
|
||||
sum += q->buffer[i];
|
||||
|
||||
cmc_assert_equals(size_t, 1200, q_count(q));
|
||||
cmc_assert_equals(size_t, 720600, sum);
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(enqueue[count capacity], {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
for (size_t i = 0; i < 150; i++)
|
||||
cmc_assert(q_enqueue(q, i));
|
||||
|
||||
cmc_assert_equals(size_t, 150, q_count(q));
|
||||
cmc_assert_greater(size_t, 100, q_capacity(q));
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(enqueue[item preservation], {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
for (size_t i = 1; i <= 100; i++)
|
||||
cmc_assert(q_enqueue(q, i));
|
||||
|
||||
size_t sum = 0;
|
||||
|
||||
for (size_t i = q->front, j = 0; j < q->count;
|
||||
i = (i + 1) % q->capacity, j++)
|
||||
{
|
||||
sum += q->buffer[i];
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 5050, sum);
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(dequeue[count capacity], {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
cmc_assert(q_enqueue(q, 10));
|
||||
cmc_assert(q_dequeue(q));
|
||||
|
||||
cmc_assert_equals(size_t, 0, q_count(q));
|
||||
|
||||
cmc_assert(q_enqueue(q, 10));
|
||||
cmc_assert(q_dequeue(q));
|
||||
|
||||
cmc_assert_equals(size_t, 0, q_count(q));
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(dequeue[item preservation], {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
for (size_t i = 200; i > 0; i--)
|
||||
cmc_assert(q_enqueue(q, i));
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(q_dequeue(q));
|
||||
|
||||
size_t sum = 0;
|
||||
|
||||
for (size_t i = q->front, j = 0; j < q->count;
|
||||
i = (i + 1) % q->capacity, j++)
|
||||
{
|
||||
sum += q->buffer[i];
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 5050, sum);
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(peek[count = 0], {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
size_t r = q_peek(q);
|
||||
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, r);
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(peek[sum], {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
size_t sum = 0;
|
||||
|
||||
for (size_t i = 0; i <= 100; i++)
|
||||
cmc_assert(q_enqueue(q, i));
|
||||
|
||||
while (!q_empty(q))
|
||||
{
|
||||
size_t r = q_peek(q);
|
||||
|
||||
sum += r;
|
||||
|
||||
cmc_assert(q_dequeue(q));
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 5050, sum);
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(contains, {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
for (size_t i = 1; i <= 20; i++)
|
||||
cmc_assert(q_enqueue(q, i));
|
||||
|
||||
for (size_t i = 1; i <= 20; i++)
|
||||
cmc_assert(q_contains(q, i));
|
||||
|
||||
q_clear(q);
|
||||
|
||||
for (size_t i = 1; i <= 20; i++)
|
||||
cmc_assert(!q_contains(q, i));
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(contains[count = 0], {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
cmc_assert(!q_contains(q, 10));
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(contains[count = 1], {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
cmc_assert(!q_contains(q, 10));
|
||||
|
||||
cmc_assert(q_enqueue(q, 100));
|
||||
|
||||
cmc_assert(q_contains(q, 100));
|
||||
cmc_assert(!q_contains(q, 101));
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(empty, {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
cmc_assert(q_empty(q));
|
||||
|
||||
cmc_assert(q_enqueue(q, 1));
|
||||
|
||||
cmc_assert(!q_empty(q));
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(full, {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
cmc_assert(!q_full(q));
|
||||
|
||||
for (size_t i = 0; i != q_capacity(q); i++)
|
||||
cmc_assert(q_enqueue(q, i));
|
||||
|
||||
cmc_assert(q_full(q));
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(count, {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
cmc_assert_equals(size_t, 0, q_count(q));
|
||||
|
||||
for (size_t i = 0; i < 100; i++)
|
||||
cmc_assert(q_enqueue(q, i));
|
||||
|
||||
cmc_assert_equals(size_t, 100, q_count(q));
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(capacity, {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
cmc_assert_equals(size_t, 100, q_capacity(q));
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(resize, {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
for (size_t i = 0; i < 150; i++)
|
||||
cmc_assert(q_enqueue(q, i));
|
||||
|
||||
cmc_assert_equals(size_t, 150, q_count(q));
|
||||
cmc_assert(q_resize(q, q_count(q)));
|
||||
cmc_assert_equals(size_t, 150, q_capacity(q));
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(resize[item preservation], {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
for (size_t i = 1; i <= 150; i++)
|
||||
cmc_assert(q_enqueue(q, i));
|
||||
|
||||
cmc_assert(q_resize(q, q_count(q)));
|
||||
|
||||
size_t sum = 0;
|
||||
|
||||
for (size_t i = q->front, j = 0; j < q->count;
|
||||
i = (i + 1) % q->capacity, j++)
|
||||
{
|
||||
sum += q->buffer[i];
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 11325, sum);
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(copy_of, {
|
||||
struct queue *d1 = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d1);
|
||||
|
||||
for (size_t i = 1; i <= 150; i++)
|
||||
cmc_assert(q_enqueue(d1, i));
|
||||
|
||||
struct queue *d2 = q_copy_of(d1);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d2);
|
||||
cmc_assert_equals(size_t, q_count(d1), q_count(d2));
|
||||
|
||||
for (size_t i1 = d1->front, i2 = d2->front, j = 0; j < d1->count; j++)
|
||||
{
|
||||
cmc_assert_equals(size_t, d1->buffer[i1], d2->buffer[i2]);
|
||||
|
||||
i1 = (i1 + 1) % d1->capacity;
|
||||
i2 = (i2 + 1) % d2->capacity;
|
||||
}
|
||||
|
||||
q_free(d1);
|
||||
q_free(d2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(equals, {
|
||||
struct queue *d1 = q_new(100, q_ftab_val);
|
||||
struct queue *d2 = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d1);
|
||||
cmc_assert_not_equals(ptr, NULL, d2);
|
||||
|
||||
for (size_t i = 1; i <= 150; i++)
|
||||
{
|
||||
cmc_assert(q_enqueue(d1, i));
|
||||
cmc_assert(q_enqueue(d2, i));
|
||||
}
|
||||
|
||||
cmc_assert(q_equals(d1, d2));
|
||||
|
||||
q_free(d1);
|
||||
q_free(d2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(equals[from copy], {
|
||||
struct queue *d1 = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d1);
|
||||
|
||||
for (size_t i = 1; i <= 150; i++)
|
||||
{
|
||||
cmc_assert(q_enqueue(d1, i));
|
||||
}
|
||||
|
||||
struct queue *d2 = q_copy_of(d1);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d2);
|
||||
|
||||
cmc_assert(q_equals(d1, d2));
|
||||
|
||||
q_free(d1);
|
||||
q_free(d2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(equals[count = 0], {
|
||||
struct queue *d1 = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d1);
|
||||
|
||||
struct queue *d2 = q_copy_of(d1);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, d2);
|
||||
|
||||
cmc_assert(q_equals(d1, d2));
|
||||
|
||||
q_free(d1);
|
||||
q_free(d2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flag, {
|
||||
struct queue *q = q_new(100, q_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q));
|
||||
|
||||
// clear
|
||||
q->flag = cmc_flags.ERROR;
|
||||
q_clear(q);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q));
|
||||
|
||||
// customize
|
||||
q->flag = cmc_flags.ERROR;
|
||||
q_customize(q, NULL, NULL);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q));
|
||||
|
||||
// enqueue
|
||||
q->flag = cmc_flags.ERROR;
|
||||
q_enqueue(q, 10);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q));
|
||||
|
||||
// dequeue
|
||||
q->flag = cmc_flags.ERROR;
|
||||
q_dequeue(q);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q));
|
||||
|
||||
q_dequeue(q);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, q_flag(q));
|
||||
|
||||
// peek
|
||||
q->flag = cmc_flags.ERROR;
|
||||
q_peek(q);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, q_flag(q));
|
||||
|
||||
cmc_assert(q_enqueue(q, 10));
|
||||
q_peek(q);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q));
|
||||
|
||||
// contains
|
||||
q->flag = cmc_flags.ERROR;
|
||||
cmc_assert(q_contains(q, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q));
|
||||
|
||||
// copy_of
|
||||
q->flag = cmc_flags.OK;
|
||||
struct queue *q2 = q_copy_of(q);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q2));
|
||||
|
||||
// equals
|
||||
q->flag = cmc_flags.OK;
|
||||
q2->flag = cmc_flags.OK;
|
||||
cmc_assert(q_equals(q, q2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, q_flag(q2));
|
||||
|
||||
q_free(q);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct queue *q = q_new_custom(100, q_ftab_val, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, q);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(q_enqueue(q, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(q_dequeue(q));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(q_enqueue(q, 10));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert_equals(size_t, 10, q_peek(q));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert(q_contains(q, 10));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert(q_resize(q, 1000));
|
||||
cmc_assert_equals(int32_t, 1, total_resize);
|
||||
|
||||
cmc_assert(q_resize(q, 100));
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
q_customize(q, NULL, NULL);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, q->callbacks);
|
||||
|
||||
q_clear(q);
|
||||
cmc_assert(q_enqueue(q, 10));
|
||||
cmc_assert(q_dequeue(q));
|
||||
cmc_assert(q_enqueue(q, 10));
|
||||
cmc_assert_equals(size_t, 10, q_peek(q));
|
||||
cmc_assert(q_contains(q, 10));
|
||||
cmc_assert(q_resize(q, 1000));
|
||||
cmc_assert(q_resize(q, 100));
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, q->callbacks);
|
||||
|
||||
q_free(q);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
});
|
||||
@@ -1,315 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/sortedlist.c"
|
||||
|
||||
struct sortedlist_ftab_val *sl_ftab_val =
|
||||
&(struct sortedlist_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
CMC_CREATE_UNIT(sortedlist_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct sortedlist *sl = sl_new(1000000, sl_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
cmc_assert_not_equals(ptr, NULL, sl->buffer);
|
||||
cmc_assert_equals(size_t, 1000000, sl_capacity(sl));
|
||||
cmc_assert_equals(size_t, 0, sl_count(sl));
|
||||
cmc_assert_not_equals(ptr, NULL, sl->buffer);
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = 0], {
|
||||
struct sortedlist *sl = sl_new(0, sl_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = UINT64_MAX], {
|
||||
struct sortedlist *sl = sl_new(UINT64_MAX, sl_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count capacity], {
|
||||
struct sortedlist *sl = sl_new(100, sl_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
cmc_assert(sl_insert(sl, i));
|
||||
|
||||
cmc_assert_equals(size_t, 50, sl_count(sl));
|
||||
|
||||
sl_clear(sl);
|
||||
|
||||
cmc_assert_equals(size_t, 0, sl_count(sl));
|
||||
cmc_assert_equals(size_t, 100, sl_capacity(sl));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(buffer_growth[capacity = 1], {
|
||||
struct sortedlist *sl = sl_new(1, sl_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
cmc_assert(sl_insert(sl, i));
|
||||
|
||||
sl_sort(sl);
|
||||
|
||||
cmc_assert_equals(size_t, 50, sl_count(sl));
|
||||
cmc_assert_array_sorted_any(size_t, sl->buffer, cmp, 0, sl->count - 1);
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(insert, {
|
||||
struct sortedlist *sl = sl_new(100, sl_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
cmc_assert(sl_insert(sl, 1));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove, {
|
||||
struct sortedlist *sl = sl_new(100, sl_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
cmc_assert(sl_insert(sl, 32));
|
||||
|
||||
cmc_assert(sl_remove(sl, 0));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove[count = 0], {
|
||||
struct sortedlist *sl = sl_new(100, sl_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
cmc_assert(!sl_remove(sl, 0));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(remove[out of range], {
|
||||
struct sortedlist *sl = sl_new(100, sl_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
cmc_assert(sl_insert(sl, 32));
|
||||
|
||||
cmc_assert(!sl_remove(sl, 2));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(index_of, {
|
||||
struct sortedlist *sl = sl_new(1, sl_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
for (size_t i = 0; i < 20; i++)
|
||||
cmc_assert(sl_insert(sl, i % 10));
|
||||
|
||||
/* 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9 */
|
||||
cmc_assert_equals(size_t, 4, sl_index_of(sl, 2, true));
|
||||
cmc_assert_equals(size_t, 5, sl_index_of(sl, 2, false));
|
||||
|
||||
cmc_assert_equals(size_t, 0, sl_index_of(sl, 0, true));
|
||||
cmc_assert_equals(size_t, 1, sl_index_of(sl, 0, false));
|
||||
|
||||
cmc_assert(sl_remove(sl, 0));
|
||||
|
||||
cmc_assert_equals(size_t, 0, sl_index_of(sl, 0, true));
|
||||
cmc_assert_equals(size_t, 0, sl_index_of(sl, 0, false));
|
||||
|
||||
cmc_assert(sl_remove(sl, 0));
|
||||
|
||||
cmc_assert_equals(size_t, sl_count(sl), sl_index_of(sl, 0, true));
|
||||
cmc_assert_equals(size_t, sl_count(sl), sl_index_of(sl, 0, false));
|
||||
|
||||
sl_free(sl);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct sortedlist *sl = sl_new(100, sl_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl));
|
||||
|
||||
// clear
|
||||
sl->flag = cmc_flags.ERROR;
|
||||
sl_clear(sl);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl));
|
||||
|
||||
// customize
|
||||
sl->flag = cmc_flags.ERROR;
|
||||
sl_customize(sl, NULL, NULL);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl));
|
||||
|
||||
// insert
|
||||
sl->flag = cmc_flags.ERROR;
|
||||
cmc_assert(sl_insert(sl, 10));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl));
|
||||
|
||||
// remove
|
||||
cmc_assert(!sl_remove(sl, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.RANGE, sl_flag(sl));
|
||||
|
||||
cmc_assert(sl_remove(sl, 0));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl));
|
||||
|
||||
cmc_assert(!sl_remove(sl, 0));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, sl_flag(sl));
|
||||
|
||||
// max min
|
||||
sl->flag = cmc_flags.ERROR;
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, sl_max(sl));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, sl_flag(sl));
|
||||
sl->flag = cmc_flags.ERROR;
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, sl_min(sl));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, sl_flag(sl));
|
||||
|
||||
cmc_assert(sl_insert(sl, 1));
|
||||
sl->flag = cmc_flags.ERROR;
|
||||
cmc_assert_equals(size_t, 1, sl_max(sl));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl));
|
||||
sl->flag = cmc_flags.ERROR;
|
||||
cmc_assert_equals(size_t, 1, sl_min(sl));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl));
|
||||
|
||||
// get
|
||||
sl->flag = cmc_flags.ERROR;
|
||||
sl_get(sl, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.RANGE, sl_flag(sl));
|
||||
|
||||
sl_get(sl, 0);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl));
|
||||
|
||||
cmc_assert(sl_remove(sl, 0));
|
||||
sl_get(sl, 0);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, sl_flag(sl));
|
||||
|
||||
// index_of
|
||||
cmc_assert(sl_insert(sl, 1));
|
||||
sl_index_of(sl, 1, false);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl));
|
||||
|
||||
// contains
|
||||
cmc_assert(sl_contains(sl, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl));
|
||||
|
||||
// sort
|
||||
sl->flag = cmc_flags.ERROR;
|
||||
sl_sort(sl);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl));
|
||||
|
||||
// copy_of
|
||||
sl->flag = cmc_flags.ERROR;
|
||||
struct sortedlist *sl2 = sl_copy_of(sl);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl2));
|
||||
|
||||
// equals
|
||||
sl->flag = cmc_flags.ERROR;
|
||||
sl2->flag = cmc_flags.ERROR;
|
||||
cmc_assert(sl_equals(sl, sl2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl2));
|
||||
|
||||
sl_free(sl);
|
||||
sl_free(sl2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct sortedlist *sl =
|
||||
sl_new_custom(100, sl_ftab_val, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, sl);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(sl_insert(sl, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(sl_remove(sl, 0));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(sl_insert(sl, 1));
|
||||
cmc_assert(sl_insert(sl, 0));
|
||||
cmc_assert_equals(int32_t, 3, total_create);
|
||||
|
||||
cmc_assert_equals(size_t, 1, sl_max(sl));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 0, sl_min(sl));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 0, sl_get(sl, 0));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 0, sl_index_of(sl, 0, true));
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
|
||||
cmc_assert(sl_contains(sl, 1));
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
|
||||
cmc_assert(sl_resize(sl, 1000));
|
||||
cmc_assert_equals(int32_t, 1, total_resize);
|
||||
|
||||
cmc_assert(sl_resize(sl, 50));
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(int32_t, 3, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
sl_customize(sl, NULL, NULL);
|
||||
|
||||
sl_clear(sl);
|
||||
cmc_assert(sl_insert(sl, 10));
|
||||
cmc_assert(sl_remove(sl, 0));
|
||||
cmc_assert(sl_insert(sl, 1));
|
||||
cmc_assert(sl_insert(sl, 0));
|
||||
cmc_assert_equals(size_t, 1, sl_max(sl));
|
||||
cmc_assert_equals(size_t, 0, sl_min(sl));
|
||||
cmc_assert_equals(size_t, 0, sl_get(sl, 0));
|
||||
cmc_assert_equals(size_t, 0, sl_index_of(sl, 0, true));
|
||||
cmc_assert(sl_contains(sl, 1));
|
||||
|
||||
cmc_assert_equals(int32_t, 3, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, sl->callbacks);
|
||||
|
||||
sl_free(sl);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
});
|
||||
@@ -1,738 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/stack.c"
|
||||
|
||||
struct stack_ftab_val *s_ftab_val =
|
||||
&(struct stack_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
CMC_CREATE_UNIT(stack_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct stack *s = s_new(1000000, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
cmc_assert_not_equals(ptr, NULL, s->buffer);
|
||||
cmc_assert_equals(size_t, 1000000, s_capacity(s));
|
||||
cmc_assert_equals(size_t, 0, s_count(s));
|
||||
cmc_assert_not_equals(ptr, NULL, s->buffer);
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = 0], {
|
||||
struct stack *s = s_new(0, s_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(new[capacity = UINT64_MAX], {
|
||||
struct stack *s = s_new(UINT64_MAX, s_ftab_val);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count capacity], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
cmc_assert_equals(size_t, 50, s_count(s));
|
||||
|
||||
s_clear(s);
|
||||
|
||||
cmc_assert_equals(size_t, 0, s_count(s));
|
||||
cmc_assert_equals(size_t, 100, s_capacity(s));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(buffer_growth[capacity = 1], {
|
||||
struct stack *s = s_new(1, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
cmc_assert_equals(size_t, 50, s_count(s));
|
||||
cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push[count], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
cmc_assert_equals(size_t, 250, s_count(s));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push[capacity], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(push[item preservation], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
for (size_t i = 0; i < s_count(s); i++)
|
||||
cmc_assert_equals(size_t, i, s->buffer[i]);
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop[count], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
cmc_assert(s_pop(s));
|
||||
|
||||
cmc_assert_equals(size_t, 249, s_count(s));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop[capacity], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
cmc_assert(s_pop(s));
|
||||
|
||||
cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop[item preservation], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
cmc_assert(s_pop(s));
|
||||
cmc_assert(s_pop(s));
|
||||
|
||||
for (size_t i = 0; i < s_count(s); i++)
|
||||
cmc_assert_equals(size_t, i, s->buffer[i]);
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(pop[count = 0], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
cmc_assert_equals(bool, false, s_pop(s));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(top, {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 0; i < 250; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
cmc_assert(s_pop(s));
|
||||
cmc_assert(s_pop(s));
|
||||
|
||||
cmc_assert_equals(size_t, 247, s_top(s));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(top[count = 0], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
cmc_assert(s_push(s, 1));
|
||||
|
||||
cmc_assert(s_pop(s));
|
||||
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, s_top(s));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(top[count = 1], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
cmc_assert(s_push(s, 10));
|
||||
cmc_assert_equals(size_t, 1, s_count(s));
|
||||
cmc_assert_equals(size_t, 10, s_top(s));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(contains, {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 0; i < 150; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
for (size_t i = 0; i < 150; i++)
|
||||
cmc_assert(s_contains(s, i));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(contains[count = 0], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
cmc_assert_equals(bool, false, s_contains(s, 10));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(empty, {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
cmc_assert(s_empty(s));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(empty[after_io], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
cmc_assert(s_push(s, 10));
|
||||
cmc_assert(s_pop(s));
|
||||
cmc_assert(s_empty(s));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(full, {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 0; i < s_capacity(s); i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
cmc_assert(s_full(s));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(full[capacity = 1], {
|
||||
struct stack *s = s_new(1, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
cmc_assert(s_push(s, 10));
|
||||
|
||||
cmc_assert(s_full(s));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(iter_alloc, {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
struct stack_iter *iter = s_iter_new(s);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, iter);
|
||||
|
||||
s_iter_free(iter);
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(iter_init[count = 0], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
struct stack_iter iter;
|
||||
|
||||
s_iter_init(&iter, s);
|
||||
|
||||
cmc_assert_equals(ptr, iter.target, s);
|
||||
cmc_assert_equals(size_t, iter.cursor, 0);
|
||||
cmc_assert(iter.start);
|
||||
cmc_assert(iter.end);
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(iter_start[count = 0], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
struct stack_iter iter;
|
||||
|
||||
s_iter_init(&iter, s);
|
||||
|
||||
cmc_assert(s_iter_start(&iter));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(iter_end[count = 0], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
struct stack_iter iter;
|
||||
|
||||
s_iter_init(&iter, s);
|
||||
|
||||
cmc_assert(s_iter_end(&iter));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(iteration, {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 1; i <= 200; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
size_t total = 0;
|
||||
|
||||
for (struct stack_iter it = s->it_start(s); !s_iter_end(&it);
|
||||
s_iter_next(&it))
|
||||
{
|
||||
total += s_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 20100, total);
|
||||
|
||||
for (struct stack_iter it = s->it_end(s); !s_iter_start(&it);
|
||||
s_iter_prev(&it))
|
||||
{
|
||||
total += s_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 40200, total);
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(iteration[while loop], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 1; i <= 200; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
size_t total = 0;
|
||||
struct stack_iter it = s->it_start(s);
|
||||
|
||||
do
|
||||
{
|
||||
total += s_iter_value(&it);
|
||||
} while (s_iter_next(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 20100, total);
|
||||
|
||||
it = s->it_end(s);
|
||||
|
||||
do
|
||||
{
|
||||
total += s_iter_value(&it);
|
||||
} while (s_iter_prev(&it));
|
||||
|
||||
cmc_assert_equals(size_t, 40200, total);
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(iteration[count = 1], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
cmc_assert(s_push(s, 10));
|
||||
|
||||
size_t total = 0;
|
||||
|
||||
for (struct stack_iter it = s->it_start(s); !s_iter_end(&it);
|
||||
s_iter_next(&it))
|
||||
{
|
||||
total += s_iter_value(&it);
|
||||
}
|
||||
|
||||
for (struct stack_iter it = s->it_end(s); !s_iter_start(&it);
|
||||
s_iter_prev(&it))
|
||||
{
|
||||
total += s_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 20, total);
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(iteration[count = capacity], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
while (!s_full(s))
|
||||
cmc_assert(s_push(s, 10));
|
||||
|
||||
cmc_assert_equals(size_t, s_capacity(s), s_count(s));
|
||||
|
||||
size_t total = 0;
|
||||
|
||||
for (struct stack_iter it = s->it_start(s); !s_iter_end(&it);
|
||||
s_iter_next(&it))
|
||||
{
|
||||
total += s_iter_value(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 1000, total);
|
||||
|
||||
for (struct stack_iter it = s->it_end(s); !s_iter_start(&it);
|
||||
s_iter_prev(&it))
|
||||
{
|
||||
total += *s_iter_rvalue(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 2000, total);
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(iteration[to_start = it_start and to_end = it_end], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
struct stack_iter it1;
|
||||
struct stack_iter it2;
|
||||
|
||||
memset(&it1, 0, sizeof(struct stack_iter));
|
||||
memset(&it2, 0, sizeof(struct stack_iter));
|
||||
|
||||
s_iter_init(&it2, s);
|
||||
|
||||
it1 = s->it_start(s);
|
||||
s_iter_to_start(&it2);
|
||||
|
||||
cmc_assert_equals(ptr, it1.target, it2.target);
|
||||
cmc_assert_equals(size_t, it1.cursor, it2.cursor);
|
||||
cmc_assert_equals(bool, it1.start, it2.start);
|
||||
cmc_assert_equals(bool, it1.end, it2.end);
|
||||
|
||||
it1 = s->it_end(s);
|
||||
s_iter_to_end(&it2);
|
||||
|
||||
cmc_assert_equals(ptr, it1.target, it2.target);
|
||||
cmc_assert_equals(size_t, it1.cursor, it2.cursor);
|
||||
cmc_assert_equals(bool, it1.start, it2.start);
|
||||
cmc_assert_equals(bool, it1.end, it2.end);
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(iteration[boundaries count = 0], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
struct stack_iter iter;
|
||||
s_iter_init(&iter, s);
|
||||
|
||||
s_iter_to_end(&iter);
|
||||
|
||||
cmc_assert_equals(bool, false, s_iter_next(&iter));
|
||||
|
||||
s_iter_to_start(&iter);
|
||||
|
||||
cmc_assert_equals(bool, false, s_iter_prev(&iter));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(iteration[boundaries count > 0], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 0; i < 200; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
struct stack_iter iter;
|
||||
s_iter_init(&iter, s);
|
||||
|
||||
s_iter_to_end(&iter);
|
||||
|
||||
cmc_assert_equals(bool, false, s_iter_next(&iter));
|
||||
|
||||
s_iter_to_start(&iter);
|
||||
|
||||
cmc_assert_equals(bool, false, s_iter_prev(&iter));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(iter_value[count = 0], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
struct stack_iter iter;
|
||||
|
||||
s_iter_init(&iter, s);
|
||||
|
||||
cmc_assert_equals(size_t, (size_t){ 0 }, s_iter_value(&iter));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(iter_rvalue[count = 0], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
struct stack_iter iter;
|
||||
|
||||
s_iter_init(&iter, s);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, s_iter_rvalue(&iter));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(index, {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
for (size_t i = 0; i < 10; i++)
|
||||
cmc_assert(s_push(s, i));
|
||||
|
||||
cmc_assert_equals(size_t, 10, s_count(s));
|
||||
|
||||
size_t total = 0;
|
||||
|
||||
for (struct stack_iter it = s->it_start(s); false;)
|
||||
{
|
||||
cmc_assert_equals(size_t, 0, s_iter_index(&it));
|
||||
}
|
||||
|
||||
for (struct stack_iter it = s->it_start(s); false;)
|
||||
{
|
||||
cmc_assert_equals(size_t, s_count(s) - 1, s_iter_index(&it));
|
||||
}
|
||||
|
||||
for (struct stack_iter it = s->it_start(s); !s_iter_end(&it);
|
||||
s_iter_next(&it))
|
||||
{
|
||||
total += s_iter_index(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 45, total);
|
||||
|
||||
for (struct stack_iter it = s->it_end(s); !s_iter_start(&it);
|
||||
s_iter_prev(&it))
|
||||
{
|
||||
total += s_iter_index(&it);
|
||||
}
|
||||
|
||||
cmc_assert_equals(size_t, 90, total);
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(index[count = 0], {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
struct stack_iter iter;
|
||||
s_iter_init(&iter, s);
|
||||
|
||||
cmc_assert_equals(size_t, 0, s_iter_index(&iter));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct stack *s = s_new(100, s_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s));
|
||||
|
||||
// clear
|
||||
s->flag = cmc_flags.ERROR;
|
||||
s_clear(s);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s));
|
||||
|
||||
// customize
|
||||
s->flag = cmc_flags.ERROR;
|
||||
s_customize(s, NULL, NULL);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s));
|
||||
|
||||
// push
|
||||
s->flag = cmc_flags.ERROR;
|
||||
cmc_assert(s_push(s, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s));
|
||||
|
||||
// pop
|
||||
s->flag = cmc_flags.ERROR;
|
||||
cmc_assert(s_pop(s));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s));
|
||||
|
||||
cmc_assert(!s_pop(s));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, s_flag(s));
|
||||
|
||||
// top
|
||||
s->flag = cmc_flags.ERROR;
|
||||
s_top(s);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, s_flag(s));
|
||||
|
||||
cmc_assert(s_push(s, 1));
|
||||
s_top(s);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s));
|
||||
|
||||
// contains
|
||||
s->flag = cmc_flags.ERROR;
|
||||
cmc_assert(s_contains(s, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s));
|
||||
|
||||
// copy_of
|
||||
s->flag = cmc_flags.ERROR;
|
||||
struct stack *s2 = s_copy_of(s);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s2));
|
||||
|
||||
// equals
|
||||
s->flag = cmc_flags.ERROR;
|
||||
s2->flag = cmc_flags.ERROR;
|
||||
cmc_assert(s_equals(s, s2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, s_flag(s2));
|
||||
|
||||
s_free(s);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct stack *s = s_new_custom(100, s_ftab_val, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, s);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(s_push(s, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(s_pop(s));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(s_push(s, 1));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert_equals(size_t, 1, s_top(s));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert(s_contains(s, 1));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert(s_resize(s, 1000));
|
||||
cmc_assert_equals(int32_t, 1, total_resize);
|
||||
|
||||
cmc_assert(s_resize(s, 10));
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
s_customize(s, NULL, NULL);
|
||||
|
||||
s_clear(s);
|
||||
cmc_assert(s_push(s, 10));
|
||||
cmc_assert(s_pop(s));
|
||||
cmc_assert(s_push(s, 1));
|
||||
cmc_assert_equals(size_t, 1, s_top(s));
|
||||
cmc_assert(s_contains(s, 1));
|
||||
cmc_assert(s_resize(s, 1000));
|
||||
cmc_assert(s_resize(s, 10));
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 2, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, s->callbacks);
|
||||
|
||||
s_free(s);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
});
|
||||
});
|
||||
@@ -1,215 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/treemap.c"
|
||||
|
||||
struct treemap_ftab_key *tm_ftab_key =
|
||||
&(struct treemap_ftab_key){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
struct treemap_ftab_val *tm_ftab_val =
|
||||
&(struct treemap_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
CMC_CREATE_UNIT(treemap_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct treemap *map = tm_new(tm_ftab_key, tm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count], {
|
||||
struct treemap *map = tm_new(tm_ftab_key, tm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
tm_insert(map, i, i);
|
||||
|
||||
cmc_assert_equals(size_t, 50, tm_count(map));
|
||||
|
||||
tm_clear(map);
|
||||
|
||||
cmc_assert_equals(size_t, 0, tm_count(map));
|
||||
cmc_assert_equals(ptr, NULL, map->root);
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct treemap *map = tm_new(tm_ftab_key, tm_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map));
|
||||
|
||||
// clear
|
||||
map->flag = cmc_flags.ERROR;
|
||||
tm_clear(map);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map));
|
||||
|
||||
// insert
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(tm_insert(map, 1, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map));
|
||||
|
||||
// update
|
||||
cmc_assert(!tm_update(map, 2, 2, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, tm_flag(map));
|
||||
|
||||
cmc_assert(tm_update(map, 1, 2, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map));
|
||||
|
||||
// remove
|
||||
cmc_assert(!tm_remove(map, 2, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, tm_flag(map));
|
||||
|
||||
cmc_assert(tm_remove(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map));
|
||||
|
||||
cmc_assert(!tm_remove(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, tm_flag(map));
|
||||
|
||||
// max min
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!tm_max(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, tm_flag(map));
|
||||
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!tm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, tm_flag(map));
|
||||
|
||||
cmc_assert(tm_insert(map, 1, 1));
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(tm_max(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map));
|
||||
|
||||
map->flag = cmc_flags.ERROR;
|
||||
cmc_assert(tm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map));
|
||||
|
||||
// get get_ref
|
||||
tm_get(map, 2);
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, tm_flag(map));
|
||||
|
||||
tm_get(map, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map));
|
||||
|
||||
tm_get_ref(map, 2);
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, tm_flag(map));
|
||||
|
||||
tm_get_ref(map, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map));
|
||||
|
||||
cmc_assert(tm_remove(map, 1, NULL));
|
||||
map->flag = cmc_flags.ERROR;
|
||||
tm_get(map, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, tm_flag(map));
|
||||
|
||||
map->flag = cmc_flags.ERROR;
|
||||
tm_get_ref(map, 1);
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, tm_flag(map));
|
||||
|
||||
// copy_of
|
||||
map->flag = cmc_flags.ERROR;
|
||||
struct treemap *map2 = tm_copy_of(map);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map2));
|
||||
|
||||
// equals
|
||||
map->flag = cmc_flags.ERROR;
|
||||
map2->flag = cmc_flags.ERROR;
|
||||
cmc_assert(tm_equals(map, map2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, tm_flag(map2));
|
||||
|
||||
tm_free(map);
|
||||
tm_free(map2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct treemap *map =
|
||||
tm_new_custom(tm_ftab_key, tm_ftab_val, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, map);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(tm_insert(map, 1, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(tm_update(map, 1, 2, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_update);
|
||||
|
||||
cmc_assert(tm_remove(map, 1, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(tm_insert(map, 1, 2));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert(tm_max(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert(tm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert_equals(size_t, 2, tm_get(map, 1));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, tm_get_ref(map, 1));
|
||||
cmc_assert_equals(int32_t, 4, total_read);
|
||||
|
||||
cmc_assert(tm_contains(map, 1));
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 1, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 0, total_resize);
|
||||
|
||||
tm_customize(map, NULL, NULL);
|
||||
|
||||
tm_clear(map);
|
||||
cmc_assert(tm_insert(map, 1, 10));
|
||||
cmc_assert(tm_update(map, 1, 2, NULL));
|
||||
cmc_assert(tm_remove(map, 1, NULL));
|
||||
cmc_assert(tm_insert(map, 1, 2));
|
||||
cmc_assert(tm_max(map, NULL, NULL));
|
||||
cmc_assert(tm_min(map, NULL, NULL));
|
||||
cmc_assert_equals(size_t, 2, tm_get(map, 1));
|
||||
cmc_assert_not_equals(ptr, NULL, tm_get_ref(map, 1));
|
||||
cmc_assert(tm_contains(map, 1));
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 5, total_read);
|
||||
cmc_assert_equals(int32_t, 1, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 0, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, map->callbacks);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
tm_free(map);
|
||||
});
|
||||
});
|
||||
@@ -1,165 +0,0 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
|
||||
#include "../src/treeset.c"
|
||||
|
||||
struct treeset_ftab_val *ts_ftab_val =
|
||||
&(struct treeset_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
.str = str,
|
||||
.free = custom_free,
|
||||
.hash = hash,
|
||||
.pri = pri };
|
||||
|
||||
CMC_CREATE_UNIT(treeset_test, true, {
|
||||
CMC_CREATE_TEST(new, {
|
||||
struct treeset *set = ts_new(ts_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(clear[count], {
|
||||
struct treeset *set = ts_new(ts_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
for (size_t i = 0; i < 50; i++)
|
||||
ts_insert(set, i);
|
||||
|
||||
cmc_assert_equals(size_t, 50, ts_count(set));
|
||||
|
||||
ts_clear(set);
|
||||
|
||||
cmc_assert_equals(size_t, 0, ts_count(set));
|
||||
cmc_assert_equals(ptr, NULL, set->root);
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(flags, {
|
||||
struct treeset *set = ts_new(ts_ftab_val);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set));
|
||||
|
||||
// clear
|
||||
set->flag = cmc_flags.ERROR;
|
||||
ts_clear(set);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set));
|
||||
|
||||
// insert
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ts_insert(set, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set));
|
||||
|
||||
// remove
|
||||
cmc_assert(!ts_remove(set, 2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.NOT_FOUND, ts_flag(set));
|
||||
|
||||
cmc_assert(ts_remove(set, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set));
|
||||
|
||||
cmc_assert(!ts_remove(set, 1));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ts_flag(set));
|
||||
|
||||
// max min
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!ts_max(set, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ts_flag(set));
|
||||
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(!ts_min(set, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.EMPTY, ts_flag(set));
|
||||
|
||||
cmc_assert(ts_insert(set, 1));
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ts_max(set, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set));
|
||||
|
||||
set->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ts_min(set, NULL));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set));
|
||||
|
||||
// copy_of
|
||||
set->flag = cmc_flags.ERROR;
|
||||
struct treeset *set2 = ts_copy_of(set);
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set2));
|
||||
|
||||
// equals
|
||||
set->flag = cmc_flags.ERROR;
|
||||
set2->flag = cmc_flags.ERROR;
|
||||
cmc_assert(ts_equals(set, set2));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set));
|
||||
cmc_assert_equals(int32_t, cmc_flags.OK, ts_flag(set2));
|
||||
|
||||
ts_free(set);
|
||||
ts_free(set2);
|
||||
});
|
||||
|
||||
CMC_CREATE_TEST(callbacks, {
|
||||
struct treeset *set = ts_new_custom(ts_ftab_val, NULL, callbacks);
|
||||
|
||||
cmc_assert_not_equals(ptr, NULL, set);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
cmc_assert(ts_insert(set, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_create);
|
||||
|
||||
cmc_assert(ts_remove(set, 10));
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
|
||||
cmc_assert(ts_insert(set, 1));
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
|
||||
cmc_assert(ts_max(set, NULL));
|
||||
cmc_assert_equals(int32_t, 1, total_read);
|
||||
|
||||
cmc_assert(ts_min(set, NULL));
|
||||
cmc_assert_equals(int32_t, 2, total_read);
|
||||
|
||||
cmc_assert(ts_contains(set, 1));
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 0, total_resize);
|
||||
|
||||
ts_customize(set, NULL, NULL);
|
||||
|
||||
ts_clear(set);
|
||||
cmc_assert(ts_insert(set, 10));
|
||||
cmc_assert(ts_remove(set, 10));
|
||||
cmc_assert(ts_insert(set, 1));
|
||||
cmc_assert(ts_max(set, NULL));
|
||||
cmc_assert(ts_min(set, NULL));
|
||||
cmc_assert(ts_contains(set, 1));
|
||||
|
||||
cmc_assert_equals(int32_t, 2, total_create);
|
||||
cmc_assert_equals(int32_t, 3, total_read);
|
||||
cmc_assert_equals(int32_t, 0, total_update);
|
||||
cmc_assert_equals(int32_t, 1, total_delete);
|
||||
cmc_assert_equals(int32_t, 0, total_resize);
|
||||
|
||||
cmc_assert_equals(ptr, NULL, set->callbacks);
|
||||
|
||||
total_create = 0;
|
||||
total_read = 0;
|
||||
total_update = 0;
|
||||
total_delete = 0;
|
||||
total_resize = 0;
|
||||
|
||||
ts_free(set);
|
||||
});
|
||||
});
|
||||
@@ -1,200 +0,0 @@
|
||||
/* Utility file to be included in the unit tests */
|
||||
#ifndef CMC_UNIT_TEST_UTL__
|
||||
#define CMC_UNIT_TEST_UTL__
|
||||
|
||||
#include <cmc/hashmap.h>
|
||||
#include <inttypes.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int cmp(size_t a, size_t b)
|
||||
{
|
||||
return (a > b) - (a < b);
|
||||
}
|
||||
|
||||
size_t copy(size_t a)
|
||||
{
|
||||
return a;
|
||||
}
|
||||
|
||||
bool str(FILE *fptr, size_t a)
|
||||
{
|
||||
return fprintf(fptr, "%" PRIuMAX " ", a) > 0;
|
||||
}
|
||||
|
||||
void custom_free(size_t a)
|
||||
{
|
||||
// blank
|
||||
// Free any resources if necessary
|
||||
}
|
||||
|
||||
size_t hash(size_t a)
|
||||
{
|
||||
a += ~(a << 15);
|
||||
a ^= (a >> 10);
|
||||
a += (a << 3);
|
||||
a ^= (a >> 6);
|
||||
a += ~(a << 11);
|
||||
a ^= (a >> 16);
|
||||
return a;
|
||||
}
|
||||
|
||||
int pri(size_t a, size_t b)
|
||||
{
|
||||
// Could contain different logic
|
||||
return cmp(a, b);
|
||||
}
|
||||
|
||||
size_t numhash(size_t a)
|
||||
{
|
||||
return a;
|
||||
}
|
||||
|
||||
size_t hashcapminus1(size_t a)
|
||||
{
|
||||
return cmc_hashtable_primes[0] - 1;
|
||||
}
|
||||
|
||||
size_t hashcapminus4(size_t a)
|
||||
{
|
||||
return cmc_hashtable_primes[0] - 1;
|
||||
}
|
||||
|
||||
size_t hash0(size_t a)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// counter ftab functions
|
||||
|
||||
int32_t k_total_cmp = 0;
|
||||
int32_t k_total_cpy = 0;
|
||||
int32_t k_total_str = 0;
|
||||
int32_t k_total_free = 0;
|
||||
int32_t k_total_hash = 0;
|
||||
int32_t k_total_pri = 0;
|
||||
|
||||
int32_t v_total_cmp = 0;
|
||||
int32_t v_total_cpy = 0;
|
||||
int32_t v_total_str = 0;
|
||||
int32_t v_total_free = 0;
|
||||
int32_t v_total_hash = 0;
|
||||
int32_t v_total_pri = 0;
|
||||
|
||||
int k_c_cmp(size_t a, size_t b)
|
||||
{
|
||||
k_total_cmp++;
|
||||
return (a > b) - (a < b);
|
||||
}
|
||||
|
||||
size_t k_c_cpy(size_t a)
|
||||
{
|
||||
k_total_cpy++;
|
||||
return a;
|
||||
}
|
||||
|
||||
bool k_c_str(FILE *fptr, size_t a)
|
||||
{
|
||||
k_total_str++;
|
||||
return fprintf(fptr, "%" PRIuMAX " ", a) > 0;
|
||||
}
|
||||
|
||||
void k_c_free(size_t a)
|
||||
{
|
||||
k_total_free++;
|
||||
}
|
||||
|
||||
size_t k_c_hash(size_t x)
|
||||
{
|
||||
k_total_hash++;
|
||||
x = ((x >> 16) ^ x) * 0x45d9f3b;
|
||||
x = ((x >> 16) ^ x) * 0x45d9f3b;
|
||||
x = (x >> 16) ^ x;
|
||||
return x;
|
||||
}
|
||||
|
||||
int k_c_pri(size_t a, size_t b)
|
||||
{
|
||||
k_total_pri++;
|
||||
return cmp(a, b);
|
||||
}
|
||||
|
||||
int v_c_cmp(size_t a, size_t b)
|
||||
{
|
||||
v_total_cmp++;
|
||||
return (a > b) - (a < b);
|
||||
}
|
||||
|
||||
size_t v_c_cpy(size_t a)
|
||||
{
|
||||
v_total_cpy++;
|
||||
return a;
|
||||
}
|
||||
|
||||
bool v_c_str(FILE *fptr, size_t a)
|
||||
{
|
||||
v_total_str++;
|
||||
return fprintf(fptr, "%" PRIuMAX " ", a) > 0;
|
||||
}
|
||||
|
||||
void v_c_free(size_t a)
|
||||
{
|
||||
v_total_free++;
|
||||
}
|
||||
|
||||
size_t v_c_hash(size_t x)
|
||||
{
|
||||
v_total_hash++;
|
||||
x = ((x >> 16) ^ x) * 0x45d9f3b;
|
||||
x = ((x >> 16) ^ x) * 0x45d9f3b;
|
||||
x = (x >> 16) ^ x;
|
||||
return x;
|
||||
}
|
||||
|
||||
int v_c_pri(size_t a, size_t b)
|
||||
{
|
||||
v_total_pri++;
|
||||
return cmp(a, b);
|
||||
}
|
||||
|
||||
// callbacks
|
||||
|
||||
int total_create = 0;
|
||||
int total_read = 0;
|
||||
int total_update = 0;
|
||||
int total_delete = 0;
|
||||
int total_resize = 0;
|
||||
|
||||
void callback_create(void)
|
||||
{
|
||||
total_create++;
|
||||
}
|
||||
|
||||
void callback_read(void)
|
||||
{
|
||||
total_read++;
|
||||
}
|
||||
|
||||
void callback_update(void)
|
||||
{
|
||||
total_update++;
|
||||
}
|
||||
|
||||
void callback_delete(void)
|
||||
{
|
||||
total_delete++;
|
||||
}
|
||||
|
||||
void callback_resize(void)
|
||||
{
|
||||
total_resize++;
|
||||
}
|
||||
|
||||
struct cmc_callbacks *callbacks =
|
||||
&(struct cmc_callbacks){ .create = callback_create,
|
||||
.read = callback_read,
|
||||
.update = callback_update,
|
||||
.delete = callback_delete,
|
||||
.resize = callback_resize };
|
||||
|
||||
#endif /* CMC_UNIT_TEST_UTL__ */
|
||||
+16
-8
@@ -1,21 +1,29 @@
|
||||
CC = gcc
|
||||
CFLAGS = -std=c11 -Wall -Wextra
|
||||
CFLAGS += -Wno-unused -Wno-missing-braces
|
||||
CFLAGS += -DCMC_TEST_COLOR
|
||||
CFLAGS += -Wno-unused -Wno-missing-braces -DCMC_TEST_COLOR
|
||||
CVFLAGS = --coverage -O0
|
||||
INCLUDE = ../../src/
|
||||
|
||||
main: FORCE
|
||||
$(CC) main.c -o main $(CFLAGS) -I $(INCLUDE)
|
||||
$(CC) main.c -o main.exe $(CFLAGS) $(CVFLAGS) -I $(INCLUDE)
|
||||
./main
|
||||
gcov ./main.c
|
||||
|
||||
dev: FORCE
|
||||
$(CC) main.c -o main.exe $(CFLAGS) -I $(INCLUDE)
|
||||
./main.exe
|
||||
rm *.exe
|
||||
$(CC) main.c -o main.exe $(CFLAGS) $(CVFLAGS) -I $(INCLUDE)
|
||||
./main
|
||||
gcov ./main.c -n
|
||||
rm *.gcda *.gcno *.exe
|
||||
|
||||
windev: FORCE
|
||||
$(CC) main.c -o main $(CFLAGS) -I $(INCLUDE)
|
||||
$(CC) main.c -o main.exe $(CFLAGS) $(CVFLAGS) -I $(INCLUDE)
|
||||
./main
|
||||
del *.exe
|
||||
gcov ./main.c -n
|
||||
del *.gcda *.gcno *.exe
|
||||
|
||||
nocov: FORCE
|
||||
$(CC) main.c -o main.exe $(CFLAGS) -I $(INCLUDE)
|
||||
./main
|
||||
rm *.exe
|
||||
|
||||
FORCE:
|
||||
@@ -1,5 +1,3 @@
|
||||
# main
|
||||
|
||||
This folder hosts the main tests for the C Macro Collections Library. While this library is under development with breaking changes the old unit tests were moved to codecov to keep track of code coverage without breaking the test.
|
||||
|
||||
This new folder however will contain up-to-date changes and tests in order to have any modifications done to the library tracked and where they were broken.
|
||||
This folder hosts the main tests for the C Macro Collections Library.
|
||||
+4
-3
@@ -1,4 +1,4 @@
|
||||
#include <utl/timer.h>
|
||||
#include "utl/timer.h"
|
||||
|
||||
#include "unt/bidimap.c"
|
||||
#include "unt/deque.c"
|
||||
@@ -42,8 +42,9 @@ int main(void)
|
||||
cmc_timer_stop(timer);
|
||||
|
||||
printf("+--------------------------------------------------+\n");
|
||||
printf("| Total running time : %14.0lf milliseconds |\n", timer.result);
|
||||
printf("| Total Tests Failed : %14" PRIuMAX " tests |\n", failed);
|
||||
printf("| Total Running Time : %14.0lf milliseconds |\n", timer.result);
|
||||
printf("+--------------------------------------------------+\n");
|
||||
|
||||
return failed;
|
||||
return 0;
|
||||
}
|
||||
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/bidimap.h>
|
||||
|
||||
CMC_GENERATE_BIDIMAP(bm, bidimap, size_t, size_t)
|
||||
#include "../src/bidimap.c"
|
||||
|
||||
struct bidimap_ftab_key *bm_ftab_key =
|
||||
&(struct bidimap_ftab_key){ .cmp = cmp,
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/deque.h>
|
||||
|
||||
CMC_GENERATE_DEQUE(d, deque, size_t)
|
||||
#include "../src/deque.c"
|
||||
|
||||
struct deque_ftab_val *d_ftab_val =
|
||||
&(struct deque_ftab_val){ .cmp = cmp,
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/hashmap.h>
|
||||
|
||||
CMC_GENERATE_HASHMAP(hm, hashmap, size_t, size_t)
|
||||
#include "../src/hashmap.c"
|
||||
|
||||
struct hashmap_ftab_key *hm_ftab_key =
|
||||
&(struct hashmap_ftab_key){ .cmp = cmp,
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/hashset.h>
|
||||
|
||||
CMC_GENERATE_HASHSET(hs, hashset, size_t)
|
||||
#include "../src/hashset.c"
|
||||
|
||||
struct hashset_ftab_val *hs_ftab_val =
|
||||
&(struct hashset_ftab_val){ .cmp = cmp,
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/heap.h>
|
||||
|
||||
CMC_GENERATE_HEAP(h, heap, size_t)
|
||||
#include "../src/heap.c"
|
||||
|
||||
struct heap_ftab_val *h_ftab_val = &(struct heap_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/intervalheap.h>
|
||||
|
||||
CMC_GENERATE_INTERVALHEAP(ih, intervalheap, size_t)
|
||||
#include "../src/intervalheap.c"
|
||||
|
||||
struct intervalheap_ftab_val *ih_ftab_val =
|
||||
&(struct intervalheap_ftab_val){ .cmp = cmp,
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/linkedlist.h>
|
||||
|
||||
CMC_GENERATE_LINKEDLIST(ll, linkedlist, size_t)
|
||||
#include "../src/linkedlist.c"
|
||||
|
||||
struct linkedlist_ftab_val *ll_ftab_val =
|
||||
&(struct linkedlist_ftab_val){ .cmp = cmp,
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/list.h>
|
||||
|
||||
CMC_GENERATE_LIST(l, list, size_t)
|
||||
#include "../src/list.c"
|
||||
|
||||
struct list_ftab_val *l_ftab_val = &(struct list_ftab_val){ .cmp = cmp,
|
||||
.cpy = copy,
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/multimap.h>
|
||||
|
||||
CMC_GENERATE_MULTIMAP(mm, multimap, size_t, size_t)
|
||||
#include "../src/multimap.c"
|
||||
|
||||
struct multimap_ftab_key *mm_ftab_key =
|
||||
&(struct multimap_ftab_key){ .cmp = cmp,
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/multiset.h>
|
||||
|
||||
CMC_GENERATE_MULTISET(ms, multiset, size_t)
|
||||
#include "../src/multiset.c"
|
||||
|
||||
struct multiset_ftab_val *ms_ftab_val =
|
||||
&(struct multiset_ftab_val){ .cmp = cmp,
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/queue.h>
|
||||
|
||||
CMC_GENERATE_QUEUE(q, queue, size_t)
|
||||
#include "../src/queue.c"
|
||||
|
||||
struct queue_ftab_val *q_ftab_val =
|
||||
&(struct queue_ftab_val){ .cmp = cmp,
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/sortedlist.h>
|
||||
|
||||
CMC_GENERATE_SORTEDLIST(sl, sortedlist, size_t)
|
||||
#include "../src/sortedlist.c"
|
||||
|
||||
struct sortedlist_ftab_val *sl_ftab_val =
|
||||
&(struct sortedlist_ftab_val){ .cmp = cmp,
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/stack.h>
|
||||
|
||||
CMC_GENERATE_STACK(s, stack, size_t)
|
||||
#include "../src/stack.c"
|
||||
|
||||
struct stack_ftab_val *s_ftab_val =
|
||||
&(struct stack_ftab_val){ .cmp = cmp,
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/treemap.h>
|
||||
|
||||
CMC_GENERATE_TREEMAP(tm, treemap, size_t, size_t)
|
||||
#include "../src/treemap.c"
|
||||
|
||||
struct treemap_ftab_key *tm_ftab_key =
|
||||
&(struct treemap_ftab_key){ .cmp = cmp,
|
||||
|
||||
@@ -1,11 +1,9 @@
|
||||
#include "utl.c"
|
||||
#include <utl/assert.h>
|
||||
#include <utl/log.h>
|
||||
#include <utl/test.h>
|
||||
#include "utl/assert.h"
|
||||
#include "utl/log.h"
|
||||
#include "utl/test.h"
|
||||
|
||||
#include <cmc/treeset.h>
|
||||
|
||||
CMC_GENERATE_TREESET(ts, treeset, size_t)
|
||||
#include "../src/treeset.c"
|
||||
|
||||
struct treeset_ftab_val *ts_ftab_val =
|
||||
&(struct treeset_ftab_val){ .cmp = cmp,
|
||||
|
||||
Reference in new issue
Block a user