Redone tests

./codecov is a stalled version for code coverage. It will be merged with main when the library is done with breaking changes

.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)

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;

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:

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().

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;
+}

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);
+    });
+
+});

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);
+    });
+
+});

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);
+    });
+
+});

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);
+    });
+
+});

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);
+    });
+
+});

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);
+    });
+})

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);
+    });
+
+});

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);
+    });
+
+});

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);
+    });
+
+});

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);
+    });
+
+});

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);
+    });
+
+});

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);
+    });
+
+});

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 <stdlib.h>
+
+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__ */

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:

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.

tests/main/main.c

@@ -1,3 +1,5 @@
+#include <utl/timer.h>
+
 #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;
 }

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 <utl/assert.h>
+#include <utl/log.h>
+#include <utl/test.h>
+
+#include <cmc/deque.h>
+
+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);
+    });
 });

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 <utl/assert.h>
+#include <utl/log.h>
+#include <utl/test.h>
+
+#include <cmc/hashmap.h>
+
+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);
     });
 
 });

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 <utl/assert.h>
+#include <utl/log.h>
+#include <utl/test.h>
+
+#include <cmc/hashset.h>
+
+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);
     });
 
 });

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 <utl/assert.h>
+#include <utl/log.h>
+#include <utl/test.h>
+
+#include <cmc/heap.h>
+
+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);
     });
 
 });

tests/main/unt/intervalheap.c

@@ -0,0 +1,70 @@
+#include "utl.c"
+#include <utl/assert.h>
+#include <utl/log.h>
+#include <utl/test.h>
+
+#include <ext/intervalheap.h>
+
+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);
+    });
+});

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 <utl/assert.h>
+#include <utl/log.h>
+#include <utl/test.h>
+
+#include <cmc/linkedlist.h>
+
+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);
     });
 
 });

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 <utl/assert.h>
+#include <utl/log.h>
+#include <utl/test.h>
+
+#include <cmc/list.h>
+
+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);
     });
 })

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 <utl/assert.h>
+#include <utl/log.h>
+#include <utl/test.h>
+
+#include <ext/multimap.h>
+
+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);
     });
 
 });

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 <utl/assert.h>
+#include <utl/log.h>
+#include <utl/test.h>
+
+#include <ext/multiset.h>
+
+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);
     });
 
 });

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 <utl/assert.h>
+#include <utl/log.h>
+#include <utl/test.h>
+
+#include <cmc/queue.h>
+
+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);
     });
 
 });

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 <utl/assert.h>
+#include <utl/log.h>
+#include <utl/test.h>
+
+#include <cmc/stack.h>
+
+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);
     });
 
 });

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 <utl/assert.h>
+#include <utl/log.h>
+#include <utl/test.h>
+
+#include <cmc/treemap.h>
+
+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);
     });
 
 });

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 <utl/assert.h>
+#include <utl/log.h>
+#include <utl/test.h>
+
+#include <cmc/treeset.h>
+
+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);
     });
 
 });