Redone tests

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

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__ */