diff --git a/autogen.py b/autogen.py index 9bea336..ee5b26f 100644 --- a/autogen.py +++ b/autogen.py @@ -2,7 +2,6 @@ import os import re -import time import subprocess # Compiler settings @@ -22,7 +21,7 @@ UNIQUE_FLAG = '// C_MACRO_COLLECTIONS_CODE' TMP_FILE = 'main.c' # Output directory -OUTPUT_DIR = './tests/codecov/src' +OUTPUT_DIR = './tests/main/src' collections = [ # type, header, pfx, sname, key, val diff --git a/src/utl/assert.h b/src/utl/assert.h index 7896364..266a69f 100644 --- a/src/utl/assert.h +++ b/src/utl/assert.h @@ -96,7 +96,7 @@ static bool cmc_assert_state = true; /** * dtype : One of the data types listed at the beggining of this file. * expected : Expected value for the assertion to pass. - * actual : Actual value tested against 'expected'. + * actual : Actual value tested against 'not_expected'. */ #define cmc_assert_not_equals(dtype, not_expected, actual) \ CMC_ASSERT_GLUE(dtype, not_equals) \ diff --git a/tests/codecov/Makefile b/tests/codecov/Makefile deleted file mode 100644 index bb54420..0000000 --- a/tests/codecov/Makefile +++ /dev/null @@ -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: diff --git a/tests/codecov/README.md b/tests/codecov/README.md deleted file mode 100644 index 270818a..0000000 --- a/tests/codecov/README.md +++ /dev/null @@ -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(). diff --git a/tests/codecov/main.c b/tests/codecov/main.c deleted file mode 100644 index 1bcf491..0000000 --- a/tests/codecov/main.c +++ /dev/null @@ -1,49 +0,0 @@ -#include - -#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; -} diff --git a/tests/codecov/unt/bidimap.c b/tests/codecov/unt/bidimap.c deleted file mode 100644 index eb8a7bf..0000000 --- a/tests/codecov/unt/bidimap.c +++ /dev/null @@ -1,827 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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; - }); -}); diff --git a/tests/codecov/unt/deque.c b/tests/codecov/unt/deque.c deleted file mode 100644 index dc7255b..0000000 --- a/tests/codecov/unt/deque.c +++ /dev/null @@ -1,819 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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; - }); -}); diff --git a/tests/codecov/unt/hashmap.c b/tests/codecov/unt/hashmap.c deleted file mode 100644 index 8ea3553..0000000 --- a/tests/codecov/unt/hashmap.c +++ /dev/null @@ -1,682 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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; - }); -}); diff --git a/tests/codecov/unt/hashset.c b/tests/codecov/unt/hashset.c deleted file mode 100644 index e0096f9..0000000 --- a/tests/codecov/unt/hashset.c +++ /dev/null @@ -1,555 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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; - }); -}); diff --git a/tests/codecov/unt/heap.c b/tests/codecov/unt/heap.c deleted file mode 100644 index 72a75ef..0000000 --- a/tests/codecov/unt/heap.c +++ /dev/null @@ -1,293 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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; - }); -}); diff --git a/tests/codecov/unt/intervalheap.c b/tests/codecov/unt/intervalheap.c deleted file mode 100644 index 71b780c..0000000 --- a/tests/codecov/unt/intervalheap.c +++ /dev/null @@ -1,352 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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; - }); -}); diff --git a/tests/codecov/unt/linkedlist.c b/tests/codecov/unt/linkedlist.c deleted file mode 100644 index 5f31aac..0000000 --- a/tests/codecov/unt/linkedlist.c +++ /dev/null @@ -1,345 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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; - }); -}); diff --git a/tests/codecov/unt/list.c b/tests/codecov/unt/list.c deleted file mode 100644 index ddfc3c3..0000000 --- a/tests/codecov/unt/list.c +++ /dev/null @@ -1,615 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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; - }); -}) diff --git a/tests/codecov/unt/multimap.c b/tests/codecov/unt/multimap.c deleted file mode 100644 index f15f832..0000000 --- a/tests/codecov/unt/multimap.c +++ /dev/null @@ -1,374 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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; - }); -}); diff --git a/tests/codecov/unt/multiset.c b/tests/codecov/unt/multiset.c deleted file mode 100644 index b9220f0..0000000 --- a/tests/codecov/unt/multiset.c +++ /dev/null @@ -1,352 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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; - }); -}); diff --git a/tests/codecov/unt/queue.c b/tests/codecov/unt/queue.c deleted file mode 100644 index ee70de0..0000000 --- a/tests/codecov/unt/queue.c +++ /dev/null @@ -1,547 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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; - }); -}); diff --git a/tests/codecov/unt/sortedlist.c b/tests/codecov/unt/sortedlist.c deleted file mode 100644 index 81b2317..0000000 --- a/tests/codecov/unt/sortedlist.c +++ /dev/null @@ -1,315 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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; - }); -}); diff --git a/tests/codecov/unt/stack.c b/tests/codecov/unt/stack.c deleted file mode 100644 index 5476365..0000000 --- a/tests/codecov/unt/stack.c +++ /dev/null @@ -1,738 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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; - }); -}); diff --git a/tests/codecov/unt/treemap.c b/tests/codecov/unt/treemap.c deleted file mode 100644 index 804b1e4..0000000 --- a/tests/codecov/unt/treemap.c +++ /dev/null @@ -1,215 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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); - }); -}); diff --git a/tests/codecov/unt/treeset.c b/tests/codecov/unt/treeset.c deleted file mode 100644 index 872cf01..0000000 --- a/tests/codecov/unt/treeset.c +++ /dev/null @@ -1,165 +0,0 @@ -#include "utl.c" -#include -#include -#include - -#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); - }); -}); diff --git a/tests/codecov/unt/utl.c b/tests/codecov/unt/utl.c deleted file mode 100644 index 522aec5..0000000 --- a/tests/codecov/unt/utl.c +++ /dev/null @@ -1,200 +0,0 @@ -/* Utility file to be included in the unit tests */ -#ifndef CMC_UNIT_TEST_UTL__ -#define CMC_UNIT_TEST_UTL__ - -#include -#include -#include -#include - -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__ */ diff --git a/tests/main/Makefile b/tests/main/Makefile index 879474d..c0ede3d 100644 --- a/tests/main/Makefile +++ b/tests/main/Makefile @@ -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: diff --git a/tests/main/README.md b/tests/main/README.md index 4b14146..9d14b3e 100644 --- a/tests/main/README.md +++ b/tests/main/README.md @@ -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. diff --git a/tests/main/main.c b/tests/main/main.c index 1bcf491..f3bde88 100644 --- a/tests/main/main.c +++ b/tests/main/main.c @@ -1,4 +1,4 @@ -#include +#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; } diff --git a/tests/codecov/src/bidimap.c b/tests/main/src/bidimap.c similarity index 100% rename from tests/codecov/src/bidimap.c rename to tests/main/src/bidimap.c diff --git a/tests/codecov/src/deque.c b/tests/main/src/deque.c similarity index 100% rename from tests/codecov/src/deque.c rename to tests/main/src/deque.c diff --git a/tests/codecov/src/hashmap.c b/tests/main/src/hashmap.c similarity index 100% rename from tests/codecov/src/hashmap.c rename to tests/main/src/hashmap.c diff --git a/tests/codecov/src/hashset.c b/tests/main/src/hashset.c similarity index 100% rename from tests/codecov/src/hashset.c rename to tests/main/src/hashset.c diff --git a/tests/codecov/src/heap.c b/tests/main/src/heap.c similarity index 100% rename from tests/codecov/src/heap.c rename to tests/main/src/heap.c diff --git a/tests/codecov/src/intervalheap.c b/tests/main/src/intervalheap.c similarity index 100% rename from tests/codecov/src/intervalheap.c rename to tests/main/src/intervalheap.c diff --git a/tests/codecov/src/linkedlist.c b/tests/main/src/linkedlist.c similarity index 100% rename from tests/codecov/src/linkedlist.c rename to tests/main/src/linkedlist.c diff --git a/tests/codecov/src/list.c b/tests/main/src/list.c similarity index 100% rename from tests/codecov/src/list.c rename to tests/main/src/list.c diff --git a/tests/codecov/src/multimap.c b/tests/main/src/multimap.c similarity index 100% rename from tests/codecov/src/multimap.c rename to tests/main/src/multimap.c diff --git a/tests/codecov/src/multiset.c b/tests/main/src/multiset.c similarity index 100% rename from tests/codecov/src/multiset.c rename to tests/main/src/multiset.c diff --git a/tests/codecov/src/queue.c b/tests/main/src/queue.c similarity index 100% rename from tests/codecov/src/queue.c rename to tests/main/src/queue.c diff --git a/tests/codecov/src/sortedlist.c b/tests/main/src/sortedlist.c similarity index 100% rename from tests/codecov/src/sortedlist.c rename to tests/main/src/sortedlist.c diff --git a/tests/codecov/src/stack.c b/tests/main/src/stack.c similarity index 100% rename from tests/codecov/src/stack.c rename to tests/main/src/stack.c diff --git a/tests/codecov/src/treemap.c b/tests/main/src/treemap.c similarity index 100% rename from tests/codecov/src/treemap.c rename to tests/main/src/treemap.c diff --git a/tests/codecov/src/treeset.c b/tests/main/src/treeset.c similarity index 100% rename from tests/codecov/src/treeset.c rename to tests/main/src/treeset.c diff --git a/tests/main/unt/bidimap.c b/tests/main/unt/bidimap.c index 9a61517..192e3ec 100644 --- a/tests/main/unt/bidimap.c +++ b/tests/main/unt/bidimap.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -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, diff --git a/tests/main/unt/deque.c b/tests/main/unt/deque.c index 34d7381..76bb8a0 100644 --- a/tests/main/unt/deque.c +++ b/tests/main/unt/deque.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -CMC_GENERATE_DEQUE(d, deque, size_t) +#include "../src/deque.c" struct deque_ftab_val *d_ftab_val = &(struct deque_ftab_val){ .cmp = cmp, diff --git a/tests/main/unt/hashmap.c b/tests/main/unt/hashmap.c index 3dc4aa1..aa679da 100644 --- a/tests/main/unt/hashmap.c +++ b/tests/main/unt/hashmap.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -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, diff --git a/tests/main/unt/hashset.c b/tests/main/unt/hashset.c index 2ec072b..bc67c02 100644 --- a/tests/main/unt/hashset.c +++ b/tests/main/unt/hashset.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -CMC_GENERATE_HASHSET(hs, hashset, size_t) +#include "../src/hashset.c" struct hashset_ftab_val *hs_ftab_val = &(struct hashset_ftab_val){ .cmp = cmp, diff --git a/tests/main/unt/heap.c b/tests/main/unt/heap.c index f07d4fe..de91616 100644 --- a/tests/main/unt/heap.c +++ b/tests/main/unt/heap.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -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, diff --git a/tests/main/unt/intervalheap.c b/tests/main/unt/intervalheap.c index 586a5a3..1a9907a 100644 --- a/tests/main/unt/intervalheap.c +++ b/tests/main/unt/intervalheap.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -CMC_GENERATE_INTERVALHEAP(ih, intervalheap, size_t) +#include "../src/intervalheap.c" struct intervalheap_ftab_val *ih_ftab_val = &(struct intervalheap_ftab_val){ .cmp = cmp, diff --git a/tests/main/unt/linkedlist.c b/tests/main/unt/linkedlist.c index a0131b6..c0ad9cd 100644 --- a/tests/main/unt/linkedlist.c +++ b/tests/main/unt/linkedlist.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -CMC_GENERATE_LINKEDLIST(ll, linkedlist, size_t) +#include "../src/linkedlist.c" struct linkedlist_ftab_val *ll_ftab_val = &(struct linkedlist_ftab_val){ .cmp = cmp, diff --git a/tests/main/unt/list.c b/tests/main/unt/list.c index e4a6e46..6fb6072 100644 --- a/tests/main/unt/list.c +++ b/tests/main/unt/list.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -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, diff --git a/tests/main/unt/multimap.c b/tests/main/unt/multimap.c index 655ae6c..5e00e57 100644 --- a/tests/main/unt/multimap.c +++ b/tests/main/unt/multimap.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -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, diff --git a/tests/main/unt/multiset.c b/tests/main/unt/multiset.c index ccdb573..c962aad 100644 --- a/tests/main/unt/multiset.c +++ b/tests/main/unt/multiset.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -CMC_GENERATE_MULTISET(ms, multiset, size_t) +#include "../src/multiset.c" struct multiset_ftab_val *ms_ftab_val = &(struct multiset_ftab_val){ .cmp = cmp, diff --git a/tests/main/unt/queue.c b/tests/main/unt/queue.c index 7fe02b6..bc54ba7 100644 --- a/tests/main/unt/queue.c +++ b/tests/main/unt/queue.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -CMC_GENERATE_QUEUE(q, queue, size_t) +#include "../src/queue.c" struct queue_ftab_val *q_ftab_val = &(struct queue_ftab_val){ .cmp = cmp, diff --git a/tests/main/unt/sortedlist.c b/tests/main/unt/sortedlist.c index 150dde4..0792594 100644 --- a/tests/main/unt/sortedlist.c +++ b/tests/main/unt/sortedlist.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -CMC_GENERATE_SORTEDLIST(sl, sortedlist, size_t) +#include "../src/sortedlist.c" struct sortedlist_ftab_val *sl_ftab_val = &(struct sortedlist_ftab_val){ .cmp = cmp, diff --git a/tests/main/unt/stack.c b/tests/main/unt/stack.c index 5ebc986..4cb8ca8 100644 --- a/tests/main/unt/stack.c +++ b/tests/main/unt/stack.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -CMC_GENERATE_STACK(s, stack, size_t) +#include "../src/stack.c" struct stack_ftab_val *s_ftab_val = &(struct stack_ftab_val){ .cmp = cmp, diff --git a/tests/main/unt/treemap.c b/tests/main/unt/treemap.c index 8685fd5..f07ed46 100644 --- a/tests/main/unt/treemap.c +++ b/tests/main/unt/treemap.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -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, diff --git a/tests/main/unt/treeset.c b/tests/main/unt/treeset.c index c1285c6..32d79a9 100644 --- a/tests/main/unt/treeset.c +++ b/tests/main/unt/treeset.c @@ -1,11 +1,9 @@ #include "utl.c" -#include -#include -#include +#include "utl/assert.h" +#include "utl/log.h" +#include "utl/test.h" -#include - -CMC_GENERATE_TREESET(ts, treeset, size_t) +#include "../src/treeset.c" struct treeset_ftab_val *ts_ftab_val = &(struct treeset_ftab_val){ .cmp = cmp,