Added callbacks to multimap and multiset, removed enabled flag and more

The enabled flag from the previous commit was removed because it seemed pointless
PFX##_customize functions were changed, now callbacks can be NULL but not allloc_node
Added more code to callback test
Added some missing functions and changed some others
Added more TODO comments of missing code checks or possible improvements
Added more callback guards for set functions

tests/main/unt/bidimap.c

@@ -543,6 +543,8 @@ CMC_CREATE_UNIT(bidimap_test, true, {
         cmc_assert_equals(int32_t, 2, total_delete);
 
         cmc_assert(bm_insert(map, 1, 2));
+        cmc_assert_equals(int32_t, 3, total_create);
+
         cmc_assert_equals(size_t, 1, bm_get_key(map, 2));
         cmc_assert_equals(int32_t, 1, total_read);
 
@@ -561,6 +563,39 @@ CMC_CREATE_UNIT(bidimap_test, true, {
         cmc_assert(bm_contains_val(map, 2));
         cmc_assert_equals(int32_t, 4, total_read);
 
+        cmc_assert_equals(int32_t, 3, total_create);
+        cmc_assert_equals(int32_t, 4, total_read);
+        cmc_assert_equals(int32_t, 2, total_update);
+        cmc_assert_equals(int32_t, 2, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        bm_customize(map, NULL, NULL);
+
+        cmc_assert_equals(ptr, NULL, map->callbacks);
+
+        bm_clear(map);
+        cmc_assert(bm_insert(map, 10, 10));
+        cmc_assert(bm_update_key(map, 10, 5));
+        cmc_assert(bm_update_val(map, 5, 5));
+        cmc_assert(bm_insert(map, 10, 10));
+        cmc_assert(bm_remove_by_key(map, 5, NULL, NULL));
+        cmc_assert(bm_remove_by_val(map, 10, NULL, NULL));
+        cmc_assert(bm_insert(map, 1, 2));
+        cmc_assert_equals(size_t, 1, bm_get_key(map, 2));
+        cmc_assert_equals(size_t, 2, bm_get_val(map, 1));
+        cmc_assert(bm_resize(map, 1000));
+        cmc_assert(bm_resize(map, 200));
+        cmc_assert(bm_contains_key(map, 1));
+        cmc_assert(bm_contains_val(map, 2));
+
+        cmc_assert_equals(int32_t, 3, total_create);
+        cmc_assert_equals(int32_t, 4, total_read);
+        cmc_assert_equals(int32_t, 2, total_update);
+        cmc_assert_equals(int32_t, 2, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(ptr, NULL, map->callbacks);
+
         bm_free(map);
     });
 });

tests/main/unt/deque.c

@@ -772,6 +772,44 @@ CMC_CREATE_UNIT(deque_test, true, {
         cmc_assert(!d_contains(d, 1));
         cmc_assert_equals(int32_t, 4, total_read);
 
+        cmc_assert(d_resize(d, 1000));
+        cmc_assert_equals(int32_t, 1, total_resize);
+
+        cmc_assert(d_resize(d, 10));
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(int32_t, 4, total_create);
+        cmc_assert_equals(int32_t, 4, total_read);
+        cmc_assert_equals(int32_t, 0, total_update);
+        cmc_assert_equals(int32_t, 2, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        d_customize(d, NULL, NULL);
+
+        cmc_assert_equals(ptr, NULL, d->callbacks);
+
+        d_clear(d);
+        cmc_assert(d_push_front(d, 10));
+        cmc_assert(d_push_back(d, 10));
+        cmc_assert(d_pop_front(d));
+        cmc_assert(d_pop_back(d));
+        cmc_assert(d_push_front(d, 10));
+        cmc_assert(d_push_front(d, 5));
+        cmc_assert_equals(size_t, 5, d_front(d));
+        cmc_assert_equals(size_t, 10, d_back(d));
+        cmc_assert(d_contains(d, 10));
+        cmc_assert(!d_contains(d, 1));
+        cmc_assert(d_resize(d, 1000));
+        cmc_assert(d_resize(d, 10));
+
+        cmc_assert_equals(int32_t, 4, total_create);
+        cmc_assert_equals(int32_t, 4, total_read);
+        cmc_assert_equals(int32_t, 0, total_update);
+        cmc_assert_equals(int32_t, 2, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(ptr, NULL, d->callbacks);
+
         d_free(d);
     });
 });

tests/main/unt/hashmap.c

@@ -640,6 +640,43 @@ CMC_CREATE_UNIT(hashmap_test, true, {
         cmc_assert(hm_contains(map, 1));
         cmc_assert_equals(int32_t, 5, total_read);
 
+        cmc_assert(hm_resize(map, 10000));
+        cmc_assert_equals(int32_t, 1, total_resize);
+
+        cmc_assert(hm_resize(map, 500));
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(int32_t, 2, total_create);
+        cmc_assert_equals(int32_t, 5, total_read);
+        cmc_assert_equals(int32_t, 1, total_update);
+        cmc_assert_equals(int32_t, 1, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        hm_customize(map, NULL, NULL);
+
+        cmc_assert_equals(ptr, NULL, map->callbacks);
+
+        hm_clear(map);
+        cmc_assert(hm_insert(map, 1, 2));
+        cmc_assert(hm_update(map, 1, 10, NULL));
+        cmc_assert(hm_remove(map, 1, NULL));
+        cmc_assert(hm_insert(map, 1, 2));
+        cmc_assert(hm_max(map, NULL, NULL));
+        cmc_assert(hm_min(map, NULL, NULL));
+        cmc_assert_equals(size_t, 2, hm_get(map, 1));
+        cmc_assert_not_equals(ptr, NULL, hm_get_ref(map, 1));
+        cmc_assert(hm_contains(map, 1));
+        cmc_assert(hm_resize(map, 10000));
+        cmc_assert(hm_resize(map, 500));
+
+        cmc_assert_equals(int32_t, 2, total_create);
+        cmc_assert_equals(int32_t, 5, total_read);
+        cmc_assert_equals(int32_t, 1, total_update);
+        cmc_assert_equals(int32_t, 1, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(ptr, NULL, map->callbacks);
+
         hm_free(map);
     });
 });

tests/main/unt/hashset.c

@@ -510,6 +510,40 @@ CMC_CREATE_UNIT(hashset_test, true, {
         cmc_assert(hs_contains(set, 1));
         cmc_assert_equals(int32_t, 3, total_read);
 
+        cmc_assert(hs_resize(set, 10000));
+        cmc_assert_equals(int32_t, 1, total_resize);
+
+        cmc_assert(hs_resize(set, 500));
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(int32_t, 2, total_create);
+        cmc_assert_equals(int32_t, 3, total_read);
+        cmc_assert_equals(int32_t, 0, total_update);
+        cmc_assert_equals(int32_t, 1, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        hs_customize(set, NULL, NULL);
+
+        cmc_assert_equals(ptr, NULL, set->callbacks);
+
+        hs_clear(set);
+        cmc_assert(hs_resize(set, 10000));
+        cmc_assert(hs_resize(set, 500));
+        cmc_assert(hs_insert(set, 1));
+        cmc_assert(hs_remove(set, 1));
+        cmc_assert(hs_insert(set, 1));
+        cmc_assert(hs_max(set, NULL));
+        cmc_assert(hs_min(set, NULL));
+        cmc_assert(hs_contains(set, 1));
+
+        cmc_assert_equals(int32_t, 2, total_create);
+        cmc_assert_equals(int32_t, 3, total_read);
+        cmc_assert_equals(int32_t, 0, total_update);
+        cmc_assert_equals(int32_t, 1, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(ptr, NULL, set->callbacks);
+
         hs_free(set);
     });
 });

tests/main/unt/heap.c

@@ -255,6 +255,33 @@ CMC_CREATE_UNIT(heap_test, true, {
         cmc_assert(h_resize(h, 100));
         cmc_assert_equals(int32_t, 2, total_resize);
 
+        cmc_assert_equals(int32_t, 2, total_create);
+        cmc_assert_equals(int32_t, 2, total_read);
+        cmc_assert_equals(int32_t, 0, total_update);
+        cmc_assert_equals(int32_t, 1, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        h_customize(h, NULL, NULL);
+
+        cmc_assert_equals(ptr, NULL, h->callbacks);
+
+        h_clear(h);
+        cmc_assert(h_insert(h, 10));
+        cmc_assert(h_remove(h));
+        cmc_assert(h_insert(h, 10));
+        cmc_assert_equals(size_t, 10, h_peek(h));
+        cmc_assert(h_contains(h, 10));
+        cmc_assert(h_resize(h, 1000));
+        cmc_assert(h_resize(h, 100));
+
+        cmc_assert_equals(int32_t, 2, total_create);
+        cmc_assert_equals(int32_t, 2, total_read);
+        cmc_assert_equals(int32_t, 0, total_update);
+        cmc_assert_equals(int32_t, 1, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(ptr, NULL, h->callbacks);
+
         h_free(h);
     });
 });

tests/main/unt/intervalheap.c

@@ -308,6 +308,39 @@ CMC_CREATE_UNIT(intervalheap_test, true, {
         cmc_assert(ih_resize(ih, 50));
         cmc_assert_equals(int32_t, 2, total_resize);
 
+        cmc_assert_equals(int32_t, 4, total_create);
+        cmc_assert_equals(int32_t, 3, total_read);
+        cmc_assert_equals(int32_t, 2, total_update);
+        cmc_assert_equals(int32_t, 2, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        ih_customize(ih, NULL, NULL);
+
+        cmc_assert_equals(ptr, NULL, ih->callbacks);
+
+        ih_clear(ih);
+        cmc_assert(ih_insert(ih, 10));
+        cmc_assert(ih_remove_max(ih));
+        cmc_assert(ih_insert(ih, 10));
+        cmc_assert(ih_remove_min(ih));
+        cmc_assert(ih_insert(ih, 1));
+        cmc_assert(ih_insert(ih, 2));
+        cmc_assert(ih_update_max(ih, 1));
+        cmc_assert(ih_update_min(ih, 2));
+        cmc_assert_equals(size_t, 2, ih_max(ih));
+        cmc_assert_equals(size_t, 1, ih_min(ih));
+        cmc_assert(ih_contains(ih, 1));
+        cmc_assert(ih_resize(ih, 1000));
+        cmc_assert(ih_resize(ih, 50));
+
+        cmc_assert_equals(int32_t, 4, total_create);
+        cmc_assert_equals(int32_t, 3, total_read);
+        cmc_assert_equals(int32_t, 2, total_update);
+        cmc_assert_equals(int32_t, 2, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(ptr, NULL, ih->callbacks);
+
         ih_free(ih);
     });
 });

tests/main/unt/linkedlist.c

@@ -302,6 +302,38 @@ CMC_CREATE_UNIT(linkedlist_test, true, {
         cmc_assert(ll_contains(ll, 10));
         cmc_assert_equals(int32_t, 5, total_read);
 
+        cmc_assert_equals(int32_t, 4, total_create);
+        cmc_assert_equals(int32_t, 5, total_read);
+        cmc_assert_equals(int32_t, 0, total_update);
+        cmc_assert_equals(int32_t, 3, total_delete);
+        cmc_assert_equals(int32_t, 0, total_resize);
+
+        ll_customize(ll, NULL, NULL);
+
+        cmc_assert_equals(ptr, NULL, ll->callbacks);
+
+        ll_clear(ll);
+        cmc_assert(ll_push_front(ll, 10));
+        cmc_assert(ll_push_back(ll, 10));
+        cmc_assert(ll_push_at(ll, 10, 1));
+        cmc_assert(ll_pop_at(ll, 1));
+        cmc_assert(ll_pop_front(ll));
+        cmc_assert(ll_pop_back(ll));
+        cmc_assert(ll_push_back(ll, 10));
+        cmc_assert_equals(size_t, 10, ll_front(ll));
+        cmc_assert_equals(size_t, 10, ll_back(ll));
+        cmc_assert_equals(size_t, 10, ll_get(ll, 0));
+        cmc_assert_not_equals(ptr, NULL, ll_get_ref(ll, 0));
+        cmc_assert(ll_contains(ll, 10));
+
+        cmc_assert_equals(int32_t, 4, total_create);
+        cmc_assert_equals(int32_t, 5, total_read);
+        cmc_assert_equals(int32_t, 0, total_update);
+        cmc_assert_equals(int32_t, 3, total_delete);
+        cmc_assert_equals(int32_t, 0, total_resize);
+
+        cmc_assert_equals(ptr, NULL, ll->callbacks);
+
         ll_free(ll);
     });
 });

