Fast forward changes (read desc)

Freezing tests outside of ./tests/main
Formatting all files in ./src and ./tests except for ./tests/codecov
Created makefile for automated code formatting using clang-format
Now bidimap and deque operate with Functions Tables

tests/main/unt/bidimap.c

@@ -7,23 +7,21 @@
 
 CMC_GENERATE_BIDIMAP(bm, bidimap, size_t, size_t)
 
-struct bidimap_ftab_key *bm_ftab_key = &(struct bidimap_ftab_key) {
-    .cmp = cmp,
-    .cpy = copy,
-    .str = to_string,
-    .free = custom_free,
-    .hash = hash,
-    .pri = priority
-};
+struct bidimap_ftab_key *bm_ftab_key =
+    &(struct bidimap_ftab_key){ .cmp = cmp,
+                                .cpy = copy,
+                                .str = str,
+                                .free = custom_free,
+                                .hash = hash,
+                                .pri = pri };
 
-struct bidimap_ftab_val *bm_ftab_val = &(struct bidimap_ftab_val) {
-    .cmp = cmp,
-    .cpy = copy,
-    .str = to_string,
-    .free = custom_free,
-    .hash = hash,
-    .pri = priority
-};
+struct bidimap_ftab_val *bm_ftab_val =
+    &(struct bidimap_ftab_val){ .cmp = cmp,
+                                .cpy = copy,
+                                .str = str,
+                                .free = custom_free,
+                                .hash = hash,
+                                .pri = pri };
 
 CMC_CREATE_UNIT(bidimap_test, true, {
     CMC_CREATE_TEST(new, {
@@ -50,13 +48,13 @@ CMC_CREATE_UNIT(bidimap_test, true, {
     });
 
     CMC_CREATE_TEST(new_custom, {
-        struct bidimap *map = bm_new_custom(100, 0.6, bm_ftab_key, bm_ftab_val,
-                                            &(struct cmc_alloc_node){
-                                                .malloc = malloc,
-                                                .calloc = calloc,
-                                                .realloc = realloc,
-                                                .free = free},
-                                            &(struct cmc_callbacks_bidimap){0});
+        struct bidimap *map =
+            bm_new_custom(100, 0.6, bm_ftab_key, bm_ftab_val,
+                          &(struct cmc_alloc_node){ .malloc = malloc,
+                                                    .calloc = calloc,
+                                                    .realloc = realloc,
+                                                    .free = free },
+                          &(struct cmc_callbacks_bidimap){ 0 });
 
         cmc_assert_not_equals(ptr, NULL, map);
 
@@ -64,13 +62,13 @@ CMC_CREATE_UNIT(bidimap_test, true, {
     });
 
     CMC_CREATE_TEST(new_custom[insert remove], {
-        struct bidimap *map = bm_new_custom(500, 0.6, bm_ftab_key, bm_ftab_val,
-                                            &(struct cmc_alloc_node){
-                                                .malloc = malloc,
-                                                .calloc = calloc,
-                                                .realloc = realloc,
-                                                .free = free},
-                                            &(struct cmc_callbacks_bidimap){0});
+        struct bidimap *map =
+            bm_new_custom(500, 0.6, bm_ftab_key, bm_ftab_val,
+                          &(struct cmc_alloc_node){ .malloc = malloc,
+                                                    .calloc = calloc,
+                                                    .realloc = realloc,
+                                                    .free = free },
+                          &(struct cmc_callbacks_bidimap){ 0 });
 
         cmc_assert_not_equals(ptr, NULL, map);
 
@@ -233,13 +231,13 @@ CMC_CREATE_UNIT(bidimap_test, true, {
     });
 
     CMC_CREATE_TEST(remove_by_key[cleanup custom], {
-        struct bidimap *map = bm_new_custom(10000, 0.6, bm_ftab_key, bm_ftab_val,
-                                            &(struct cmc_alloc_node){
-                                                .malloc = malloc,
-                                                .calloc = calloc,
-                                                .realloc = realloc,
-                                                .free = free},
-                                            &(struct cmc_callbacks_bidimap){0});
+        struct bidimap *map =
+            bm_new_custom(10000, 0.6, bm_ftab_key, bm_ftab_val,
+                          &(struct cmc_alloc_node){ .malloc = malloc,
+                                                    .calloc = calloc,
+                                                    .realloc = realloc,
+                                                    .free = free },
+                          &(struct cmc_callbacks_bidimap){ 0 });
 
         cmc_assert_not_equals(ptr, NULL, map);
 
@@ -258,21 +256,21 @@ CMC_CREATE_UNIT(bidimap_test, true, {
             struct bidimap_entry *k = map->key_buffer[i];
             struct bidimap_entry *v = map->val_buffer[i];
 
-            cmc_assert((k == NULL || k == CMC_ENTRY_DELETED)
-                    && (v == NULL || v == CMC_ENTRY_DELETED));
+            cmc_assert((k == NULL || k == CMC_ENTRY_DELETED) &&
+                       (v == NULL || v == CMC_ENTRY_DELETED));
         }
 
         bm_free(map);
     });
 
     CMC_CREATE_TEST(remove_by_val[cleanup custom], {
-        struct bidimap *map = bm_new_custom(10000, 0.6, bm_ftab_key, bm_ftab_val,
-                                            &(struct cmc_alloc_node){
-                                                .malloc = malloc,
-                                                .calloc = calloc,
-                                                .realloc = realloc,
-                                                .free = free},
-                                            &(struct cmc_callbacks_bidimap){0});
+        struct bidimap *map =
+            bm_new_custom(10000, 0.6, bm_ftab_key, bm_ftab_val,
+                          &(struct cmc_alloc_node){ .malloc = malloc,
+                                                    .calloc = calloc,
+                                                    .realloc = realloc,
+                                                    .free = free },
+                          &(struct cmc_callbacks_bidimap){ 0 });
 
         cmc_assert_not_equals(ptr, NULL, map);
 
@@ -291,7 +289,8 @@ CMC_CREATE_UNIT(bidimap_test, true, {
             struct bidimap_entry *k = map->key_buffer[i];
             struct bidimap_entry *v = map->val_buffer[i];
 
-            cmc_assert((k == NULL || k == CMC_ENTRY_DELETED) && (v == NULL || v == CMC_ENTRY_DELETED));
+            cmc_assert((k == NULL || k == CMC_ENTRY_DELETED) &&
+                       (v == NULL || v == CMC_ENTRY_DELETED));
         }
 
         bm_free(map);

tests/main/unt/deque.c

@@ -7,32 +7,40 @@
 
 CMC_GENERATE_DEQUE(d, deque, size_t)
 
+struct deque_ftab_val *d_ftab_val =
+    &(struct deque_ftab_val){ .cmp = cmp,
+                              .cpy = copy,
+                              .str = str,
+                              .free = custom_free,
+                              .hash = hash,
+                              .pri = pri };
+
 CMC_CREATE_UNIT(deque_test, true, {
     CMC_CREATE_TEST(new, {
-        struct deque *d = d_new(1000000);
+        struct deque *d = d_new(1000000, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
         cmc_assert_not_equals(ptr, NULL, d->buffer);
         cmc_assert_equals(size_t, 1000000, d->capacity);
         cmc_assert_equals(size_t, 0, d_count(d));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(new[capacity = 0], {
-        struct deque *d = d_new(0);
+        struct deque *d = d_new(0, d_ftab_val);
 
         cmc_assert_equals(ptr, NULL, d);
     });
 
     CMC_CREATE_TEST(new[capacity = UINT64_MAX], {
-        struct deque *d = d_new(UINT64_MAX);
+        struct deque *d = d_new(UINT64_MAX, d_ftab_val);
 
         cmc_assert_equals(ptr, NULL, d);
     });
 
     CMC_CREATE_TEST(clear[count capacity], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -41,16 +49,16 @@ CMC_CREATE_UNIT(deque_test, true, {
 
         cmc_assert_equals(size_t, 50, d_count(d));
 
-        d_clear(d, NULL);
+        d_clear(d);
 
         cmc_assert_equals(size_t, 0, d_count(d));
         cmc_assert_equals(size_t, 100, d_capacity(d));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(buffer_growth[capacity = 1], {
-        struct deque *d = d_new(1);
+        struct deque *d = d_new(1, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -60,11 +68,11 @@ 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, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(buffer_growth[item preservation], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -77,17 +85,18 @@ CMC_CREATE_UNIT(deque_test, true, {
         }
 
         size_t sum = 0;
-        for (size_t i = d->front, j = 0; j < d->count; i = (i + 1) % d->capacity, j++)
+        for (size_t i = d->front, j = 0; j < d->count;
+             i = (i + 1) % d->capacity, j++)
             sum += d->buffer[i];
 
         cmc_assert_equals(size_t, 1200, d_count(d));
         cmc_assert_equals(size_t, 720600, sum);
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(push_front[count capacity], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -97,11 +106,11 @@ CMC_CREATE_UNIT(deque_test, true, {
         cmc_assert_equals(size_t, 150, d_count(d));
         cmc_assert_greater(size_t, 100, d_capacity(d));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(push_front[item preservation], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -110,18 +119,19 @@ CMC_CREATE_UNIT(deque_test, true, {
 
         size_t sum = 0;
 
-        for (size_t i = d->front, j = 0; j < d->count; i = (i + 1) % d->capacity, j++)
+        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);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(push_back[count capacity], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -131,11 +141,11 @@ CMC_CREATE_UNIT(deque_test, true, {
         cmc_assert_equals(size_t, 150, d_count(d));
         cmc_assert_greater(size_t, 100, d_capacity(d));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(push_back[item preservation], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -144,18 +154,19 @@ CMC_CREATE_UNIT(deque_test, true, {
 
         size_t sum = 0;
 
-        for (size_t i = d->front, j = 0; j < d->count; i = (i + 1) % d->capacity, j++)
+        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);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(pop_front[count capacity], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -169,11 +180,11 @@ CMC_CREATE_UNIT(deque_test, true, {
 
         cmc_assert_equals(size_t, 0, d_count(d));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(pop_front[item preservation], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -185,18 +196,19 @@ CMC_CREATE_UNIT(deque_test, true, {
 
         size_t sum = 0;
 
-        for (size_t i = d->front, j = 0; j < d->count; i = (i + 1) % d->capacity, j++)
+        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);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(pop_back[count capacity], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -210,11 +222,11 @@ CMC_CREATE_UNIT(deque_test, true, {
 
         cmc_assert_equals(size_t, 0, d_count(d));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(pop_back[item preservation], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -226,18 +238,19 @@ CMC_CREATE_UNIT(deque_test, true, {
 
         size_t sum = 0;
 
-        for (size_t i = d->front, j = 0; j < d->count; i = (i + 1) % d->capacity, j++)
+        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);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(Mixed IO, {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -297,23 +310,23 @@ CMC_CREATE_UNIT(deque_test, true, {
 
         cmc_assert_equals(size_t, 0, d_count(d));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(front[count = 0], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
         size_t r = d_front(d);
 
-        cmc_assert_equals(size_t, (size_t){0}, r);
+        cmc_assert_equals(size_t, (size_t){ 0 }, r);
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(front[sum], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -338,23 +351,23 @@ CMC_CREATE_UNIT(deque_test, true, {
 
         cmc_assert_equals(size_t, 5050, sum);
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(back[count = 0], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
         size_t r = d_back(d);
 
-        cmc_assert_equals(size_t, (size_t){0}, r);
+        cmc_assert_equals(size_t, (size_t){ 0 }, r);
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(back[sum], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -379,11 +392,11 @@ CMC_CREATE_UNIT(deque_test, true, {
 
         cmc_assert_equals(size_t, 5050, sum);
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(contains, {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -391,52 +404,52 @@ CMC_CREATE_UNIT(deque_test, true, {
             cmc_assert(d_push_back(d, i));
 
         for (size_t i = 1; i <= 20; i++)
-            cmc_assert(d_contains(d, i, cmp));
+            cmc_assert(d_contains(d, i));
 
-        d_clear(d, NULL);
+        d_clear(d);
 
         for (size_t i = 1; i <= 20; i++)
             cmc_assert(d_push_front(d, i));
 
         for (size_t i = 1; i <= 20; i++)
-            cmc_assert(d_contains(d, i, cmp));
+            cmc_assert(d_contains(d, i));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(contains[count = 0], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
-        cmc_assert(!d_contains(d, 10, cmp));
+        cmc_assert(!d_contains(d, 10));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(contains[count = 1], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
-        cmc_assert(!d_contains(d, 10, cmp));
+        cmc_assert(!d_contains(d, 10));
 
         cmc_assert(d_push_back(d, 100));
 
-        cmc_assert(d_contains(d, 100, cmp));
-        cmc_assert(!d_contains(d, 101, cmp));
+        cmc_assert(d_contains(d, 100));
+        cmc_assert(!d_contains(d, 101));
 
         cmc_assert(d_pop_front(d));
         cmc_assert(d_push_front(d, 100));
 
-        cmc_assert(d_contains(d, 100, cmp));
-        cmc_assert(!d_contains(d, 101, cmp));
+        cmc_assert(d_contains(d, 100));
+        cmc_assert(!d_contains(d, 101));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(empty, {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -446,11 +459,11 @@ CMC_CREATE_UNIT(deque_test, true, {
 
         cmc_assert(!d_empty(d));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(full, {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -461,11 +474,11 @@ CMC_CREATE_UNIT(deque_test, true, {
 
         cmc_assert(d_full(d));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(count, {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -476,21 +489,21 @@ CMC_CREATE_UNIT(deque_test, true, {
 
         cmc_assert_equals(size_t, 100, d_count(d));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(capacity, {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
         cmc_assert_equals(size_t, 100, d_capacity(d));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(resize, {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -506,11 +519,11 @@ CMC_CREATE_UNIT(deque_test, true, {
         cmc_assert(d_resize(d, d_count(d)));
         cmc_assert_equals(size_t, 150, d_capacity(d));
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(resize[item preservation], {
-        struct deque *d = d_new(100);
+        struct deque *d = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d);
 
@@ -526,18 +539,19 @@ CMC_CREATE_UNIT(deque_test, true, {
 
         size_t sum = 0;
 
-        for (size_t i = d->front, j = 0; j < d->count; i = (i + 1) % d->capacity, j++)
+        for (size_t i = d->front, j = 0; j < d->count;
+             i = (i + 1) % d->capacity, j++)
         {
             sum += d->buffer[i];
         }
 
         cmc_assert_equals(size_t, 11325, sum);
 
-        d_free(d, NULL);
+        d_free(d);
     });
 
     CMC_CREATE_TEST(copy_of, {
-        struct deque *d1 = d_new(100);
+        struct deque *d1 = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d1);
 
@@ -549,7 +563,7 @@ CMC_CREATE_UNIT(deque_test, true, {
                 cmc_assert(d_push_front(d1, i));
         }
 
-        struct deque *d2 = d_copy_of(d1, NULL);
+        struct deque *d2 = d_copy_of(d1);
 
         cmc_assert_not_equals(ptr, NULL, d2);
         cmc_assert_equals(size_t, d_count(d1), d_count(d2));
@@ -562,13 +576,20 @@ CMC_CREATE_UNIT(deque_test, true, {
             i2 = (i2 + 1) % d2->capacity;
         }
 
-        d_free(d1, NULL);
-        d_free(d2, NULL);
+        cmc_assert(d_push_front(d1, 10));
+        cmc_assert(d_push_front(d2, 10));
+        cmc_assert(d_push_back(d1, 11));
+        cmc_assert(d_push_back(d2, 11));
+
+        cmc_assert(d_equals(d1, d2));
+
+        d_free(d1);
+        d_free(d2);
     });
 
     CMC_CREATE_TEST(equals, {
-        struct deque *d1 = d_new(100);
-        struct deque *d2 = d_new(100);
+        struct deque *d1 = d_new(100, d_ftab_val);
+        struct deque *d2 = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d1);
         cmc_assert_not_equals(ptr, NULL, d2);
@@ -587,14 +608,14 @@ CMC_CREATE_UNIT(deque_test, true, {
             }
         }
 
-        cmc_assert(d_equals(d1, d2, cmp));
+        cmc_assert(d_equals(d1, d2));
 
-        d_free(d1, NULL);
-        d_free(d2, NULL);
+        d_free(d1);
+        d_free(d2);
     });
 
     CMC_CREATE_TEST(equals[from copy], {
-        struct deque *d1 = d_new(100);
+        struct deque *d1 = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d1);
 
@@ -606,28 +627,28 @@ CMC_CREATE_UNIT(deque_test, true, {
                 cmc_assert(d_push_front(d1, i));
         }
 
-        struct deque *d2 = d_copy_of(d1, NULL);
+        struct deque *d2 = d_copy_of(d1);
 
         cmc_assert_not_equals(ptr, NULL, d2);
 
-        cmc_assert(d_equals(d1, d2, cmp));
+        cmc_assert(d_equals(d1, d2));
 
-        d_free(d1, NULL);
-        d_free(d2, NULL);
+        d_free(d1);
+        d_free(d2);
     });
 
     CMC_CREATE_TEST(equals[count = 0], {
-        struct deque *d1 = d_new(100);
+        struct deque *d1 = d_new(100, d_ftab_val);
 
         cmc_assert_not_equals(ptr, NULL, d1);
 
-        struct deque *d2 = d_copy_of(d1, NULL);
+        struct deque *d2 = d_copy_of(d1);
 
         cmc_assert_not_equals(ptr, NULL, d2);
 
-        cmc_assert(d_equals(d1, d2, cmp));
+        cmc_assert(d_equals(d1, d2));
 
-        d_free(d1, NULL);
-        d_free(d2, NULL);
+        d_free(d1);
+        d_free(d2);
     });
 });

tests/main/unt/hashmap.c

@@ -97,7 +97,8 @@ CMC_CREATE_UNIT(hashmap_test, true, {
         for (size_t i = 0; i < 200; i++)
             cmc_assert(hm_insert(map, i, i));
 
-        // Everything is hashed to 0 so key 0 should have dist 0, key 1 dist 1, etc
+        // Everything is hashed to 0 so key 0 should have dist 0, key 1 dist 1,
+        // etc
         for (size_t i = 0; i < 200; i++)
             cmc_assert_equals(size_t, i, map->buffer[i].dist);
 
@@ -112,7 +113,8 @@ CMC_CREATE_UNIT(hashmap_test, true, {
         size_t capacity = hm_capacity(map);
 
         // Just to be sure, not part of the test
-        cmc_assert_equals(size_t, cmc_hashtable_primes[0] - 1, hashcapminus1(0));
+        cmc_assert_equals(size_t, cmc_hashtable_primes[0] - 1,
+                          hashcapminus1(0));
         cmc_assert_equals(size_t, capacity - 1, hashcapminus1(0));
 
         cmc_assert(hm_insert(map, 0, 0));
@@ -304,7 +306,7 @@ CMC_CREATE_UNIT(hashmap_test, true, {
 
         cmc_assert_not_equals(ptr, NULL, map);
 
-        cmc_assert_equals(size_t, (size_t){0}, hm_get(map, 4321));
+        cmc_assert_equals(size_t, (size_t){ 0 }, hm_get(map, 4321));
 
         hm_free(map, NULL);
     });
@@ -389,7 +391,8 @@ CMC_CREATE_UNIT(hashmap_test, true, {
     });
 
     CMC_CREATE_TEST(full, {
-        struct hashmap *map = hm_new(cmc_hashtable_primes[0], 0.99999, cmp, hash);
+        struct hashmap *map =
+            hm_new(cmc_hashtable_primes[0], 0.99999, cmp, hash);
 
         cmc_assert_not_equals(ptr, NULL, map);
 
@@ -428,7 +431,8 @@ CMC_CREATE_UNIT(hashmap_test, true, {
 
         cmc_assert_not_equals(ptr, NULL, map);
 
-        cmc_assert_greater_equals(size_t, (size_t)(2500 / 0.6), hm_capacity(map));
+        cmc_assert_greater_equals(size_t, (size_t)(2500 / 0.6),
+                                  hm_capacity(map));
 
         hm_free(map, NULL);
     });

tests/main/unt/hashset.c

@@ -83,7 +83,8 @@ CMC_CREATE_UNIT(hashset_test, true, {
         cmc_assert(hs_insert(set, capacity - 1));
         cmc_assert(hs_insert(set, capacity));
 
-        cmc_assert_equals(size_t, capacity - 1, set->buffer[capacity - 1].value);
+        cmc_assert_equals(size_t, capacity - 1,
+                          set->buffer[capacity - 1].value);
         cmc_assert_equals(size_t, capacity, set->buffer[0].value);
 
         hs_free(set, NULL);
@@ -97,7 +98,8 @@ CMC_CREATE_UNIT(hashset_test, true, {
         for (size_t i = 0; i < 200; i++)
             cmc_assert(hs_insert(set, i));
 
-        // Everything is hashed to 0 so key 0 should have dist 0, key 1 dist 1, etc
+        // Everything is hashed to 0 so key 0 should have dist 0, key 1 dist 1,
+        // etc
         for (size_t i = 0; i < 200; i++)
             cmc_assert_equals(size_t, i, set->buffer[i].dist);
 
@@ -112,7 +114,8 @@ CMC_CREATE_UNIT(hashset_test, true, {
         size_t capacity = hs_capacity(set);
 
         // Just to be sure, not part of the test
-        cmc_assert_equals(size_t, cmc_hashtable_primes[0] - 1, hashcapminus1(0));
+        cmc_assert_equals(size_t, cmc_hashtable_primes[0] - 1,
+                          hashcapminus1(0));
         cmc_assert_equals(size_t, capacity - 1, hashcapminus1(0));
 
         cmc_assert(hs_insert(set, 0));
@@ -294,7 +297,8 @@ CMC_CREATE_UNIT(hashset_test, true, {
     });
 
     CMC_CREATE_TEST(full, {
-        struct hashset *set = hs_new(cmc_hashtable_primes[0], 0.99999, cmp, hash);
+        struct hashset *set =
+            hs_new(cmc_hashtable_primes[0], 0.99999, cmp, hash);
 
         cmc_assert_not_equals(ptr, NULL, set);
 
@@ -333,7 +337,8 @@ CMC_CREATE_UNIT(hashset_test, true, {
 
         cmc_assert_not_equals(ptr, NULL, set);
 
-        cmc_assert_greater_equals(size_t, (size_t)(2500 / 0.6), hs_capacity(set));
+        cmc_assert_greater_equals(size_t, (size_t)(2500 / 0.6),
+                                  hs_capacity(set));
 
         hs_free(set, NULL);
     });

tests/main/unt/heap.c

@@ -157,7 +157,7 @@ CMC_CREATE_UNIT(heap_test, true, {
 
         cmc_assert_not_equals(ptr, NULL, h);
 
-        cmc_assert_equals(size_t, (size_t){0}, h_peek(h));
+        cmc_assert_equals(size_t, (size_t){ 0 }, h_peek(h));
 
         h_free(h, NULL);
     });

tests/main/unt/multiset.c

@@ -14,7 +14,8 @@ CMC_CREATE_UNIT(multiset_test, true, {
         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));
+        cmc_assert_greater_equals(size_t, ((size_t)(943722 / 0.6)),
+                                  ms_capacity(set));
 
         ms_free(set, NULL);
     });

tests/main/unt/queue.c

@@ -74,7 +74,8 @@ CMC_CREATE_UNIT(queue_test, true, {
         }
 
         size_t sum = 0;
-        for (size_t i = q->front, j = 0; j < q->count; i = (i + 1) % q->capacity, j++)
+        for (size_t i = q->front, j = 0; j < q->count;
+             i = (i + 1) % q->capacity, j++)
             sum += q->buffer[i];
 
         cmc_assert_equals(size_t, 1200, q_count(q));
@@ -107,7 +108,8 @@ CMC_CREATE_UNIT(queue_test, true, {
 
         size_t sum = 0;
 
-        for (size_t i = q->front, j = 0; j < q->count; i = (i + 1) % q->capacity, j++)
+        for (size_t i = q->front, j = 0; j < q->count;
+             i = (i + 1) % q->capacity, j++)
         {
             sum += q->buffer[i];
         }
@@ -148,7 +150,8 @@ CMC_CREATE_UNIT(queue_test, true, {
 
         size_t sum = 0;
 
-        for (size_t i = q->front, j = 0; j < q->count; i = (i + 1) % q->capacity, j++)
+        for (size_t i = q->front, j = 0; j < q->count;
+             i = (i + 1) % q->capacity, j++)
         {
             sum += q->buffer[i];
         }
@@ -165,7 +168,7 @@ CMC_CREATE_UNIT(queue_test, true, {
 
         size_t r = q_peek(q);
 
-        cmc_assert_equals(size_t, (size_t){0}, r);
+        cmc_assert_equals(size_t, (size_t){ 0 }, r);
 
         q_free(q, NULL);
     });
@@ -319,7 +322,8 @@ CMC_CREATE_UNIT(queue_test, true, {
 
         size_t sum = 0;
 
-        for (size_t i = q->front, j = 0; j < q->count; i = (i + 1) % q->capacity, j++)
+        for (size_t i = q->front, j = 0; j < q->count;
+             i = (i + 1) % q->capacity, j++)
         {
             sum += q->buffer[i];
         }

tests/main/unt/stack.c

@@ -186,7 +186,7 @@ CMC_CREATE_UNIT(stack_test, true, {
 
         cmc_assert(s_pop(s));
 
-        cmc_assert_equals(size_t, (size_t){0}, s_top(s));
+        cmc_assert_equals(size_t, (size_t){ 0 }, s_top(s));
 
         s_free(s, NULL);
     });
@@ -342,14 +342,16 @@ CMC_CREATE_UNIT(stack_test, true, {
 
         size_t total = 0;
 
-        for (struct stack_iter it = s->it_start(s); !s_iter_end(&it); s_iter_next(&it))
+        for (struct stack_iter it = s->it_start(s); !s_iter_end(&it);
+             s_iter_next(&it))
         {
             total += s_iter_value(&it);
         }
 
         cmc_assert_equals(size_t, 20100, total);
 
-        for (struct stack_iter it = s->it_end(s); !s_iter_start(&it); s_iter_prev(&it))
+        for (struct stack_iter it = s->it_end(s); !s_iter_start(&it);
+             s_iter_prev(&it))
         {
             total += s_iter_value(&it);
         }
@@ -397,12 +399,14 @@ CMC_CREATE_UNIT(stack_test, true, {
 
         size_t total = 0;
 
-        for (struct stack_iter it = s->it_start(s); !s_iter_end(&it); s_iter_next(&it))
+        for (struct stack_iter it = s->it_start(s); !s_iter_end(&it);
+             s_iter_next(&it))
         {
             total += s_iter_value(&it);
         }
 
-        for (struct stack_iter it = s->it_end(s); !s_iter_start(&it); s_iter_prev(&it))
+        for (struct stack_iter it = s->it_end(s); !s_iter_start(&it);
+             s_iter_prev(&it))
         {
             total += s_iter_value(&it);
         }
@@ -424,14 +428,16 @@ CMC_CREATE_UNIT(stack_test, true, {
 
         size_t total = 0;
 
-        for (struct stack_iter it = s->it_start(s); !s_iter_end(&it); s_iter_next(&it))
+        for (struct stack_iter it = s->it_start(s); !s_iter_end(&it);
+             s_iter_next(&it))
         {
             total += s_iter_value(&it);
         }
 
         cmc_assert_equals(size_t, 1000, total);
 
-        for (struct stack_iter it = s->it_end(s); !s_iter_start(&it); s_iter_prev(&it))
+        for (struct stack_iter it = s->it_end(s); !s_iter_start(&it);
+             s_iter_prev(&it))
         {
             total += *s_iter_rvalue(&it);
         }
@@ -526,7 +532,7 @@ CMC_CREATE_UNIT(stack_test, true, {
 
         s_iter_init(&iter, s);
 
-        cmc_assert_equals(size_t, (size_t){0}, s_iter_value(&iter));
+        cmc_assert_equals(size_t, (size_t){ 0 }, s_iter_value(&iter));
 
         s_free(s, NULL);
     });
@@ -567,14 +573,16 @@ CMC_CREATE_UNIT(stack_test, true, {
             cmc_assert_equals(size_t, s_count(s) - 1, s_iter_index(&it));
         }
 
-        for (struct stack_iter it = s->it_start(s); !s_iter_end(&it); s_iter_next(&it))
+        for (struct stack_iter it = s->it_start(s); !s_iter_end(&it);
+             s_iter_next(&it))
         {
             total += s_iter_index(&it);
         }
 
         cmc_assert_equals(size_t, 45, total);
 
-        for (struct stack_iter it = s->it_end(s); !s_iter_start(&it); s_iter_prev(&it))
+        for (struct stack_iter it = s->it_end(s); !s_iter_start(&it);
+             s_iter_prev(&it))
         {
             total += s_iter_index(&it);
         }

tests/main/unt/utl.c

@@ -2,9 +2,10 @@
 #ifndef CMC_UNIT_TEST_UTL__
 #define CMC_UNIT_TEST_UTL__
 
-#include <stdlib.h>
-#include <inttypes.h>
 #include <cmc/hashmap.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdlib.h>
 
 int cmp(size_t a, size_t b)
 {
@@ -16,7 +17,7 @@ size_t copy(size_t a)
     return a;
 }
 
-bool to_string(FILE *fptr, size_t a)
+bool str(FILE *fptr, size_t a)
 {
     return fprintf(fptr, "%" PRIuMAX " ", a) > 0;
 }
@@ -38,7 +39,7 @@ size_t hash(size_t a)
     return a;
 }
 
-int priority(size_t a, size_t b)
+int pri(size_t a, size_t b)
 {
     // Could contain different logic
     return cmp(a, b);