diff --git a/.travis.yml b/.travis.yml index 083bcf0..c94a0cb 100644 --- a/.travis.yml +++ b/.travis.yml @@ -12,9 +12,8 @@ addons: script: - sudo ln -s /usr/bin/gcc-6 /usr/local/bin/gcc - export CC=gcc-7 - - cd ./tests - - make - - cd ./main - - make + - make -C ./tests + - make -C ./main + - make -C ./codecov after_success: - bash <(curl -s https://codecov.io/bash) diff --git a/tests/README.md b/tests/README.md index 4a4692d..0755797 100644 --- a/tests/README.md +++ b/tests/README.md @@ -1,6 +1,7 @@ # Tests -* `main` - Unit tests for the main C Macro Collections library with code coverage; +* `codecov` - A stalled version for codecov; +* `main` - Unit tests for the main C Macro Collections library; * `sep/main.c`, `sep/sep.c` and `sep/sep.h` - Tests separate header and source compilation; * `contains.c` - Tests the `contains` function for all collections; * `foreach.c` - Tests the ForEach macros for all collections; diff --git a/tests/codecov/Makefile b/tests/codecov/Makefile new file mode 100644 index 0000000..bb54420 --- /dev/null +++ b/tests/codecov/Makefile @@ -0,0 +1,24 @@ +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 new file mode 100644 index 0000000..270818a --- /dev/null +++ b/tests/codecov/README.md @@ -0,0 +1,7 @@ +# 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 new file mode 100644 index 0000000..2303be1 --- /dev/null +++ b/tests/codecov/main.c @@ -0,0 +1,35 @@ +#include "unt/deque.c" +#include "unt/hashmap.c" +#include "unt/hashset.c" +#include "unt/heap.c" +#include "unt/linkedlist.c" +#include "unt/list.c" +#include "unt/queue.c" +#include "unt/stack.c" +#include "unt/treemap.c" +#include "unt/treeset.c" + +#include "unt/multimap.c" +#include "unt/multiset.c" + +int main(void) +{ + uintmax_t failed = 0; + + failed += deque_test(); + failed += hashmap_test(); + failed += hashset_test(); + failed += heap_test(); + failed += linkedlist_test(); + failed += list_test(); + failed += queue_test(); + failed += stack_test(); + failed += treemap_test(); + failed += treeset_test(); + + /* ext */ + failed += multimap_test(); + failed += multiset_test(); + + return failed; +} diff --git a/tests/main/src/deque.c b/tests/codecov/src/deque.c similarity index 100% rename from tests/main/src/deque.c rename to tests/codecov/src/deque.c diff --git a/tests/main/src/hashmap.c b/tests/codecov/src/hashmap.c similarity index 100% rename from tests/main/src/hashmap.c rename to tests/codecov/src/hashmap.c diff --git a/tests/main/src/hashset.c b/tests/codecov/src/hashset.c similarity index 100% rename from tests/main/src/hashset.c rename to tests/codecov/src/hashset.c diff --git a/tests/main/src/heap.c b/tests/codecov/src/heap.c similarity index 100% rename from tests/main/src/heap.c rename to tests/codecov/src/heap.c diff --git a/tests/main/src/linkedlist.c b/tests/codecov/src/linkedlist.c similarity index 100% rename from tests/main/src/linkedlist.c rename to tests/codecov/src/linkedlist.c diff --git a/tests/main/src/list.c b/tests/codecov/src/list.c similarity index 100% rename from tests/main/src/list.c rename to tests/codecov/src/list.c diff --git a/tests/main/src/multimap.c b/tests/codecov/src/multimap.c similarity index 100% rename from tests/main/src/multimap.c rename to tests/codecov/src/multimap.c diff --git a/tests/main/src/multiset.c b/tests/codecov/src/multiset.c similarity index 100% rename from tests/main/src/multiset.c rename to tests/codecov/src/multiset.c diff --git a/tests/main/src/queue.c b/tests/codecov/src/queue.c similarity index 100% rename from tests/main/src/queue.c rename to tests/codecov/src/queue.c diff --git a/tests/main/src/stack.c b/tests/codecov/src/stack.c similarity index 100% rename from tests/main/src/stack.c rename to tests/codecov/src/stack.c diff --git a/tests/main/src/treemap.c b/tests/codecov/src/treemap.c similarity index 100% rename from tests/main/src/treemap.c rename to tests/codecov/src/treemap.c diff --git a/tests/main/src/treeset.c b/tests/codecov/src/treeset.c similarity index 100% rename from tests/main/src/treeset.c rename to tests/codecov/src/treeset.c diff --git a/tests/codecov/unt/deque.c b/tests/codecov/unt/deque.c new file mode 100644 index 0000000..f31cb9a --- /dev/null +++ b/tests/codecov/unt/deque.c @@ -0,0 +1,61 @@ +#include "utl/assert.h" +#include "utl/test.h" +#include "../src/deque.c" + +CMC_CREATE_UNIT(deque_test, false, { + CMC_CREATE_TEST(new, { + deque *d = d_new(1000000); + + 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[edge_case:capacity = 0], { + deque *d = d_new(0); + + cmc_assert_equals(ptr, NULL, d); + }); + + CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { + deque *d = d_new(UINT64_MAX); + + cmc_assert_equals(ptr, NULL, d); + }); + + CMC_CREATE_TEST(clear[count capacity], { + deque *d = d_new(100); + + 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[edge_case:capacity = 1], { + deque *d = d_new(1); + + 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); + }); + +}); diff --git a/tests/codecov/unt/hashmap.c b/tests/codecov/unt/hashmap.c new file mode 100644 index 0000000..cc5cce5 --- /dev/null +++ b/tests/codecov/unt/hashmap.c @@ -0,0 +1,48 @@ +#include "utl/assert.h" +#include "utl/test.h" +#include "../src/hashmap.c" + +#include "utl.c" + +CMC_CREATE_UNIT(hashmap_test, false, { + CMC_CREATE_TEST(new, { + hashmap *map = hm_new(943722, 0.6, cmp, hash); + + 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[edge_case:capacity = 0], { + hashmap *map = hm_new(0, 0.6, cmp, hash); + + cmc_assert_equals(ptr, NULL, map); + }); + + CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { + hashmap *map = hm_new(UINT64_MAX, 0.6, cmp, hash); + + cmc_assert_equals(ptr, NULL, map); + }); + + CMC_CREATE_TEST(clear[count capacity], { + hashmap *map = hm_new(100, 0.6, cmp, hash); + + 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); + }); + +}); diff --git a/tests/codecov/unt/hashset.c b/tests/codecov/unt/hashset.c new file mode 100644 index 0000000..5cbe83f --- /dev/null +++ b/tests/codecov/unt/hashset.c @@ -0,0 +1,48 @@ +#include "utl/assert.h" +#include "utl/test.h" +#include "../src/hashset.c" + +#include "utl.c" + +CMC_CREATE_UNIT(hashset_test, false, { + CMC_CREATE_TEST(new, { + hashset *set = hs_new(943722, 0.6, cmp, hash); + + 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[edge_case:capacity = 0], { + hashset *set = hs_new(0, 0.6, cmp, hash); + + cmc_assert_equals(ptr, NULL, set); + }); + + CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { + hashset *set = hs_new(UINT64_MAX, 0.6, cmp, hash); + + cmc_assert_equals(ptr, NULL, set); + }); + + CMC_CREATE_TEST(clear[count capacity], { + hashset *set = hs_new(100, 0.6, cmp, hash); + + 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); + }); + +}); diff --git a/tests/codecov/unt/heap.c b/tests/codecov/unt/heap.c new file mode 100644 index 0000000..d02747b --- /dev/null +++ b/tests/codecov/unt/heap.c @@ -0,0 +1,62 @@ +#include "utl/assert.h" +#include "utl/test.h" +#include "../src/heap.c" + +#include "utl.c" + +CMC_CREATE_UNIT(heap_test, false, { + CMC_CREATE_TEST(new, { + heap *h = h_new(1000000, cmc_max_heap, cmp); + + 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], { + heap *h = h_new(0, cmc_max_heap, cmp); + + cmc_assert_equals(ptr, NULL, h); + }); + + CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { + heap *h = h_new(UINT64_MAX, cmc_max_heap, cmp); + + cmc_assert_equals(ptr, NULL, h); + }); + + CMC_CREATE_TEST(clear[count capacity], { + heap *h = h_new(100, cmc_max_heap, cmp); + + 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], { + heap *h = h_new(1, cmc_max_heap, cmp); + + 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_free(h); + }); + +}); diff --git a/tests/codecov/unt/linkedlist.c b/tests/codecov/unt/linkedlist.c new file mode 100644 index 0000000..84ca867 --- /dev/null +++ b/tests/codecov/unt/linkedlist.c @@ -0,0 +1,74 @@ +#include "utl/assert.h" +#include "utl/test.h" +#include "../src/linkedlist.c" + +CMC_CREATE_UNIT(linkedlist_test, false, { + CMC_CREATE_TEST(new, { + linkedlist *ll = ll_new(); + + 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], { + linkedlist *ll = ll_new(); + + 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[edge_case:count = 0], { + linkedlist *ll = ll_new(); + + 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], { + linkedlist *ll = ll_new(); + + 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], { + linkedlist *ll = ll_new(); + + 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); + }); + +}); diff --git a/tests/codecov/unt/list.c b/tests/codecov/unt/list.c new file mode 100644 index 0000000..c3f81d1 --- /dev/null +++ b/tests/codecov/unt/list.c @@ -0,0 +1,335 @@ +#include "utl/assert.h" +#include "utl/test.h" +#include "../src/list.c" + +CMC_CREATE_UNIT(list_test, false, { + CMC_CREATE_TEST(new, { + list *l = l_new(1000000); + + 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[edge_case:capacity = 0], { + list *l = l_new(0); + + cmc_assert_equals(ptr, NULL, l); + }); + + CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { + list *l = l_new(UINT64_MAX); + + cmc_assert_equals(ptr, NULL, l); + }); + + CMC_CREATE_TEST(new_from[count item_preservation], { + size_t v[5]; + + for (size_t i = 0; i < 5; i++) + { + v[i] = i; + } + + list *l = l_new_from(v, 5); + + cmc_assert_not_equals(ptr, NULL, l); + + for (size_t i = 0; i < 5; i++) + cmc_assert_equals(size_t, i, l_get(l, i)); + + l_free(l); + }); + + CMC_CREATE_TEST(new_from[edge_case:size = 1], { + size_t a = 10; + + size_t *values = &a; + + list *l = l_new_from(values, 1); + + cmc_assert_not_equals(ptr, NULL, l); + + l_free(l); + }); + + CMC_CREATE_TEST(clear[count capacity], { + list *l = l_new(100); + + 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[edge_case:capacity = 1], { + list *l = l_new(1); + + 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], { + list *l = l_new(100); + + 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], { + list *l = l_new(100); + + 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], { + list *l = l_new(100); + + 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[count], { + list *l = l_new(100); + + 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(l, i, l_count(l) - 1)); + + cmc_assert_equals(size_t, 250, l_count(l)); + + l_free(l); + }); + + CMC_CREATE_TEST(push[capacity], { + list *l = l_new(100); + + 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(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[item_preservation], { + list *l = l_new(100); + + 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(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], { + list *l = l_new(100); + + 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], { + list *l = l_new(100); + + 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], { + list *l = l_new(100); + + 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], { + list *l = l_new(100); + + 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], { + list *l = l_new(100); + + 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[edge_case:count = 0], { + list *l = l_new(100); + + cmc_assert_not_equals(ptr, NULL, l); + cmc_assert(!l_pop_front(l)); + + l_free(l); + }); + + CMC_CREATE_TEST(pop_front[edge_case:count = 1], { + list *l = l_new(100); + + 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], { + list *l = l_new(100); + + 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[edge_case:count = 0], { + list *l = l_new(100); + + cmc_assert_not_equals(ptr, NULL, l); + cmc_assert(!l_pop(l, 1)); + + l_free(l); + }); + + CMC_CREATE_TEST(pop[edge_case:count = 1], { + list *l = l_new(100); + + cmc_assert_not_equals(ptr, NULL, l); + cmc_assert(l_push_back(l, 1)); + cmc_assert(l_pop(l, 0)); + + cmc_assert_equals(size_t, 0, l->buffer[0]); + + l_free(l); + }); + + CMC_CREATE_TEST(pop[buffer_clear], { + list *l = l_new(100); + + 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(l, 1)); + + l_free(l); + }); + + CMC_CREATE_TEST(pop_back[edge_case:count = 0], { + list *l = l_new(100); + + cmc_assert_not_equals(ptr, NULL, l); + cmc_assert(!l_pop_back(l)); + + l_free(l); + }); + + CMC_CREATE_TEST(pop_back[edge_case:count = 1], { + list *l = l_new(100); + + cmc_assert_not_equals(ptr, NULL, l); + cmc_assert(l_push_back(l, 10)); + cmc_assert(l_pop_back(l)); + + l_free(l); + }); +}) diff --git a/tests/codecov/unt/multimap.c b/tests/codecov/unt/multimap.c new file mode 100644 index 0000000..899548b --- /dev/null +++ b/tests/codecov/unt/multimap.c @@ -0,0 +1,151 @@ +#include "utl/assert.h" +#include "utl/test.h" +#include "../src/multimap.c" + +#include "utl.c" + +CMC_CREATE_UNIT(multimap_test, false, { + CMC_CREATE_TEST(new, { + multimap *map = mm_new(943722, 0.8, cmp, hash); + + 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[edge_case:capacity = 0], { + multimap *map = mm_new(0, 0.8, cmp, hash); + + cmc_assert_equals(ptr, NULL, map); + }); + + CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { + multimap *map = mm_new(UINT64_MAX, 0.8, cmp, hash); + + cmc_assert_equals(ptr, NULL, map); + }); + + CMC_CREATE_TEST(clear[count capacity], { + multimap *map = mm_new(100, 0.8, cmp, hash); + + 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], { + multimap *map = mm_new(100, 0.8, cmp, hash); + + cmc_assert_not_equals(ptr, NULL, map); + + for (size_t i = 0; i < 200; i++) + cmc_assert(mm_insert(map, i % 20, i % 20)); + + cmc_assert_equals(size_t, 200, mm_count(map)); + + mm_free(map); + }); + + CMC_CREATE_TEST(remove[count], { + multimap *map = mm_new(100, 0.8, cmp, hash); + + 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[edge_case:count = 0], { + multimap *map = mm_new(100, 0.8, cmp, hash); + + cmc_assert_not_equals(ptr, NULL, map); + + size_t r; + + cmc_assert(!mm_remove(map, 10, &r)); + + mm_free(map); + }); + + CMC_CREATE_TEST(remove[edge_case:count = 1], { + multimap *map = mm_new(100, 0.8, cmp, hash); + + 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(insert_if, { + multimap *map = mm_new(100, 0.8, cmp, hash); + + cmc_assert_not_equals(ptr, NULL, map); + + for (size_t i = 1; i <= 100; i++) + cmc_assert(mm_insert_if(map, i % 20, i, i % 2 == 0) || i % 2 != 0); + + cmc_assert_equals(size_t, 50, mm_count(map)); + + mm_free(map); + }); + + CMC_CREATE_TEST(remove_if, { + multimap *map = mm_new(100, 0.8, cmp, hash); + + cmc_assert_not_equals(ptr, NULL, map); + + for (size_t i = 1; i <= 100; i++) + cmc_assert(mm_insert(map, i % 20, i)); + + size_t r; + + for (size_t i = 1; i <= 100; i++) + cmc_assert(mm_remove_if(map, i % 20, &r, i % 2 == 0) || i % 2 != 0); + + cmc_assert_equals(size_t, 50, mm_count(map)); + + mm_free(map); + }); + + CMC_CREATE_TEST(get[key_ordering], { + multimap *map = mm_new(100, 0.8, cmp, hash); + + 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); + }); + +}); diff --git a/tests/codecov/unt/multiset.c b/tests/codecov/unt/multiset.c new file mode 100644 index 0000000..6a2a3c4 --- /dev/null +++ b/tests/codecov/unt/multiset.c @@ -0,0 +1,86 @@ +#include "utl/assert.h" +#include "utl/test.h" +#include "../src/multiset.c" + +#include "utl.c" + +CMC_CREATE_UNIT(multiset_test, false, { + CMC_CREATE_TEST(new, { + multiset *set = ms_new(943722, 0.6, cmp, hash); + + 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[edge_case:capacity = 0], { + multiset *set = ms_new(0, 0.6, cmp, hash); + + cmc_assert_equals(ptr, NULL, set); + }); + + CMC_CREATE_TEST(new[edge_case:capacity = UINTMAX_MAX], { + multiset *set = ms_new(UINTMAX_MAX, 0.99, cmp, hash); + + cmc_assert_equals(ptr, NULL, set); + }); + + CMC_CREATE_TEST(clear[count capacity], { + multiset *set = ms_new(100, 0.6, cmp, hash); + + 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], { + multiset *set = ms_new(100, 0.6, cmp, hash); + + 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(multiplicity, { + multiset *set = ms_new(100, 0.6, cmp, hash); + + cmc_assert_not_equals(ptr, NULL, set); + + for (size_t i = 0; i < 100; i++) + cmc_assert(ms_insert(set, i % 20)); + + cmc_assert_equals(size_t, 20, ms_count(set)); + cmc_assert_equals(size_t, 100, ms_cardinality(set)); + + for (size_t i = 0; i < 20; i++) + cmc_assert_equals(size_t, 5, ms_multiplicity_of(set, i)); + + ms_free(set); + }); + +}); diff --git a/tests/codecov/unt/queue.c b/tests/codecov/unt/queue.c new file mode 100644 index 0000000..bacebb7 --- /dev/null +++ b/tests/codecov/unt/queue.c @@ -0,0 +1,61 @@ +#include "utl/assert.h" +#include "utl/test.h" +#include "../src/queue.c" + +CMC_CREATE_UNIT(queue_test, false, { + CMC_CREATE_TEST(new, { + queue *q = q_new(1000000); + + 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[edge_case:capacity = 0], { + queue *q = q_new(0); + + cmc_assert_equals(ptr, NULL, q); + }); + + CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { + queue *q = q_new(UINT64_MAX); + + cmc_assert_equals(ptr, NULL, q); + }); + + CMC_CREATE_TEST(clear[count capacity], { + queue *q = q_new(100); + + 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[edge_case:capacity = 1], { + queue *q = q_new(1); + + 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); + }); + +}); diff --git a/tests/codecov/unt/stack.c b/tests/codecov/unt/stack.c new file mode 100644 index 0000000..32f80e0 --- /dev/null +++ b/tests/codecov/unt/stack.c @@ -0,0 +1,628 @@ +#include "utl/assert.h" +#include "utl/test.h" +#include "../src/stack.c" + +#include "utl.c" + +CMC_CREATE_UNIT(stack_test, false, { + CMC_CREATE_TEST(new, { + stack *s = s_new(1000000); + + 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[edge_case:capacity = 0], { + stack *s = s_new(0); + + cmc_assert_equals(ptr, NULL, s); + }); + + CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { + stack *s = s_new(UINT64_MAX); + + cmc_assert_equals(ptr, NULL, s); + }); + + CMC_CREATE_TEST(clear[count capacity], { + stack *s = s_new(100); + + 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[edge_case:capacity = 1], { + stack *s = s_new(1); + + 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], { + stack *s = s_new(100); + + 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], { + stack *s = s_new(100); + + 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], { + stack *s = s_new(100); + + 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], { + stack *s = s_new(100); + + 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], { + stack *s = s_new(100); + + 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], { + stack *s = s_new(100); + + 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[edge_case:count = 0], { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + cmc_assert_equals(bool, false, s_pop(s)); + + s_free(s); + }); + + CMC_CREATE_TEST(push_if, { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + for (size_t i = 0; i < 250; i++) + s_push_if(s, i, i % 2 == 0); + + for (size_t i = 0; i < s_count(s); i++) + cmc_assert(s->buffer[i] % 2 == 0); + + s_free(s); + }); + + CMC_CREATE_TEST(pop_if, { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + for (size_t i = 0; i < 250; i++) + { + s_push(s, i); + s_pop_if(s, s_top(s) % 2 == 0); + } + + for (size_t i = 0; i < s_count(s); i++) + cmc_assert_not_equals(uint32_t, 0, s->buffer[i] % 2); + + s_free(s); + }); + + CMC_CREATE_TEST(top, { + stack *s = s_new(100); + + 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[edge_case:count = 0], { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + cmc_assert(s_push(s, 1)); + + cmc_assert(s_pop(s)); + + cmc_assert_equals(size_t, s_impl_default_value(), s_top(s)); + + s_free(s); + }); + + CMC_CREATE_TEST(top[edge_case:count = 1], { + stack *s = s_new(100); + + 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, { + stack *s = s_new(100); + + 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, cmp)); + + s_free(s); + }); + + CMC_CREATE_TEST(contains[edge_case:count = 0], { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + cmc_assert_equals(bool, false, s_contains(s, 10, cmp)); + + s_free(s); + }); + + CMC_CREATE_TEST(empty, { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + cmc_assert(s_empty(s)); + + s_free(s); + }); + + CMC_CREATE_TEST(empty[after_io], { + stack *s = s_new(100); + + 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, { + stack *s = s_new(100); + + 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[edge_case:capacity = 1], { + stack *s = s_new(1); + + 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, { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + 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[edge_case:count = 0], { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + 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[edge_case:count = 0], { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + stack_iter iter; + + s_iter_init(&iter, s); + + cmc_assert(s_iter_start(&iter)); + + s_free(s); + }); + + CMC_CREATE_TEST(iter_end[edge_case:count = 0], { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + stack_iter iter; + + s_iter_init(&iter, s); + + cmc_assert(s_iter_end(&iter)); + + s_free(s); + }); + + CMC_CREATE_TEST(iteration, { + stack *s = s_new(100); + + 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 (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 (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], { + stack *s = s_new(100); + + 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; + 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[edge_case:count = 1], { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + cmc_assert(s_push(s, 10)); + + size_t total = 0; + + for (stack_iter it = s->it_start(s); !s_iter_end(&it); s_iter_next(&it)) + { + total += s_iter_value(&it); + } + + for (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[edge_case:count = capacity], { + stack *s = s_new(100); + + 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 (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 (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], { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + for (size_t i = 0; i < 50; i++) + cmc_assert(s_push(s, i)); + + stack_iter it1; + stack_iter it2; + + memset(&it1, 0, sizeof(stack_iter)); + memset(&it2, 0, sizeof(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], { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + 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], { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + for (size_t i = 0; i < 200; i++) + cmc_assert(s_push(s, i)); + + 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[edge_case:count = 0], { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + stack_iter iter; + + s_iter_init(&iter, s); + + cmc_assert_equals(size_t, s_impl_default_value(), s_iter_value(&iter)); + + s_free(s); + }); + + CMC_CREATE_TEST(iter_rvalue[edge_case:count = 0], { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + stack_iter iter; + + s_iter_init(&iter, s); + + cmc_assert_equals(ptr, NULL, s_iter_rvalue(&iter)); + + s_free(s); + }); + + CMC_CREATE_TEST(index, { + stack *s = s_new(100); + + 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 (stack_iter it = s->it_start(s); false; ) + { + cmc_assert_equals(size_t, 0, s_iter_index(&it)); + } + + for (stack_iter it = s->it_start(s); false; ) + { + cmc_assert_equals(size_t, s_count(s) - 1, s_iter_index(&it)); + } + + for (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 (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[edge_case:count = 0], { + stack *s = s_new(100); + + cmc_assert_not_equals(ptr, NULL, s); + + stack_iter iter; + s_iter_init(&iter, s); + + cmc_assert_equals(size_t, 0, s_iter_index(&iter)); + + s_free(s); + }); + +}); diff --git a/tests/codecov/unt/treemap.c b/tests/codecov/unt/treemap.c new file mode 100644 index 0000000..c9d873b --- /dev/null +++ b/tests/codecov/unt/treemap.c @@ -0,0 +1,34 @@ +#include "utl/assert.h" +#include "utl/test.h" +#include "../src/treemap.c" + +#include "utl.c" + +CMC_CREATE_UNIT(treemap_test, false, { + CMC_CREATE_TEST(new, { + treemap *map = tm_new(cmp); + + cmc_assert_not_equals(ptr, NULL, map); + + tm_free(map); + }); + + CMC_CREATE_TEST(clear[count], { + treemap *map = tm_new(cmp); + + 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); + }); + +}); diff --git a/tests/codecov/unt/treeset.c b/tests/codecov/unt/treeset.c new file mode 100644 index 0000000..b8bb64b --- /dev/null +++ b/tests/codecov/unt/treeset.c @@ -0,0 +1,34 @@ +#include "utl/assert.h" +#include "utl/test.h" +#include "../src/treeset.c" + +#include "utl.c" + +CMC_CREATE_UNIT(treeset_test, false, { + CMC_CREATE_TEST(new, { + treeset *set = ts_new(cmp); + + cmc_assert_not_equals(ptr, NULL, set); + + ts_free(set); + }); + + CMC_CREATE_TEST(clear[count], { + treeset *set = ts_new(cmp); + + 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); + }); + +}); diff --git a/tests/codecov/unt/utl.c b/tests/codecov/unt/utl.c new file mode 100644 index 0000000..b42a9e4 --- /dev/null +++ b/tests/codecov/unt/utl.c @@ -0,0 +1,23 @@ +/* Utility file to be included in the unit tests */ +#ifndef CMC_UNIT_TEST_UTL__ +#define CMC_UNIT_TEST_UTL__ + +#include + +int cmp(size_t a, size_t b) +{ + return (a > b) - (a < b); +} + +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; +} + +#endif /* CMC_UNIT_TEST_UTL__ */ diff --git a/tests/main/Makefile b/tests/main/Makefile index bb54420..305a8d4 100644 --- a/tests/main/Makefile +++ b/tests/main/Makefile @@ -1,24 +1,21 @@ CC = gcc CFLAGS = -std=c11 -Wall -Wextra CFLAGS += -Wno-unused-function -Wno-unused-parameter -Wno-unused-variable -Wno-unused-label -CVFLAGS = --coverage -O0 +CFLAGS += -DCMC_TEST_COLOR INCLUDE = ../../src/ main: FORCE - $(CC) main.c -o main $(CFLAGS) $(CVFLAGS) -I $(INCLUDE) + $(CC) main.c -o main $(CFLAGS) -I $(INCLUDE) ./main - gcov ./main.c dev: FORCE - $(CC) main.c -o main $(CFLAGS) $(CVFLAGS) -I $(INCLUDE) + $(CC) main.c -o main $(CFLAGS) -I $(INCLUDE) ./main - gcov ./main.c -n - rm *.gcda *.gcno *.exe + rm *.exe windev: FORCE - $(CC) main.c -o main $(CFLAGS) $(CVFLAGS) -I $(INCLUDE) + $(CC) main.c -o main $(CFLAGS) -I $(INCLUDE) ./main - gcov ./main.c -n - del *.gcda *.gcno *.exe + del *.exe FORCE: diff --git a/tests/main/README.md b/tests/main/README.md index 24f0a9b..4b14146 100644 --- a/tests/main/README.md +++ b/tests/main/README.md @@ -1,7 +1,5 @@ # main -Tests for the main C Macro Collections library. In order to provide a good code coverage, all macros have been expanded and added to `src/*.c`. +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. -* `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(). +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. diff --git a/tests/main/main.c b/tests/main/main.c index 2303be1..24cae15 100644 --- a/tests/main/main.c +++ b/tests/main/main.c @@ -1,3 +1,5 @@ +#include + #include "unt/deque.c" #include "unt/hashmap.c" #include "unt/hashset.c" @@ -9,11 +11,15 @@ #include "unt/treemap.c" #include "unt/treeset.c" +#include "unt/intervalheap.c" #include "unt/multimap.c" #include "unt/multiset.c" int main(void) { + cmc_timer timer; + + cmc_timer_start(timer); uintmax_t failed = 0; failed += deque_test(); @@ -28,8 +34,16 @@ int main(void) failed += treeset_test(); /* ext */ + failed += intervalheap_test(); failed += multimap_test(); failed += multiset_test(); + cmc_timer_stop(timer); + cmc_timer_calc(timer); + + printf("+--------------------------------------------------+\n"); + printf("| Total running time : %14.0lf milliseconds |\n", timer.result); + printf("+--------------------------------------------------+\n"); + return failed; } diff --git a/tests/main/unt/deque.c b/tests/main/unt/deque.c index 3b229c7..8ebf3b8 100644 --- a/tests/main/unt/deque.c +++ b/tests/main/unt/deque.c @@ -1,6 +1,11 @@ -#include "utl/assert.h" -#include "utl/test.h" -#include "../src/deque.c" +#include "utl.c" +#include +#include +#include + +#include + +CMC_GENERATE_DEQUE(d, deque, size_t) CMC_CREATE_UNIT(deque_test, true, { CMC_CREATE_TEST(new, { @@ -11,16 +16,16 @@ CMC_CREATE_UNIT(deque_test, true, { cmc_assert_equals(size_t, 1000000, d->capacity); cmc_assert_equals(size_t, 0, d_count(d)); - d_free(d); + d_free(d, NULL); }); - CMC_CREATE_TEST(new[edge_case:capacity = 0], { + CMC_CREATE_TEST(new [edge_case:capacity = 0], { deque *d = d_new(0); cmc_assert_equals(ptr, NULL, d); }); - CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], { + CMC_CREATE_TEST(new [edge_case:capacity = UINT64_MAX], { deque *d = d_new(UINT64_MAX); cmc_assert_equals(ptr, NULL, d); @@ -36,15 +41,15 @@ CMC_CREATE_UNIT(deque_test, true, { cmc_assert_equals(size_t, 50, d_count(d)); - d_clear(d); + d_clear(d, NULL); cmc_assert_equals(size_t, 0, d_count(d)); cmc_assert_equals(size_t, 100, d_capacity(d)); - d_free(d); + d_free(d, NULL); }); - CMC_CREATE_TEST(buffer_growth[edge_case:capacity = 1], { + CMC_CREATE_TEST(buffer_growth [edge_case:capacity = 1], { deque *d = d_new(1); cmc_assert_not_equals(ptr, NULL, d); @@ -55,7 +60,220 @@ CMC_CREATE_UNIT(deque_test, true, { cmc_assert_equals(size_t, 50, d_count(d)); cmc_assert_lesser_equals(size_t, d_capacity(d), d_count(d)); - d_free(d); + d_free(d, NULL); }); + CMC_CREATE_TEST(push_front[count capacity], { + deque *d = d_new(100); + + 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, NULL); + }); + + CMC_CREATE_TEST(push_front[item_preservation], { + deque *d = d_new(100); + + 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, NULL); + }); + + CMC_CREATE_TEST(push_back[count capacity], { + deque *d = d_new(100); + + 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, NULL); + }); + + CMC_CREATE_TEST(push_back[item_preservation], { + deque *d = d_new(100); + + 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, NULL); + }); + + CMC_CREATE_TEST(pop_front[count capacity], { + deque *d = d_new(100); + + 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, NULL); + }); + + CMC_CREATE_TEST(pop_front[item_preservation], { + deque *d = d_new(100); + + 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, NULL); + }); + + CMC_CREATE_TEST(pop_back[count capacity], { + deque *d = d_new(100); + + 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, NULL); + }); + + CMC_CREATE_TEST(pop_back[item_preservation], { + deque *d = d_new(100); + + 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, NULL); + }); + + CMC_CREATE_TEST(Mixed IO, { + deque *d = d_new(100); + + 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, NULL); + }); }); diff --git a/tests/main/unt/hashmap.c b/tests/main/unt/hashmap.c index 63cb793..f80445d 100644 --- a/tests/main/unt/hashmap.c +++ b/tests/main/unt/hashmap.c @@ -1,8 +1,11 @@ -#include "utl/assert.h" -#include "utl/test.h" -#include "../src/hashmap.c" - #include "utl.c" +#include +#include +#include + +#include + +CMC_GENERATE_HASHMAP(hm, hashmap, size_t, size_t) CMC_CREATE_UNIT(hashmap_test, true, { CMC_CREATE_TEST(new, { @@ -13,7 +16,7 @@ CMC_CREATE_UNIT(hashmap_test, true, { cmc_assert_equals(size_t, 0, hm_count(map)); cmc_assert_greater_equals(size_t, (943722 / 0.6), hm_capacity(map)); - hm_free(map); + hm_free(map, NULL); }); CMC_CREATE_TEST(new[edge_case:capacity = 0], { @@ -38,11 +41,11 @@ CMC_CREATE_UNIT(hashmap_test, true, { cmc_assert_equals(size_t, 50, hm_count(map)); - hm_clear(map); + hm_clear(map, NULL); cmc_assert_equals(size_t, 0, hm_count(map)); - hm_free(map); + hm_free(map, NULL); }); }); diff --git a/tests/main/unt/hashset.c b/tests/main/unt/hashset.c index 1242826..fa5e911 100644 --- a/tests/main/unt/hashset.c +++ b/tests/main/unt/hashset.c @@ -1,8 +1,11 @@ -#include "utl/assert.h" -#include "utl/test.h" -#include "../src/hashset.c" - #include "utl.c" +#include +#include +#include + +#include + +CMC_GENERATE_HASHSET(hs, hashset, size_t) CMC_CREATE_UNIT(hashset_test, true, { CMC_CREATE_TEST(new, { @@ -13,7 +16,7 @@ CMC_CREATE_UNIT(hashset_test, true, { cmc_assert_equals(size_t, 0, hs_count(set)); cmc_assert_greater_equals(size_t, (943722 / 0.6), hs_capacity(set)); - hs_free(set); + hs_free(set, NULL); }); CMC_CREATE_TEST(new[edge_case:capacity = 0], { @@ -38,11 +41,11 @@ CMC_CREATE_UNIT(hashset_test, true, { cmc_assert_equals(size_t, 50, hs_count(set)); - hs_clear(set); + hs_clear(set, NULL); cmc_assert_equals(size_t, 0, hs_count(set)); - hs_free(set); + hs_free(set, NULL); }); }); diff --git a/tests/main/unt/heap.c b/tests/main/unt/heap.c index 0c34b20..84b4aaf 100644 --- a/tests/main/unt/heap.c +++ b/tests/main/unt/heap.c @@ -1,8 +1,11 @@ -#include "utl/assert.h" -#include "utl/test.h" -#include "../src/heap.c" - #include "utl.c" +#include +#include +#include + +#include + +CMC_GENERATE_HEAP(h, heap, size_t) CMC_CREATE_UNIT(heap_test, true, { CMC_CREATE_TEST(new, { @@ -13,7 +16,7 @@ CMC_CREATE_UNIT(heap_test, true, { cmc_assert_equals(size_t, 1000000, h_capacity(h)); cmc_assert_equals(size_t, 0, h_count(h)); - h_free(h); + h_free(h, NULL); }); CMC_CREATE_TEST(new[edge_case:capacity = 0], { @@ -38,12 +41,12 @@ CMC_CREATE_UNIT(heap_test, true, { cmc_assert_equals(size_t, 50, h_count(h)); - h_clear(h); + h_clear(h, NULL); cmc_assert_equals(size_t, 0, h_count(h)); cmc_assert_equals(size_t, 100, h_capacity(h)); - h_free(h); + h_free(h, NULL); }); CMC_CREATE_TEST(buffer_growth[edge_case:capacity = 1], { @@ -56,7 +59,7 @@ CMC_CREATE_UNIT(heap_test, true, { cmc_assert_equals(size_t, 50, h_count(h)); - h_free(h); + h_free(h, NULL); }); }); diff --git a/tests/main/unt/intervalheap.c b/tests/main/unt/intervalheap.c new file mode 100644 index 0000000..df25453 --- /dev/null +++ b/tests/main/unt/intervalheap.c @@ -0,0 +1,70 @@ +#include "utl.c" +#include +#include +#include + +#include + +CMC_GENERATE_INTERVALHEAP(ih, intervalheap, size_t) + +CMC_CREATE_UNIT(intervalheap_test, true, { + CMC_CREATE_TEST(new, { + intervalheap *ih = ih_new(1000000, cmp); + + 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, NULL); + }); + + CMC_CREATE_TEST(new [edge_case:capacity = 0], { + intervalheap *ih = ih_new(0, cmp); + + cmc_assert_equals(ptr, NULL, ih); + + if (ih) + ih_free(ih, NULL); + }); + + CMC_CREATE_TEST(new [edge_case:capacity = UINT64_MAX], { + intervalheap *ih = ih_new(UINT64_MAX, cmp); + + cmc_assert_equals(ptr, NULL, ih); + + if (ih) + ih_free(ih, NULL); + }); + + CMC_CREATE_TEST(clear[count capacity], { + intervalheap *ih = ih_new(100, cmp); + + cmc_assert_not_equals(ptr, NULL, ih); + + for (size_t i = 0; i < 50; i++) + ih_insert(ih, i); + + cmc_assert_equals(size_t, 50, ih_count(ih)); + + ih_clear(ih, NULL); + + cmc_assert_equals(size_t, 0, ih_count(ih)); + cmc_assert_equals(size_t, 50, ih_capacity(ih)); + + ih_free(ih, NULL); + }); + + CMC_CREATE_TEST(buffer_growth [edge_case:capacity = 1], { + intervalheap *ih = ih_new(1, cmp); + + cmc_assert_not_equals(ptr, NULL, ih); + + for (size_t i = 0; i < 50; i++) + ih_insert(ih, i); + + cmc_assert_equals(size_t, 50, ih_count(ih)); + + ih_free(ih, NULL); + }); +}); diff --git a/tests/main/unt/linkedlist.c b/tests/main/unt/linkedlist.c index 248797d..0d7b5e3 100644 --- a/tests/main/unt/linkedlist.c +++ b/tests/main/unt/linkedlist.c @@ -1,6 +1,11 @@ -#include "utl/assert.h" -#include "utl/test.h" -#include "../src/linkedlist.c" +#include "utl.c" +#include +#include +#include + +#include + +CMC_GENERATE_LINKEDLIST(ll, linkedlist, size_t) CMC_CREATE_UNIT(linkedlist_test, true, { CMC_CREATE_TEST(new, { @@ -11,7 +16,7 @@ CMC_CREATE_UNIT(linkedlist_test, true, { cmc_assert_equals(ptr, NULL, ll->head); cmc_assert_equals(ptr, NULL, ll->tail); - ll_free(ll); + ll_free(ll, NULL); }); CMC_CREATE_TEST(clear[count capacity], { @@ -24,11 +29,11 @@ CMC_CREATE_UNIT(linkedlist_test, true, { cmc_assert_equals(size_t, 50, ll_count(ll)); - ll_clear(ll); + ll_clear(ll, NULL); cmc_assert_equals(size_t, 0, ll_count(ll)); - ll_free(ll); + ll_free(ll, NULL); }); CMC_CREATE_TEST(clear[edge_case:count = 0], { @@ -36,11 +41,11 @@ CMC_CREATE_UNIT(linkedlist_test, true, { cmc_assert_not_equals(ptr, NULL, ll); - ll_clear(ll); + ll_clear(ll, NULL); cmc_assert_equals(size_t, 0, ll_count(ll)); - ll_free(ll); + ll_free(ll, NULL); }); CMC_CREATE_TEST(push_front[count], { @@ -54,7 +59,7 @@ CMC_CREATE_UNIT(linkedlist_test, true, { cmc_assert_not_equals(ptr, NULL, ll->tail); cmc_assert_equals(size_t, 1, ll_count(ll)); - ll_free(ll); + ll_free(ll, NULL); }); CMC_CREATE_TEST(push_front[item_preservation], { @@ -68,7 +73,7 @@ CMC_CREATE_UNIT(linkedlist_test, true, { 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); + ll_free(ll, NULL); }); }); diff --git a/tests/main/unt/list.c b/tests/main/unt/list.c index 2990b4d..c5e25c9 100644 --- a/tests/main/unt/list.c +++ b/tests/main/unt/list.c @@ -1,6 +1,11 @@ -#include "utl/assert.h" -#include "utl/test.h" -#include "../src/list.c" +#include "utl.c" +#include +#include +#include + +#include + +CMC_GENERATE_LIST(l, list, size_t) CMC_CREATE_UNIT(list_test, true, { CMC_CREATE_TEST(new, { @@ -11,7 +16,7 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_equals(size_t, 1000000, l_capacity(l)); cmc_assert_equals(size_t, 0, l_count(l)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(new[edge_case:capacity = 0], { @@ -41,7 +46,7 @@ CMC_CREATE_UNIT(list_test, true, { for (size_t i = 0; i < 5; i++) cmc_assert_equals(size_t, i, l_get(l, i)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(new_from[edge_case:size = 1], { @@ -53,7 +58,7 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_not_equals(ptr, NULL, l); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(clear[count capacity], { @@ -66,12 +71,12 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_equals(size_t, 50, l_count(l)); - l_clear(l); + l_clear(l, NULL); cmc_assert_equals(size_t, 0, l_count(l)); cmc_assert_equals(size_t, 100, l_capacity(l)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(buffer_growth[edge_case:capacity = 1], { @@ -87,7 +92,7 @@ CMC_CREATE_UNIT(list_test, true, { for (size_t i = 0; i < 100; i++) cmc_assert_equals(size_t, i, l_get(l, i)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(push_front[count], { @@ -100,7 +105,7 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_equals(size_t, 250, l_count(l)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(push_front[capacity], { @@ -113,7 +118,7 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(push_front[item_preservation], { @@ -127,7 +132,7 @@ CMC_CREATE_UNIT(list_test, true, { 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); + l_free(l, NULL); }); CMC_CREATE_TEST(push[count], { @@ -139,11 +144,11 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert(l_push_back(l, 249)); for (size_t i = 1; i < 249; i++) - cmc_assert(l_push(l, i, l_count(l) - 1)); + cmc_assert(l_push_at(l, i, l_count(l) - 1)); cmc_assert_equals(size_t, 250, l_count(l)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(push[capacity], { @@ -155,11 +160,11 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert(l_push_back(l, 249)); for (size_t i = 1; i < 249; i++) - cmc_assert(l_push(l, i, l_count(l) - 1)); + 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); + l_free(l, NULL); }); CMC_CREATE_TEST(push[item_preservation], { @@ -171,12 +176,12 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert(l_push_back(l, 249)); for (size_t i = 1; i < 249; i++) - cmc_assert(l_push(l, i, l_count(l) - 1)); + 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); + l_free(l, NULL); }); CMC_CREATE_TEST(push_back[count], { @@ -189,7 +194,7 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_equals(size_t, 250, l_count(l)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(push_back[capacity], { @@ -202,7 +207,7 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(push_back[item_preservation], { @@ -216,7 +221,7 @@ CMC_CREATE_UNIT(list_test, true, { for (size_t i = 0; i < l_count(l); i++) cmc_assert_equals(size_t, l_get(l, i), i); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(pop_front[count], { @@ -229,7 +234,7 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert(l_pop_front(l)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(pop_front[item_preservation], { @@ -245,7 +250,7 @@ CMC_CREATE_UNIT(list_test, true, { for (size_t i = 0; i < l_count(l); i++) cmc_assert_equals(size_t, l_get(l, i), i + 1); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(pop_front[edge_case:count = 0], { @@ -254,7 +259,7 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_not_equals(ptr, NULL, l); cmc_assert(!l_pop_front(l)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(pop_front[edge_case:count = 1], { @@ -264,7 +269,7 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert(l_push_back(l, 10)); cmc_assert(l_pop_front(l)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(pop_front[buffer_clear], { @@ -278,16 +283,16 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_equals(size_t, 0, l->buffer[1]); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(pop[edge_case:count = 0], { list *l = l_new(100); cmc_assert_not_equals(ptr, NULL, l); - cmc_assert(!l_pop(l, 1)); + cmc_assert(!l_pop_at(l, 1)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(pop[edge_case:count = 1], { @@ -295,11 +300,11 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_not_equals(ptr, NULL, l); cmc_assert(l_push_back(l, 1)); - cmc_assert(l_pop(l, 0)); + cmc_assert(l_pop_at(l, 0)); cmc_assert_equals(size_t, 0, l->buffer[0]); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(pop[buffer_clear], { @@ -309,9 +314,9 @@ CMC_CREATE_UNIT(list_test, true, { 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(l, 1)); + cmc_assert(l_pop_at(l, 1)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(pop_back[edge_case:count = 0], { @@ -320,7 +325,7 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_not_equals(ptr, NULL, l); cmc_assert(!l_pop_back(l)); - l_free(l); + l_free(l, NULL); }); CMC_CREATE_TEST(pop_back[edge_case:count = 1], { @@ -330,6 +335,6 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert(l_push_back(l, 10)); cmc_assert(l_pop_back(l)); - l_free(l); + l_free(l, NULL); }); }) diff --git a/tests/main/unt/multimap.c b/tests/main/unt/multimap.c index 03895f3..5ee74fa 100644 --- a/tests/main/unt/multimap.c +++ b/tests/main/unt/multimap.c @@ -1,8 +1,11 @@ -#include "utl/assert.h" -#include "utl/test.h" -#include "../src/multimap.c" - #include "utl.c" +#include +#include +#include + +#include + +CMC_GENERATE_MULTIMAP(mm, multimap, size_t, size_t) CMC_CREATE_UNIT(multimap_test, true, { CMC_CREATE_TEST(new, { @@ -13,7 +16,7 @@ CMC_CREATE_UNIT(multimap_test, true, { cmc_assert_equals(size_t, 0, mm_count(map)); cmc_assert_greater_equals(size_t, (943722 / 0.8), mm_capacity(map)); - mm_free(map); + mm_free(map, NULL); }); CMC_CREATE_TEST(new[edge_case:capacity = 0], { @@ -38,11 +41,11 @@ CMC_CREATE_UNIT(multimap_test, true, { cmc_assert_equals(size_t, 50, mm_count(map)); - mm_clear(map); + mm_clear(map, NULL); cmc_assert_equals(size_t, 0, mm_count(map)); - mm_free(map); + mm_free(map, NULL); }); CMC_CREATE_TEST(insert[count], { @@ -55,7 +58,7 @@ CMC_CREATE_UNIT(multimap_test, true, { cmc_assert_equals(size_t, 200, mm_count(map)); - mm_free(map); + mm_free(map, NULL); }); CMC_CREATE_TEST(remove[count], { @@ -73,7 +76,7 @@ CMC_CREATE_UNIT(multimap_test, true, { cmc_assert_equals(size_t, 140, mm_count(map)); - mm_free(map); + mm_free(map, NULL); }); CMC_CREATE_TEST(remove[edge_case:count = 0], { @@ -85,7 +88,7 @@ CMC_CREATE_UNIT(multimap_test, true, { cmc_assert(!mm_remove(map, 10, &r)); - mm_free(map); + mm_free(map, NULL); }); CMC_CREATE_TEST(remove[edge_case:count = 1], { @@ -98,38 +101,7 @@ CMC_CREATE_UNIT(multimap_test, true, { cmc_assert(mm_insert(map, 10, 11)); cmc_assert(mm_remove(map, 10, &r)); - mm_free(map); - }); - - CMC_CREATE_TEST(insert_if, { - multimap *map = mm_new(100, 0.8, cmp, hash); - - cmc_assert_not_equals(ptr, NULL, map); - - for (size_t i = 1; i <= 100; i++) - cmc_assert(mm_insert_if(map, i % 20, i, i % 2 == 0) || i % 2 != 0); - - cmc_assert_equals(size_t, 50, mm_count(map)); - - mm_free(map); - }); - - CMC_CREATE_TEST(remove_if, { - multimap *map = mm_new(100, 0.8, cmp, hash); - - cmc_assert_not_equals(ptr, NULL, map); - - for (size_t i = 1; i <= 100; i++) - cmc_assert(mm_insert(map, i % 20, i)); - - size_t r; - - for (size_t i = 1; i <= 100; i++) - cmc_assert(mm_remove_if(map, i % 20, &r, i % 2 == 0) || i % 2 != 0); - - cmc_assert_equals(size_t, 50, mm_count(map)); - - mm_free(map); + mm_free(map, NULL); }); CMC_CREATE_TEST(get[key_ordering], { @@ -145,7 +117,7 @@ CMC_CREATE_UNIT(multimap_test, true, { cmc_assert_equals(size_t, 100, mm_get(map, 10)); - mm_free(map); + mm_free(map, NULL); }); }); diff --git a/tests/main/unt/multiset.c b/tests/main/unt/multiset.c index 7d5a0a0..f793d02 100644 --- a/tests/main/unt/multiset.c +++ b/tests/main/unt/multiset.c @@ -1,8 +1,11 @@ -#include "utl/assert.h" -#include "utl/test.h" -#include "../src/multiset.c" - #include "utl.c" +#include +#include +#include + +#include + +CMC_GENERATE_MULTISET(ms, multiset, size_t) CMC_CREATE_UNIT(multiset_test, true, { CMC_CREATE_TEST(new, { @@ -13,7 +16,7 @@ CMC_CREATE_UNIT(multiset_test, true, { 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); + ms_free(set, NULL); }); CMC_CREATE_TEST(new[edge_case:capacity = 0], { @@ -38,11 +41,11 @@ CMC_CREATE_UNIT(multiset_test, true, { cmc_assert_equals(size_t, 50, ms_count(set)); - ms_clear(set); + ms_clear(set, NULL); cmc_assert_equals(size_t, 0, ms_count(set)); - ms_free(set); + ms_free(set, NULL); }); CMC_CREATE_TEST(insert[count cardinality multiplicity], { @@ -63,7 +66,7 @@ CMC_CREATE_UNIT(multiset_test, true, { for (size_t i = 0; i <= 3; i++) cmc_assert_equals(size_t, i, ms_multiplicity_of(set, i)); - ms_free(set); + ms_free(set, NULL); }); CMC_CREATE_TEST(multiplicity, { @@ -80,7 +83,7 @@ CMC_CREATE_UNIT(multiset_test, true, { for (size_t i = 0; i < 20; i++) cmc_assert_equals(size_t, 5, ms_multiplicity_of(set, i)); - ms_free(set); + ms_free(set, NULL); }); }); diff --git a/tests/main/unt/queue.c b/tests/main/unt/queue.c index 4a6f7db..4811fcb 100644 --- a/tests/main/unt/queue.c +++ b/tests/main/unt/queue.c @@ -1,6 +1,11 @@ -#include "utl/assert.h" -#include "utl/test.h" -#include "../src/queue.c" +#include "utl.c" +#include +#include +#include + +#include + +CMC_GENERATE_QUEUE(q, queue, size_t) CMC_CREATE_UNIT(queue_test, true, { CMC_CREATE_TEST(new, { @@ -12,7 +17,7 @@ CMC_CREATE_UNIT(queue_test, true, { cmc_assert_equals(size_t, 0, q_count(q)); cmc_assert_not_equals(ptr, NULL, q->buffer); - q_free(q); + q_free(q, NULL); }); CMC_CREATE_TEST(new[edge_case:capacity = 0], { @@ -37,12 +42,12 @@ CMC_CREATE_UNIT(queue_test, true, { cmc_assert_equals(size_t, 50, q_count(q)); - q_clear(q); + q_clear(q, NULL); cmc_assert_equals(size_t, 0, q_count(q)); cmc_assert_equals(size_t, 100, q_capacity(q)); - q_free(q); + q_free(q, NULL); }); CMC_CREATE_TEST(buffer_growth[edge_case:capacity = 1], { @@ -55,7 +60,7 @@ CMC_CREATE_UNIT(queue_test, true, { cmc_assert_equals(size_t, 50, q_count(q)); - q_free(q); + q_free(q, NULL); }); }); diff --git a/tests/main/unt/stack.c b/tests/main/unt/stack.c index 8222d17..a05d1b1 100644 --- a/tests/main/unt/stack.c +++ b/tests/main/unt/stack.c @@ -1,8 +1,11 @@ -#include "utl/assert.h" -#include "utl/test.h" -#include "../src/stack.c" - #include "utl.c" +#include +#include +#include + +#include + +CMC_GENERATE_STACK(s, stack, size_t) CMC_CREATE_UNIT(stack_test, true, { CMC_CREATE_TEST(new, { @@ -14,7 +17,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, 0, s_count(s)); cmc_assert_not_equals(ptr, NULL, s->buffer); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(new[edge_case:capacity = 0], { @@ -39,12 +42,12 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, 50, s_count(s)); - s_clear(s); + s_clear(s, NULL); cmc_assert_equals(size_t, 0, s_count(s)); cmc_assert_equals(size_t, 100, s_capacity(s)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(buffer_growth[edge_case:capacity = 1], { @@ -58,7 +61,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, 50, s_count(s)); cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(push[count], { @@ -71,7 +74,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, 250, s_count(s)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(push[capacity], { @@ -84,7 +87,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(push[item_preservation], { @@ -98,7 +101,7 @@ CMC_CREATE_UNIT(stack_test, true, { for (size_t i = 0; i < s_count(s); i++) cmc_assert_equals(size_t, i, s->buffer[i]); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(pop[count], { @@ -113,7 +116,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, 249, s_count(s)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(pop[capacity], { @@ -128,7 +131,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(pop[item_preservation], { @@ -145,7 +148,7 @@ CMC_CREATE_UNIT(stack_test, true, { for (size_t i = 0; i < s_count(s); i++) cmc_assert_equals(size_t, i, s->buffer[i]); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(pop[edge_case:count = 0], { @@ -155,38 +158,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(bool, false, s_pop(s)); - s_free(s); - }); - - CMC_CREATE_TEST(push_if, { - stack *s = s_new(100); - - cmc_assert_not_equals(ptr, NULL, s); - - for (size_t i = 0; i < 250; i++) - s_push_if(s, i, i % 2 == 0); - - for (size_t i = 0; i < s_count(s); i++) - cmc_assert(s->buffer[i] % 2 == 0); - - s_free(s); - }); - - CMC_CREATE_TEST(pop_if, { - stack *s = s_new(100); - - cmc_assert_not_equals(ptr, NULL, s); - - for (size_t i = 0; i < 250; i++) - { - s_push(s, i); - s_pop_if(s, s_top(s) % 2 == 0); - } - - for (size_t i = 0; i < s_count(s); i++) - cmc_assert_not_equals(uint32_t, 0, s->buffer[i] % 2); - - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(top, { @@ -202,7 +174,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, 247, s_top(s)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(top[edge_case:count = 0], { @@ -216,7 +188,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, s_impl_default_value(), s_top(s)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(top[edge_case:count = 1], { @@ -228,7 +200,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, 1, s_count(s)); cmc_assert_equals(size_t, 10, s_top(s)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(contains, { @@ -242,7 +214,7 @@ CMC_CREATE_UNIT(stack_test, true, { for (size_t i = 0; i < 150; i++) cmc_assert(s_contains(s, i, cmp)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(contains[edge_case:count = 0], { @@ -252,7 +224,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(bool, false, s_contains(s, 10, cmp)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(empty, { @@ -262,7 +234,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert(s_empty(s)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(empty[after_io], { @@ -274,7 +246,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert(s_pop(s)); cmc_assert(s_empty(s)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(full, { @@ -287,7 +259,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert(s_full(s)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(full[edge_case:capacity = 1], { @@ -299,7 +271,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert(s_full(s)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(iter_alloc, { @@ -312,7 +284,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_not_equals(ptr, NULL, iter); s_iter_free(iter); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(iter_init[edge_case:count = 0], { @@ -329,7 +301,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert(iter.start); cmc_assert(iter.end); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(iter_start[edge_case:count = 0], { @@ -343,7 +315,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert(s_iter_start(&iter)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(iter_end[edge_case:count = 0], { @@ -357,7 +329,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert(s_iter_end(&iter)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(iteration, { @@ -384,7 +356,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, 40200, total); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(iteration[while loop], { @@ -414,7 +386,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, 40200, total); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(iteration[edge_case:count = 1], { @@ -437,7 +409,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, 20, total); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(iteration[edge_case:count = capacity], { @@ -466,7 +438,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, 2000, total); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(iteration[to_start = it_start and to_end = it_end], { @@ -501,7 +473,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(bool, it1.start, it2.start); cmc_assert_equals(bool, it1.end, it2.end); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(iteration[boundaries:count = 0], { @@ -520,7 +492,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(bool, false, s_iter_prev(&iter)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(iteration[boundaries:count > 0], { @@ -542,7 +514,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(bool, false, s_iter_prev(&iter)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(iter_value[edge_case:count = 0], { @@ -556,7 +528,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, s_impl_default_value(), s_iter_value(&iter)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(iter_rvalue[edge_case:count = 0], { @@ -570,7 +542,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(ptr, NULL, s_iter_rvalue(&iter)); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(index, { @@ -609,7 +581,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, 90, total); - s_free(s); + s_free(s, NULL); }); CMC_CREATE_TEST(index[edge_case:count = 0], { @@ -622,7 +594,7 @@ CMC_CREATE_UNIT(stack_test, true, { cmc_assert_equals(size_t, 0, s_iter_index(&iter)); - s_free(s); + s_free(s, NULL); }); }); diff --git a/tests/main/unt/treemap.c b/tests/main/unt/treemap.c index f2cd02a..34e174f 100644 --- a/tests/main/unt/treemap.c +++ b/tests/main/unt/treemap.c @@ -1,8 +1,11 @@ -#include "utl/assert.h" -#include "utl/test.h" -#include "../src/treemap.c" - #include "utl.c" +#include +#include +#include + +#include + +CMC_GENERATE_TREEMAP(tm, treemap, size_t, size_t) CMC_CREATE_UNIT(treemap_test, true, { CMC_CREATE_TEST(new, { @@ -10,7 +13,7 @@ CMC_CREATE_UNIT(treemap_test, true, { cmc_assert_not_equals(ptr, NULL, map); - tm_free(map); + tm_free(map, NULL); }); CMC_CREATE_TEST(clear[count], { @@ -23,12 +26,12 @@ CMC_CREATE_UNIT(treemap_test, true, { cmc_assert_equals(size_t, 50, tm_count(map)); - tm_clear(map); + tm_clear(map, NULL); cmc_assert_equals(size_t, 0, tm_count(map)); cmc_assert_equals(ptr, NULL, map->root); - tm_free(map); + tm_free(map, NULL); }); }); diff --git a/tests/main/unt/treeset.c b/tests/main/unt/treeset.c index b07d269..f4e32c4 100644 --- a/tests/main/unt/treeset.c +++ b/tests/main/unt/treeset.c @@ -1,8 +1,11 @@ -#include "utl/assert.h" -#include "utl/test.h" -#include "../src/treeset.c" - #include "utl.c" +#include +#include +#include + +#include + +CMC_GENERATE_TREESET(ts, treeset, size_t) CMC_CREATE_UNIT(treeset_test, true, { CMC_CREATE_TEST(new, { @@ -10,7 +13,7 @@ CMC_CREATE_UNIT(treeset_test, true, { cmc_assert_not_equals(ptr, NULL, set); - ts_free(set); + ts_free(set, NULL); }); CMC_CREATE_TEST(clear[count], { @@ -23,12 +26,12 @@ CMC_CREATE_UNIT(treeset_test, true, { cmc_assert_equals(size_t, 50, ts_count(set)); - ts_clear(set); + ts_clear(set, NULL); cmc_assert_equals(size_t, 0, ts_count(set)); cmc_assert_equals(ptr, NULL, set->root); - ts_free(set); + ts_free(set, NULL); }); });