tests/main/unt/list.c

@@ -542,13 +542,13 @@ CMC_CREATE_UNIT(list_test, true, {
         cmc_assert(l_contains(l, 10));
         cmc_assert_equals(int32_t, 5, total_read);
 
-        cmc_assert(l_seq_push_front(l, (size_t[]) {7, 8, 9}, 3));
+        cmc_assert(l_seq_push_front(l, (size_t[]){ 7, 8, 9 }, 3));
         cmc_assert_equals(int32_t, 5, total_create);
 
-        cmc_assert(l_seq_push_back(l, (size_t[]) {14, 15, 16}, 3));
+        cmc_assert(l_seq_push_back(l, (size_t[]){ 14, 15, 16 }, 3));
         cmc_assert_equals(int32_t, 6, total_create);
 
-        cmc_assert(l_seq_push_at(l, (size_t[]) {11, 12, 13}, 3, 4));
+        cmc_assert(l_seq_push_at(l, (size_t[]){ 11, 12, 13 }, 3, 4));
         cmc_assert_equals(int32_t, 7, total_create);
 
         cmc_assert(l_seq_pop_at(l, 1, 4));
@@ -557,7 +557,53 @@ CMC_CREATE_UNIT(list_test, true, {
         struct list *l2 = l_seq_sublist(l, 0, 4);
         cmc_assert_equals(int32_t, 5, total_delete);
 
+        cmc_assert(l_resize(l, 1000));
+        cmc_assert_equals(int32_t, 1, total_resize);
+
+        cmc_assert(l_resize(l2, 1000));
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(int32_t, 7, total_create);
+        cmc_assert_equals(int32_t, 5, total_read);
+        cmc_assert_equals(int32_t, 0, total_update);
+        cmc_assert_equals(int32_t, 5, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        l_customize(l, NULL, NULL);
+
+        cmc_assert_equals(ptr, NULL, l->callbacks);
+
+        l_clear(l);
+        cmc_assert(l_push_front(l, 10));
+        cmc_assert(l_push_back(l, 10));
+        cmc_assert(l_push_at(l, 10, 1));
+        cmc_assert(l_pop_at(l, 1));
+        cmc_assert(l_pop_front(l));
+        cmc_assert(l_pop_back(l));
+        cmc_assert(l_push_back(l, 10));
+        cmc_assert_equals(size_t, 10, l_front(l));
+        cmc_assert_equals(size_t, 10, l_back(l));
+        cmc_assert_equals(size_t, 10, l_get(l, 0));
+        cmc_assert_not_equals(ptr, NULL, l_get_ref(l, 0));
+        cmc_assert(l_contains(l, 10));
+        cmc_assert(l_seq_push_front(l, (size_t[]){ 7, 8, 9 }, 3));
+        cmc_assert(l_seq_push_back(l, (size_t[]){ 14, 15, 16 }, 3));
+        cmc_assert(l_seq_push_at(l, (size_t[]){ 11, 12, 13 }, 3, 4));
+        cmc_assert(l_seq_pop_at(l, 1, 4));
+        struct list *l3 = l_seq_sublist(l, 0, 4);
+        cmc_assert(l_resize(l, 1000));
+        cmc_assert(l_resize(l3, 1000));
+
+        cmc_assert_equals(int32_t, 7, total_create);
+        cmc_assert_equals(int32_t, 5, total_read);
+        cmc_assert_equals(int32_t, 0, total_update);
+        cmc_assert_equals(int32_t, 5, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(ptr, NULL, l->callbacks);
+
         l_free(l);
         l_free(l2);
+        l_free(l3);
     });
 })

tests/main/unt/multimap.c

@@ -272,4 +272,97 @@ CMC_CREATE_UNIT(multimap_test, true, {
         mm_free(map);
         mm_free(map2);
     });
+
+    CMC_CREATE_TEST(callbacks, {
+        struct multimap *map =
+            mm_new_custom(100, 0.8, mm_ftab_key, mm_ftab_val, NULL, callbacks);
+
+        total_create = 0;
+        total_read = 0;
+        total_update = 0;
+        total_delete = 0;
+        total_resize = 0;
+
+        cmc_assert(mm_insert(map, 1, 1));
+        cmc_assert_equals(int32_t, 1, total_create);
+
+        cmc_assert(mm_update(map, 1, 2, NULL));
+        cmc_assert_equals(int32_t, 1, total_update);
+
+        cmc_assert(mm_insert(map, 1, 1));
+        cmc_assert_equals(int32_t, 2, total_create);
+
+        cmc_assert_equals(size_t, 2, mm_update_all(map, 1, 3, NULL));
+        cmc_assert_equals(int32_t, 2, total_update);
+
+        cmc_assert(mm_remove(map, 1, NULL));
+        cmc_assert_equals(int32_t, 1, total_delete);
+
+        cmc_assert(mm_insert(map, 1, 2));
+        cmc_assert_equals(int32_t, 3, total_create);
+
+        cmc_assert_equals(size_t, 2, mm_remove_all(map, 1, NULL));
+        cmc_assert_equals(int32_t, 2, total_delete);
+
+        cmc_assert(mm_insert(map, 1, 2));
+        cmc_assert_equals(int32_t, 4, total_create);
+
+        cmc_assert(mm_max(map, NULL, NULL));
+        cmc_assert_equals(int32_t, 1, total_read);
+
+        cmc_assert(mm_min(map, NULL, NULL));
+        cmc_assert_equals(int32_t, 2, total_read);
+
+        cmc_assert_equals(size_t, 2, mm_get(map, 1));
+        cmc_assert_equals(int32_t, 3, total_read);
+
+        cmc_assert_not_equals(ptr, NULL, mm_get_ref(map, 1));
+        cmc_assert_equals(int32_t, 4, total_read);
+
+        cmc_assert(mm_contains(map, 1));
+        cmc_assert_equals(int32_t, 5, total_read);
+
+        cmc_assert(mm_resize(map, 1000));
+        cmc_assert_equals(int32_t, 1, total_resize);
+
+        cmc_assert(mm_resize(map, 100));
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(int32_t, 4, total_create);
+        cmc_assert_equals(int32_t, 5, total_read);
+        cmc_assert_equals(int32_t, 2, total_update);
+        cmc_assert_equals(int32_t, 2, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        mm_customize(map, NULL, NULL);
+
+        cmc_assert_equals(ptr, NULL, map->callbacks);
+
+        mm_clear(map);
+        cmc_assert(mm_insert(map, 1, 1));
+        cmc_assert(mm_update(map, 1, 2, NULL));
+        cmc_assert(mm_insert(map, 1, 1));
+        cmc_assert_equals(size_t, 2, mm_update_all(map, 1, 3, NULL));
+        cmc_assert(mm_remove(map, 1, NULL));
+        cmc_assert(mm_insert(map, 1, 2));
+        cmc_assert_equals(size_t, 2, mm_remove_all(map, 1, NULL));
+        cmc_assert(mm_insert(map, 1, 2));
+        cmc_assert(mm_max(map, NULL, NULL));
+        cmc_assert(mm_min(map, NULL, NULL));
+        cmc_assert_equals(size_t, 2, mm_get(map, 1));
+        cmc_assert_not_equals(ptr, NULL, mm_get_ref(map, 1));
+        cmc_assert(mm_contains(map, 1));
+        cmc_assert(mm_resize(map, 1000));
+        cmc_assert(mm_resize(map, 100));
+
+        cmc_assert_equals(int32_t, 4, total_create);
+        cmc_assert_equals(int32_t, 5, total_read);
+        cmc_assert_equals(int32_t, 2, total_update);
+        cmc_assert_equals(int32_t, 2, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(ptr, NULL, map->callbacks);
+
+        mm_free(map);
+    });
 });

tests/main/unt/multiset.c

@@ -262,4 +262,85 @@ CMC_CREATE_UNIT(multiset_test, true, {
         ms_free(set);
         ms_free(set2);
     });
+
+    CMC_CREATE_TEST(callbacks, {
+        struct multiset *set =
+            ms_new_custom(100, 0.8, ms_ftab_val, NULL, callbacks);
+
+        total_create = 0;
+        total_read = 0;
+        total_update = 0;
+        total_delete = 0;
+        total_resize = 0;
+
+        cmc_assert(ms_insert(set, 1));
+        cmc_assert_equals(int32_t, 1, total_create);
+
+        cmc_assert(ms_insert_many(set, 1, 3));
+        cmc_assert_equals(int32_t, 2, total_create);
+
+        cmc_assert(ms_update(set, 1, 0));
+        cmc_assert_equals(int32_t, 1, total_update);
+
+        cmc_assert(ms_update(set, 1, 10));
+        cmc_assert_equals(int32_t, 2, total_update);
+
+        cmc_assert(ms_remove(set, 1));
+        cmc_assert_equals(int32_t, 1, total_delete);
+
+        cmc_assert(ms_remove_all(set, 1));
+        cmc_assert_equals(int32_t, 2, total_delete);
+
+        cmc_assert(ms_update(set, 1, 10));
+        cmc_assert_equals(int32_t, 3, total_update);
+
+        cmc_assert(ms_max(set, NULL));
+        cmc_assert_equals(int32_t, 1, total_read);
+
+        cmc_assert(ms_min(set, NULL));
+        cmc_assert_equals(int32_t, 2, total_read);
+
+        cmc_assert(ms_contains(set, 1));
+        cmc_assert_equals(int32_t, 3, total_read);
+
+        cmc_assert(ms_resize(set, 1000));
+        cmc_assert_equals(int32_t, 1, total_resize);
+
+        cmc_assert(ms_resize(set, 100));
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(int32_t, 2, total_create);
+        cmc_assert_equals(int32_t, 3, total_read);
+        cmc_assert_equals(int32_t, 3, total_update);
+        cmc_assert_equals(int32_t, 2, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        ms_customize(set, NULL, NULL);
+
+        cmc_assert_equals(ptr, NULL, set->callbacks);
+
+        ms_clear(set);
+        cmc_assert(ms_insert(set, 1));
+        cmc_assert(ms_insert_many(set, 1, 3));
+        cmc_assert(ms_update(set, 1, 0));
+        cmc_assert(ms_update(set, 1, 10));
+        cmc_assert(ms_remove(set, 1));
+        cmc_assert(ms_remove_all(set, 1));
+        cmc_assert(ms_update(set, 1, 10));
+        cmc_assert(ms_max(set, NULL));
+        cmc_assert(ms_min(set, NULL));
+        cmc_assert(ms_contains(set, 1));
+        cmc_assert(ms_resize(set, 1000));
+        cmc_assert(ms_resize(set, 100));
+
+        cmc_assert_equals(int32_t, 2, total_create);
+        cmc_assert_equals(int32_t, 3, total_read);
+        cmc_assert_equals(int32_t, 3, total_update);
+        cmc_assert_equals(int32_t, 2, total_delete);
+        cmc_assert_equals(int32_t, 2, total_resize);
+
+        cmc_assert_equals(ptr, NULL, set->callbacks);
+
+        ms_free(set);
+    });
 });

tests/main/unt/utl.c

@@ -99,8 +99,7 @@ void callback_resize(void)
 }
 
 struct cmc_callbacks *callbacks =
-    &(struct cmc_callbacks){ .enabled = true,
-                             .create = callback_create,
+    &(struct cmc_callbacks){ .create = callback_create,
                              .read = callback_read,
                              .update = callback_update,
                              .delete = callback_delete,