Add more testing (#23)

Increase code coverage so that other than the out-of-memory conditions, the code is entirely covered.

Some areas of the code have been tweaked for performance optimizations.

Bug fix! A bug has been identified and fixed in the unordered_multiset data structure in the unordered_multiset_remove_all function.

This bug would occur when more than one entry exists in the bucket in which the element is occupying, and that element had a count of more than one.

src/forward_list.c

@@ -184,7 +184,7 @@ int forward_list_add_last(forward_list me, void *const data)
  */
 static bool forward_list_is_illegal_input(forward_list me, const int index)
 {
-    return index < 0 || index >= me->item_count || me->item_count == 0;
+    return index < 0 || index >= me->item_count;
 }
 
 /**

src/list.c

@@ -253,7 +253,7 @@ int list_add_last(list me, void *const data)
  */
 static bool list_is_illegal_input(list me, const int index)
 {
-    return index < 0 || index >= me->item_count || me->item_count == 0;
+    return index < 0 || index >= me->item_count;
 }
 
 /**

src/unordered_multiset.c

@@ -389,7 +389,7 @@ bool unordered_multiset_remove_all(unordered_multiset me, void *const key)
         if (unordered_multiset_is_equal(me, traverse->next, hash, key)) {
             struct node *const backup = traverse->next;
             traverse->next = traverse->next->next;
-            me->size -= traverse->count;
+            me->size -= backup->count;
             free(backup->key);
             free(backup);
             me->used--;

src/vector.c

@@ -99,7 +99,8 @@ bool vector_is_empty(vector me)
 }
 
 /*
- * Sets the space of the buffer.
+ * Sets the space of the buffer. Assumes that size is at least the same as the
+ * amount of items currently in the vector.
  */
 static int vector_set_space(vector me, const int size)
 {
@@ -109,9 +110,6 @@ static int vector_set_space(vector me, const int size)
     }
     me->data = temp;
     me->item_capacity = size;
-    if (me->item_capacity < me->item_count) {
-        me->item_count = me->item_capacity;
-    }
     return 0;
 }
 
@@ -240,7 +238,7 @@ int vector_add_last(vector me, void *const data)
  */
 static bool vector_is_illegal_input(vector me, const int index)
 {
-    return index < 0 || index >= me->item_count || me->item_count == 0;
+    return index < 0 || index >= me->item_count;
 }
 
 /**
@@ -398,9 +396,8 @@ int vector_get_last(void *const data, vector me)
  */
 int vector_clear(vector me)
 {
-    const int ret = vector_set_space(me, START_SPACE);
     me->item_count = 0;
-    return ret;
+    return vector_set_space(me, START_SPACE);
 }
 
 /**

tst/array.c

@@ -3,6 +3,8 @@
 
 void test_array(void)
 {
+    assert(!array_init(-1, sizeof(int)));
+    assert(!array_init(1, 0));
     array me = array_init(10, sizeof(int));
     assert(me);
     assert(array_size(me) == 10);
@@ -31,6 +33,9 @@ void test_array(void)
     for (int i = 0; i < 10; i++) {
         assert(data[i] == i);
     }
+    int get = 0xdeadbeef;
+    assert(array_set(me, -1, &get) == -EINVAL);
+    assert(array_get(&get, me, -1) == -EINVAL);
     me = array_destroy(me);
     assert(!me);
 }

tst/deque.c

@@ -3,6 +3,7 @@
 
 void test_deque(void)
 {
+    assert(!deque_init(0));
     int val[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     deque me = deque_init(sizeof(int));
     assert(me);

tst/forward_list.c

@@ -3,6 +3,7 @@
 
 void test_forward_list(void)
 {
+    assert(!forward_list_init(0));
     int val[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     forward_list me = forward_list_init(sizeof(int));
     assert(me);

tst/list.c

@@ -3,6 +3,7 @@
 
 void test_list(void)
 {
+    assert(!list_init(0));
     int val[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     list me = list_init(sizeof(int));
     assert(me);
@@ -34,8 +35,9 @@ void test_list(void)
     for (int i = 0; i < 3; i++) {
         assert(10 - i == trimmed[i]);
     }
+    int index = list_size(me);
     int add = 3;
-    list_add_last(me, &add);
+    list_add_at(me, index, &add);
     add = -1;
     list_add_at(me, 1, &add);
     add = -2;
@@ -63,6 +65,12 @@ void test_list(void)
     list_remove_first(me);
     list_remove_at(me, 2);
     list_remove_last(me);
+    get = 34;
+    list_add_at(me, 0, &get);
+    int first = 0xdeadbeef;
+    list_get_first(&first, me);
+    assert(first == get);
+    list_remove_first(me);
     assert(list_size(me) == 3);
     get = 345;
     list_get_first(&get, me);

tst/map.c

@@ -10,6 +10,9 @@ static int compare_int(const void *const one, const void *const two)
 
 void test_map(void)
 {
+    assert(!map_init(0, sizeof(int), compare_int));
+    assert(!map_init(sizeof(int), 0, compare_int));
+    assert(!map_init(sizeof(int), sizeof(int), NULL));
     map me = map_init(sizeof(int), sizeof(int), compare_int);
     assert(me);
     assert(map_size(me) == 0);
@@ -117,4 +120,417 @@ void test_map(void)
     assert(map_is_empty(me));
     me = map_destroy(me);
     assert(!me);
+    me = map_init(sizeof(int), sizeof(int), compare_int);
+    assert(me);
+    // left-left
+    key = 5;
+    map_put(me, &key, &num);
+    key = 3;
+    map_put(me, &key, &num);
+    key = 1;
+    map_put(me, &key, &num);
+    key = 0xdeadbeef;
+    map_contains(me, &key);
+    map_clear(me);
+    // right-right
+    key = 1;
+    map_put(me, &key, &num);
+    key = 3;
+    map_put(me, &key, &num);
+    key = 5;
+    map_put(me, &key, &num);
+    key = 0xdeadbeef;
+    map_contains(me, &key);
+    map_clear(me);
+    // left-right
+    key = 5;
+    map_put(me, &key, &num);
+    key = 1;
+    map_put(me, &key, &num);
+    key = 3;
+    map_put(me, &key, &num);
+    key = 0xdeadbeef;
+    map_contains(me, &key);
+    map_clear(me);
+    // right-left
+    key = 1;
+    map_put(me, &key, &num);
+    key = 5;
+    map_put(me, &key, &num);
+    key = 3;
+    map_put(me, &key, &num);
+    key = 0xdeadbeef;
+    map_contains(me, &key);
+    map_clear(me);
+    // Two children edge case.
+    key = 8;
+    map_put(me, &key, &num);
+    key = 5;
+    map_put(me, &key, &num);
+    key = 11;
+    map_put(me, &key, &num);
+    key = 2;
+    map_put(me, &key, &num);
+    key = 6;
+    map_put(me, &key, &num);
+    key = 10;
+    map_put(me, &key, &num);
+    key = 15;
+    map_put(me, &key, &num);
+    key = 1;
+    map_put(me, &key, &num);
+    key = 3;
+    map_put(me, &key, &num);
+    key = 4;
+    map_put(me, &key, &num);
+    key = 7;
+    map_put(me, &key, &num);
+    key = 9;
+    map_put(me, &key, &num);
+    key = 12;
+    map_put(me, &key, &num);
+    key = 13;
+    map_put(me, &key, &num);
+    key = 16;
+    map_put(me, &key, &num);
+    key = 14;
+    map_put(me, &key, &num);
+    map_clear(me);
+    // Two children edge case.
+    key = 8;
+    map_put(me, &key, &num);
+    key = 4;
+    map_put(me, &key, &num);
+    key = 12;
+    map_put(me, &key, &num);
+    key = 2;
+    map_put(me, &key, &num);
+    key = 6;
+    map_put(me, &key, &num);
+    key = 10;
+    map_put(me, &key, &num);
+    key = 15;
+    map_put(me, &key, &num);
+    key = 1;
+    map_put(me, &key, &num);
+    key = 3;
+    map_put(me, &key, &num);
+    key = 5;
+    map_put(me, &key, &num);
+    key = 7;
+    map_put(me, &key, &num);
+    key = 9;
+    map_put(me, &key, &num);
+    key = 11;
+    map_put(me, &key, &num);
+    key = 13;
+    map_put(me, &key, &num);
+    key = 16;
+    map_put(me, &key, &num);
+    key = 14;
+    map_put(me, &key, &num);
+    map_clear(me);
+    // Add a lot of items.
+    int count = 0;
+    bool flip = false;
+    for (int i = 1234; i < 82400; i++) {
+        key = i % 765;
+        const bool is_already_present = map_contains(me, &key);
+        map_put(me, &key, &num);
+        const bool is_now_present = map_contains(me, &key);
+        assert(is_now_present);
+        if (!is_already_present && is_now_present) {
+            count++;
+        }
+        if (i == 1857 && !flip) {
+            i *= -1;
+            flip = true;
+        }
+    }
+    assert(count == map_size(me));
+    map_put(me, &key, &num);
+    map_destroy(me);
+    me = map_init(sizeof(int), sizeof(int), compare_int);
+    assert(map_size(me) == 0);
+    assert(map_is_empty(me));
+    key = 4;
+    map_put(me, &key, &num);
+    assert(map_size(me) == 1);
+    map_put(me, &key, &num);
+    assert(map_size(me) == 1);
+    assert(!map_is_empty(me));
+    assert(map_contains(me, &key));
+    key = 7;
+    assert(!map_contains(me, &key));
+    map_put(me, &key, &num);
+    assert(map_size(me) == 2);
+    assert(map_contains(me, &key));
+    int c[10] = {5, 9, 4, -5, 0, 6, 1, 5, 7, 2};
+    for (int i = 0; i < 10; i++) {
+        map_put(me, &c[i], &num);
+        assert(map_contains(me, &c[i]));
+    }
+    assert(map_size(me) == 9);
+    for (int i = 0; i < 10; i++) {
+        assert(map_contains(me, &c[i]));
+    }
+    for (int i = -100; i < 100; i++) {
+        bool contains = false;
+        for (int j = 0; j < 10; j++) {
+            if (c[j] == i) {
+                contains = true;
+            }
+        }
+        assert(map_contains(me, &i) == contains);
+    }
+    num = -3;
+    assert(!map_remove(me, &num));
+    assert(map_size(me) == 9);
+    assert(!map_contains(me, &num));
+    num = 6;
+    assert(map_remove(me, &num));
+    assert(map_size(me) == 8);
+    assert(!map_contains(me, &num));
+    num = 4;
+    assert(map_remove(me, &num));
+    assert(map_size(me) == 7);
+    assert(!map_contains(me, &num));
+    num = 7;
+    assert(map_remove(me, &num));
+    assert(map_size(me) == 6);
+    assert(!map_contains(me, &num));
+    num = 9;
+    assert(map_remove(me, &num));
+    assert(map_size(me) == 5);
+    assert(!map_contains(me, &num));
+    num = -5;
+    assert(map_remove(me, &num));
+    assert(map_size(me) == 4);
+    assert(!map_contains(me, &num));
+    num = 0;
+    assert(map_remove(me, &num));
+    assert(map_size(me) == 3);
+    assert(!map_contains(me, &num));
+    num = 1;
+    assert(map_remove(me, &num));
+    assert(map_size(me) == 2);
+    assert(!map_contains(me, &num));
+    num = 5;
+    assert(map_remove(me, &num));
+    assert(map_size(me) == 1);
+    assert(!map_contains(me, &num));
+    num = 2;
+    assert(map_remove(me, &num));
+    assert(map_size(me) == 0);
+    assert(!map_contains(me, &num));
+    // Add a lot of items and remove individually.
+    for (int i = 5000; i < 6000; i++) {
+        map_put(me, &i, &num);
+        assert(map_contains(me, &i));
+    }
+    assert(map_size(me) == 1000);
+    for (int i = 5000; i < 5500; i++) {
+        map_remove(me, &i);
+        assert(!map_contains(me, &i));
+    }
+    assert(map_size(me) == 500);
+    assert(!map_is_empty(me));
+    map_clear(me);
+    assert(map_size(me) == 0);
+    assert(map_is_empty(me));
+    // Add a lot of items and clear.
+    for (int i = 5000; i < 6000; i++) {
+        map_put(me, &i, &num);
+        assert(map_contains(me, &i));
+    }
+    assert(map_size(me) == 1000);
+    map_clear(me);
+    int p = 0xdeadbeef;
+    assert(!map_remove(me, &p));
+    assert(map_size(me) == 0);
+    assert(map_is_empty(me));
+    me = map_destroy(me);
+    assert(!me);
+    // Create odd shape graph.
+    me = map_init(sizeof(int), sizeof(int), compare_int);
+    key = 10;
+    map_put(me, &key, &num);
+    key = 5;
+    map_put(me, &key, &num);
+    key = 15;
+    map_put(me, &key, &num);
+    key = 3;
+    map_put(me, &key, &num);
+    key = 8;
+    map_put(me, &key, &num);
+    key = 12;
+    map_put(me, &key, &num);
+    key = 18;
+    map_put(me, &key, &num);
+    key = 12;
+    map_remove(me, &key);
+    key = 5;
+    map_remove(me, &key);
+    key = 3;
+    map_remove(me, &key);
+    key = 8;
+    map_remove(me, &key);
+    map_clear(me);
+    // Allocate many nodes.
+    for (int i = 8123; i < 12314; i += 3) {
+        map_put(me, &i, &num);
+        assert(map_contains(me, &i));
+    }
+    for (int i = 13000; i > 8000; i--) {
+        map_remove(me, &i);
+        assert(!map_contains(me, &i));
+    }
+    map_clear(me);
+    // Create another odd shape graph.
+    key = 20;
+    map_put(me, &key, &num);
+    key = 10;
+    map_put(me, &key, &num);
+    key = 40;
+    map_put(me, &key, &num);
+    key = 5;
+    map_put(me, &key, &num);
+    key = 15;
+    map_put(me, &key, &num);
+    key = 30;
+    map_put(me, &key, &num);
+    key = 50;
+    map_put(me, &key, &num);
+    key = 25;
+    map_put(me, &key, &num);
+    key = 35;
+    map_put(me, &key, &num);
+    key = 36;
+    map_put(me, &key, &num);
+    key = 34;
+    map_put(me, &key, &num);
+    key = 33;
+    map_put(me, &key, &num);
+    key = 32;
+    map_put(me, &key, &num);
+    key = 30;
+    map_remove(me, &key);
+    key = 32;
+    assert(map_contains(me, &key));
+    map_clear(me);
+    // One sided tree.
+    key = 10;
+    map_put(me, &key, &num);
+    key = 9;
+    map_put(me, &key, &num);
+    key = 8;
+    map_put(me, &key, &num);
+    key = 7;
+    map_put(me, &key, &num);
+    key = 8;
+    map_remove(me, &key);
+    key = 7;
+    assert(map_contains(me, &key));
+    map_destroy(me);
+    // Replace two sided two children.
+    me = map_init(sizeof(int), sizeof(int), compare_int);
+    key = 5;
+    map_put(me, &key, &num);
+    key = 1;
+    map_put(me, &key, &num);
+    key = 6;
+    map_put(me, &key, &num);
+    key = -1;
+    map_put(me, &key, &num);
+    key = 3;
+    map_put(me, &key, &num);
+    key = 7;
+    map_put(me, &key, &num);
+    key = -2;
+    map_put(me, &key, &num);
+    key = 0;
+    map_put(me, &key, &num);
+    key = 2;
+    map_put(me, &key, &num);
+    key = 4;
+    map_put(me, &key, &num);
+    key = 1;
+    map_remove(me, &key);
+    assert(!map_contains(me, &key));
+    map_clear(me);
+    key = 5;
+    map_put(me, &key, &num);
+    key = 1;
+    map_put(me, &key, &num);
+    key = 6;
+    map_put(me, &key, &num);
+    key = -1;
+    map_put(me, &key, &num);
+    key = 3;
+    map_put(me, &key, &num);
+    key = 7;
+    map_put(me, &key, &num);
+    key = -2;
+    map_put(me, &key, &num);
+    key = 0;
+    map_put(me, &key, &num);
+    key = 4;
+    map_put(me, &key, &num);
+    key = 1;
+    map_remove(me, &key);
+    assert(!map_contains(me, &key));
+    me = map_destroy(me);
+    assert(!me);
+    me = map_init(sizeof(int), sizeof(int), compare_int);
+    for (int i = 4817; i > -2983; i -= 11) {
+        map_put(me, &i, &num);
+        assert(map_contains(me, &i));
+    }
+    for (int i = -432; i < 3849; i += 7) {
+        map_remove(me, &i);
+        assert(!map_contains(me, &i));
+    }
+    map_clear(me);
+    key = 5;
+    map_put(me, &key, &num);
+    key = 7;
+    map_put(me, &key, &num);
+    key = 5;
+    map_remove(me, &key);
+    map_clear(me);
+    // Two children edge case other side.
+    key = 8;
+    map_put(me, &key, &num);
+    key = 4;
+    map_put(me, &key, &num);
+    key = 12;
+    map_put(me, &key, &num);
+    key = 2;
+    map_put(me, &key, &num);
+    key = 6;
+    map_put(me, &key, &num);
+    key = 10;
+    map_put(me, &key, &num);
+    key = 16;
+    map_put(me, &key, &num);
+    key = 1;
+    map_put(me, &key, &num);
+    key = 3;
+    map_put(me, &key, &num);
+    key = 5;
+    map_put(me, &key, &num);
+    key = 7;
+    map_put(me, &key, &num);
+    key = 9;
+    map_put(me, &key, &num);
+    key = 11;
+    map_put(me, &key, &num);
+    key = 15;
+    map_put(me, &key, &num);
+    key = 17;
+    map_put(me, &key, &num);
+    key = 13;
+    map_put(me, &key, &num);
+    map_clear(me);
+    assert(!map_get(&value, me, &key));
 }

tst/multimap.c

@@ -10,6 +10,10 @@ static int compare_int(const void *const one, const void *const two)
 
 void test_multimap(void)
 {
+    assert(!multimap_init(0, sizeof(int), compare_int, compare_int));
+    assert(!multimap_init(sizeof(int), 0, compare_int, compare_int));
+    assert(!multimap_init(sizeof(int), sizeof(int), NULL, compare_int));
+    assert(!multimap_init(sizeof(int), sizeof(int), compare_int, NULL));
     multimap me = multimap_init(sizeof(int), sizeof(int),
                                 compare_int, compare_int);
     assert(me);
@@ -146,4 +150,435 @@ void test_multimap(void)
     assert(multimap_size(me) == 1);
     me = multimap_destroy(me);
     assert(!me);
+    me = multimap_init(sizeof(int), sizeof(int), compare_int, compare_int);
+    assert(me);
+    // left-left
+    key = 5;
+    multimap_put(me, &key, &num);
+    key = 3;
+    multimap_put(me, &key, &num);
+    key = 1;
+    multimap_put(me, &key, &num);
+    key = 0xdeadbeef;
+    multimap_contains(me, &key);
+    multimap_clear(me);
+    // right-right
+    key = 1;
+    multimap_put(me, &key, &num);
+    key = 3;
+    multimap_put(me, &key, &num);
+    key = 5;
+    multimap_put(me, &key, &num);
+    key = 0xdeadbeef;
+    multimap_contains(me, &key);
+    multimap_clear(me);
+    // left-right
+    key = 5;
+    multimap_put(me, &key, &num);
+    key = 1;
+    multimap_put(me, &key, &num);
+    key = 3;
+    multimap_put(me, &key, &num);
+    key = 0xdeadbeef;
+    multimap_contains(me, &key);
+    multimap_clear(me);
+    // right-left
+    key = 1;
+    multimap_put(me, &key, &num);
+    key = 5;
+    multimap_put(me, &key, &num);
+    key = 3;
+    multimap_put(me, &key, &num);
+    key = 0xdeadbeef;
+    multimap_contains(me, &key);
+    multimap_clear(me);
+    // Two children edge case.
+    key = 8;
+    multimap_put(me, &key, &num);
+    key = 5;
+    multimap_put(me, &key, &num);
+    key = 11;
+    multimap_put(me, &key, &num);
+    key = 2;
+    multimap_put(me, &key, &num);
+    key = 6;
+    multimap_put(me, &key, &num);
+    key = 10;
+    multimap_put(me, &key, &num);
+    key = 15;
+    multimap_put(me, &key, &num);
+    key = 1;
+    multimap_put(me, &key, &num);
+    key = 3;
+    multimap_put(me, &key, &num);
+    key = 4;
+    multimap_put(me, &key, &num);
+    key = 7;
+    multimap_put(me, &key, &num);
+    key = 9;
+    multimap_put(me, &key, &num);
+    key = 12;
+    multimap_put(me, &key, &num);
+    key = 13;
+    multimap_put(me, &key, &num);
+    key = 16;
+    multimap_put(me, &key, &num);
+    key = 14;
+    multimap_put(me, &key, &num);
+    multimap_clear(me);
+    // Two children edge case.
+    key = 8;
+    multimap_put(me, &key, &num);
+    key = 4;
+    multimap_put(me, &key, &num);
+    key = 12;
+    multimap_put(me, &key, &num);
+    key = 2;
+    multimap_put(me, &key, &num);
+    key = 6;
+    multimap_put(me, &key, &num);
+    key = 10;
+    multimap_put(me, &key, &num);
+    key = 15;
+    multimap_put(me, &key, &num);
+    key = 1;
+    multimap_put(me, &key, &num);
+    key = 3;
+    multimap_put(me, &key, &num);
+    key = 5;
+    multimap_put(me, &key, &num);
+    key = 7;
+    multimap_put(me, &key, &num);
+    key = 9;
+    multimap_put(me, &key, &num);
+    key = 11;
+    multimap_put(me, &key, &num);
+    key = 13;
+    multimap_put(me, &key, &num);
+    key = 16;
+    multimap_put(me, &key, &num);
+    key = 14;
+    multimap_put(me, &key, &num);
+    multimap_clear(me);
+    // Add a lot of items.
+    count = 0;
+    bool flip = false;
+    for (int i = 1234; i < 82400; i++) {
+        key = i % 765;
+        multimap_put(me, &key, &num);
+        assert(multimap_contains(me, &key));
+        count++;
+        if (i == 1857 && !flip) {
+            i *= -1;
+            flip = true;
+        }
+    }
+    assert(count == multimap_size(me));
+    multimap_put(me, &key, &num);
+    multimap_destroy(me);
+    me = multimap_init(sizeof(int), sizeof(int), compare_int, compare_int);
+    assert(multimap_size(me) == 0);
+    assert(multimap_is_empty(me));
+    key = 4;
+    multimap_put(me, &key, &num);
+    assert(multimap_size(me) == 1);
+    multimap_put(me, &key, &num);
+    assert(multimap_size(me) == 2);
+    assert(!multimap_is_empty(me));
+    assert(multimap_contains(me, &key));
+    key = 7;
+    assert(!multimap_contains(me, &key));
+    multimap_put(me, &key, &num);
+    assert(multimap_size(me) == 3);
+    assert(multimap_contains(me, &key));
+    int c[10] = {5, 9, 4, -5, 0, 6, 1, 5, 7, 2};
+    for (int i = 0; i < 10; i++) {
+        multimap_put(me, &c[i], &value);
+        assert(multimap_contains(me, &c[i]));
+    }
+    assert(multimap_size(me) == 13);
+    for (int i = 0; i < 10; i++) {
+        assert(multimap_contains(me, &c[i]));
+    }
+    for (int i = -100; i < 100; i++) {
+        bool contains = false;
+        for (int j = 0; j < 10; j++) {
+            if (c[j] == i) {
+                contains = true;
+            }
+        }
+        assert(multimap_contains(me, &i) == contains);
+    }
+    num = -3;
+    assert(!multimap_remove(me, &num, &value));
+    assert(multimap_size(me) == 13);
+    assert(!multimap_contains(me, &num));
+    num = 6;
+    assert(multimap_remove(me, &num, &value));
+    assert(multimap_size(me) == 12);
+    assert(!multimap_contains(me, &num));
+    num = 4;
+    assert(multimap_remove(me, &num, &value));
+    assert(multimap_size(me) == 11);
+    assert(multimap_contains(me, &num));
+    num = 7;
+    assert(multimap_remove(me, &num, &value));
+    assert(multimap_size(me) == 10);
+    assert(multimap_contains(me, &num));
+    num = 9;
+    assert(multimap_remove(me, &num, &value));
+    assert(multimap_size(me) == 9);
+    assert(!multimap_contains(me, &num));
+    num = -5;
+    assert(multimap_remove(me, &num, &value));
+    assert(multimap_size(me) == 8);
+    assert(!multimap_contains(me, &num));
+    num = 0;
+    assert(multimap_remove(me, &num, &value));
+    assert(multimap_size(me) == 7);
+    assert(!multimap_contains(me, &num));
+    num = 1;
+    assert(multimap_remove(me, &num, &value));
+    assert(multimap_size(me) == 6);
+    assert(!multimap_contains(me, &num));
+    num = 5;
+    assert(multimap_remove(me, &num, &value));
+    assert(multimap_size(me) == 5);
+    assert(multimap_contains(me, &num));
+    num = 2;
+    assert(multimap_remove(me, &num, &value));
+    assert(multimap_size(me) == 4);
+    assert(!multimap_contains(me, &num));
+    multimap_clear(me);
+    // Add a lot of items and remove individually.
+    value = 37;
+    for (int i = 5000; i < 6000; i++) {
+        multimap_put(me, &i, &value);
+        assert(multimap_contains(me, &i));
+    }
+    assert(multimap_size(me) == 1000);
+    for (int i = 5000; i < 5500; i++) {
+        multimap_remove(me, &i, &value);
+        assert(!multimap_contains(me, &i));
+    }
+    assert(multimap_size(me) == 500);
+    assert(!multimap_is_empty(me));
+    multimap_clear(me);
+    assert(multimap_size(me) == 0);
+    assert(multimap_is_empty(me));
+    // Add a lot of items and clear.
+    for (int i = 5000; i < 6000; i++) {
+        multimap_put(me, &i, &num);
+        assert(multimap_contains(me, &i));
+    }
+    assert(multimap_size(me) == 1000);
+    multimap_clear(me);
+    int p = 0xdeadbeef;
+    assert(!multimap_remove(me, &p, &value));
+    assert(multimap_size(me) == 0);
+    assert(multimap_is_empty(me));
+    me = multimap_destroy(me);
+    assert(!me);
+    // Create odd shape graph.
+    me = multimap_init(sizeof(int), sizeof(int), compare_int, compare_int);
+    key = 10;
+    multimap_put(me, &key, &num);
+    key = 5;
+    multimap_put(me, &key, &num);
+    key = 15;
+    multimap_put(me, &key, &num);
+    key = 3;
+    multimap_put(me, &key, &num);
+    key = 8;
+    multimap_put(me, &key, &num);
+    key = 12;
+    multimap_put(me, &key, &num);
+    key = 18;
+    multimap_put(me, &key, &num);
+    key = 12;
+    multimap_remove(me, &key, &value);
+    key = 5;
+    multimap_remove(me, &key, &value);
+    key = 3;
+    multimap_remove(me, &key, &value);
+    key = 8;
+    multimap_remove(me, &key, &value);
+    multimap_clear(me);
+    // Allocate many nodes.
+    value = 54;
+    for (int i = 8123; i < 12314; i += 3) {
+        multimap_put(me, &i, &value);
+        assert(multimap_contains(me, &i));
+    }
+    for (int i = 13000; i > 8000; i--) {
+        multimap_remove(me, &i, &value);
+        assert(!multimap_contains(me, &i));
+    }
+    multimap_clear(me);
+    // Create another odd shape graph.
+    key = 20;
+    multimap_put(me, &key, &num);
+    key = 10;
+    multimap_put(me, &key, &num);
+    key = 40;
+    multimap_put(me, &key, &num);
+    key = 5;
+    multimap_put(me, &key, &num);
+    key = 15;
+    multimap_put(me, &key, &num);
+    key = 30;
+    multimap_put(me, &key, &num);
+    key = 50;
+    multimap_put(me, &key, &num);
+    key = 25;
+    multimap_put(me, &key, &num);
+    key = 35;
+    multimap_put(me, &key, &num);
+    key = 36;
+    multimap_put(me, &key, &num);
+    key = 34;
+    multimap_put(me, &key, &num);
+    key = 33;
+    multimap_put(me, &key, &num);
+    key = 32;
+    multimap_put(me, &key, &num);
+    key = 30;
+    multimap_remove(me, &key, &value);
+    key = 32;
+    assert(multimap_contains(me, &key));
+    multimap_clear(me);
+    // One sided tree.
+    key = 10;
+    multimap_put(me, &key, &num);
+    key = 9;
+    multimap_put(me, &key, &num);
+    key = 8;
+    multimap_put(me, &key, &num);
+    key = 7;
+    multimap_put(me, &key, &num);
+    key = 8;
+    multimap_remove(me, &key, &value);
+    key = 7;
+    assert(multimap_contains(me, &key));
+    multimap_destroy(me);
+    // Replace two sided two children.
+    me = multimap_init(sizeof(int), sizeof(int), compare_int, compare_int);
+    key = 5;
+    multimap_put(me, &key, &num);
+    key = 1;
+    multimap_put(me, &key, &num);
+    key = 6;
+    multimap_put(me, &key, &num);
+    key = -1;
+    multimap_put(me, &key, &num);
+    key = 3;
+    multimap_put(me, &key, &num);
+    key = 7;
+    multimap_put(me, &key, &num);
+    key = -2;
+    multimap_put(me, &key, &num);
+    key = 0;
+    multimap_put(me, &key, &num);
+    key = 2;
+    multimap_put(me, &key, &num);
+    key = 4;
+    multimap_put(me, &key, &num);
+    key = 1;
+    multimap_remove_all(me, &key);
+    assert(!multimap_contains(me, &key));
+    multimap_clear(me);
+    key = 5;
+    multimap_put(me, &key, &num);
+    key = 1;
+    multimap_put(me, &key, &num);
+    key = 6;
+    multimap_put(me, &key, &num);
+    key = -1;
+    multimap_put(me, &key, &num);
+    key = 3;
+    multimap_put(me, &key, &num);
+    key = 7;
+    multimap_put(me, &key, &num);
+    key = -2;
+    multimap_put(me, &key, &num);
+    key = 0;
+    multimap_put(me, &key, &num);
+    key = 4;
+    multimap_put(me, &key, &num);
+    key = 1;
+    multimap_remove_all(me, &key);
+    assert(!multimap_contains(me, &key));
+    me = multimap_destroy(me);
+    assert(!me);
+    me = multimap_init(sizeof(int), sizeof(int), compare_int, compare_int);
+    value = 97;
+    for (int i = 4817; i > -2983; i -= 11) {
+        multimap_put(me, &i, &value);
+        assert(multimap_contains(me, &i));
+    }
+    for (int i = -432; i < 3849; i += 7) {
+        multimap_remove(me, &i, &value);
+        assert(!multimap_contains(me, &i));
+    }
+    multimap_clear(me);
+    key = 5;
+    multimap_put(me, &key, &num);
+    key = 7;
+    multimap_put(me, &key, &num);
+    key = 5;
+    multimap_remove(me, &key, &value);
+    multimap_clear(me);
+    // Two children edge case other side.
+    key = 8;
+    multimap_put(me, &key, &num);
+    key = 4;
+    multimap_put(me, &key, &num);
+    key = 12;
+    multimap_put(me, &key, &num);
+    key = 2;
+    multimap_put(me, &key, &num);
+    key = 6;
+    multimap_put(me, &key, &num);
+    key = 10;
+    multimap_put(me, &key, &num);
+    key = 16;
+    multimap_put(me, &key, &num);
+    key = 1;
+    multimap_put(me, &key, &num);
+    key = 3;
+    multimap_put(me, &key, &num);
+    key = 5;
+    multimap_put(me, &key, &num);
+    key = 7;
+    multimap_put(me, &key, &num);
+    key = 9;
+    multimap_put(me, &key, &num);
+    key = 11;
+    multimap_put(me, &key, &num);
+    key = 15;
+    multimap_put(me, &key, &num);
+    key = 17;
+    multimap_put(me, &key, &num);
+    key = 13;
+    multimap_put(me, &key, &num);
+    multimap_clear(me);
+    assert(multimap_count(me, &key) == 0);
+    assert(!multimap_remove_all(me, &key));
+    // Edge case.
+    me = multimap_init(sizeof(int), sizeof(int), compare_int, compare_int);
+    value = 17;
+    key = 5;
+    multimap_put(me, &key, &value);
+    key = 3;
+    multimap_put(me, &key, &value);
+    key = 7;
+    multimap_put(me, &key, &value);
+    key = 2;
+    multimap_put(me, &key, &value);
+    key = 6;
+    multimap_put(me, &key, &value);
+    key = 9;
+    multimap_put(me, &key, &value);
+    key = 3;
+    multimap_remove(me, &key, &value);
 }

tst/multiset.c

@@ -10,6 +10,8 @@ static int compare_int(const void *const one, const void *const two)
 
 void test_multiset(void)
 {
+    assert(!multiset_init(0, compare_int));
+    assert(!multiset_init(sizeof(int), NULL));
     multiset me = multiset_init(sizeof(int), compare_int);
     assert(me);
     assert(multiset_size(me) == 0);
@@ -135,4 +137,415 @@ void test_multiset(void)
     assert(multiset_size(me) == 1);
     me = multiset_destroy(me);
     assert(!me);
+    me = multiset_init(sizeof(int), compare_int);
+    assert(me);
+    // left-left
+    key = 5;
+    multiset_put(me, &key);
+    key = 3;
+    multiset_put(me, &key);
+    key = 1;
+    multiset_put(me, &key);
+    key = 0xdeadbeef;
+    multiset_contains(me, &key);
+    multiset_clear(me);
+    // right-right
+    key = 1;
+    multiset_put(me, &key);
+    key = 3;
+    multiset_put(me, &key);
+    key = 5;
+    multiset_put(me, &key);
+    key = 0xdeadbeef;
+    multiset_contains(me, &key);
+    multiset_clear(me);
+    // left-right
+    key = 5;
+    multiset_put(me, &key);
+    key = 1;
+    multiset_put(me, &key);
+    key = 3;
+    multiset_put(me, &key);
+    key = 0xdeadbeef;
+    multiset_contains(me, &key);
+    multiset_clear(me);
+    // right-left
+    key = 1;
+    multiset_put(me, &key);
+    key = 5;
+    multiset_put(me, &key);
+    key = 3;
+    multiset_put(me, &key);
+    key = 0xdeadbeef;
+    multiset_contains(me, &key);
+    multiset_clear(me);
+    // Two children edge case.
+    key = 8;
+    multiset_put(me, &key);
+    key = 5;
+    multiset_put(me, &key);
+    key = 11;
+    multiset_put(me, &key);
+    key = 2;
+    multiset_put(me, &key);
+    key = 6;
+    multiset_put(me, &key);
+    key = 10;
+    multiset_put(me, &key);
+    key = 15;
+    multiset_put(me, &key);
+    key = 1;
+    multiset_put(me, &key);
+    key = 3;
+    multiset_put(me, &key);
+    key = 4;
+    multiset_put(me, &key);
+    key = 7;
+    multiset_put(me, &key);
+    key = 9;
+    multiset_put(me, &key);
+    key = 12;
+    multiset_put(me, &key);
+    key = 13;
+    multiset_put(me, &key);
+    key = 16;
+    multiset_put(me, &key);
+    key = 14;
+    multiset_put(me, &key);
+    multiset_clear(me);
+    // Two children edge case.
+    key = 8;
+    multiset_put(me, &key);
+    key = 4;
+    multiset_put(me, &key);
+    key = 12;
+    multiset_put(me, &key);
+    key = 2;
+    multiset_put(me, &key);
+    key = 6;
+    multiset_put(me, &key);
+    key = 10;
+    multiset_put(me, &key);
+    key = 15;
+    multiset_put(me, &key);
+    key = 1;
+    multiset_put(me, &key);
+    key = 3;
+    multiset_put(me, &key);
+    key = 5;
+    multiset_put(me, &key);
+    key = 7;
+    multiset_put(me, &key);
+    key = 9;
+    multiset_put(me, &key);
+    key = 11;
+    multiset_put(me, &key);
+    key = 13;
+    multiset_put(me, &key);
+    key = 16;
+    multiset_put(me, &key);
+    key = 14;
+    multiset_put(me, &key);
+    multiset_clear(me);
+    // Add a lot of items.
+    int count = 0;
+    bool flip = false;
+    for (int i = 1234; i < 82400; i++) {
+        key = i % 765;
+        multiset_put(me, &key);
+        assert(multiset_contains(me, &key));
+        count++;
+        if (i == 1857 && !flip) {
+            i *= -1;
+            flip = true;
+        }
+    }
+    assert(count == multiset_size(me));
+    multiset_contains(me, &key);
+    multiset_destroy(me);
+    me = multiset_init(sizeof(int), compare_int);
+    assert(multiset_size(me) == 0);
+    assert(multiset_is_empty(me));
+    key = 4;
+    multiset_put(me, &key);
+    assert(multiset_size(me) == 1);
+    multiset_put(me, &key);
+    assert(multiset_size(me) == 2);
+    assert(!multiset_is_empty(me));
+    assert(multiset_contains(me, &key));
+    key = 7;
+    assert(!multiset_contains(me, &key));
+    multiset_put(me, &key);
+    assert(multiset_size(me) == 3);
+    assert(multiset_contains(me, &key));
+    int c[10] = {5, 9, 4, -5, 0, 6, 1, 5, 7, 2};
+    for (int i = 0; i < 10; i++) {
+        multiset_put(me, &c[i]);
+        assert(multiset_contains(me, &c[i]));
+    }
+    assert(multiset_size(me) == 13);
+    for (int i = 0; i < 10; i++) {
+        assert(multiset_contains(me, &c[i]));
+    }
+    for (int i = -100; i < 100; i++) {
+        bool contains = false;
+        for (int j = 0; j < 10; j++) {
+            if (c[j] == i) {
+                contains = true;
+            }
+        }
+        assert(multiset_contains(me, &i) == contains);
+    }
+    num = -3;
+    assert(!multiset_remove(me, &num));
+    assert(multiset_size(me) == 13);
+    assert(!multiset_contains(me, &num));
+    num = 6;
+    assert(multiset_remove(me, &num));
+    assert(multiset_size(me) == 12);
+    assert(!multiset_contains(me, &num));
+    num = 4;
+    assert(multiset_remove(me, &num));
+    assert(multiset_size(me) == 11);
+    assert(multiset_contains(me, &num));
+    num = 7;
+    assert(multiset_remove(me, &num));
+    assert(multiset_size(me) == 10);
+    assert(multiset_contains(me, &num));
+    num = 9;
+    assert(multiset_remove(me, &num));
+    assert(multiset_size(me) == 9);
+    assert(!multiset_contains(me, &num));
+    num = -5;
+    assert(multiset_remove(me, &num));
+    assert(multiset_size(me) == 8);
+    assert(!multiset_contains(me, &num));
+    num = 0;
+    assert(multiset_remove(me, &num));
+    assert(multiset_size(me) == 7);
+    assert(!multiset_contains(me, &num));
+    num = 1;
+    assert(multiset_remove(me, &num));
+    assert(multiset_size(me) == 6);
+    assert(!multiset_contains(me, &num));
+    num = 5;
+    assert(multiset_remove(me, &num));
+    assert(multiset_size(me) == 5);
+    assert(multiset_contains(me, &num));
+    num = 2;
+    assert(multiset_remove(me, &num));
+    assert(multiset_size(me) == 4);
+    assert(!multiset_contains(me, &num));
+    multiset_clear(me);
+    // Add a lot of items and remove individually.
+    for (int i = 5000; i < 6000; i++) {
+        multiset_put(me, &i);
+        assert(multiset_contains(me, &i));
+    }
+    assert(multiset_size(me) == 1000);
+    for (int i = 5000; i < 5500; i++) {
+        multiset_remove(me, &i);
+        assert(!multiset_contains(me, &i));
+    }
+    assert(multiset_size(me) == 500);
+    assert(!multiset_is_empty(me));
+    multiset_clear(me);
+    assert(multiset_size(me) == 0);
+    assert(multiset_is_empty(me));
+    // Add a lot of items and clear.
+    for (int i = 5000; i < 6000; i++) {
+        multiset_put(me, &i);
+        assert(multiset_contains(me, &i));
+    }
+    assert(multiset_size(me) == 1000);
+    multiset_clear(me);
+    int p = 0xdeadbeef;
+    assert(!multiset_remove(me, &p));
+    assert(multiset_size(me) == 0);
+    assert(multiset_is_empty(me));
+    me = multiset_destroy(me);
+    assert(!me);
+    // Create odd shape graph.
+    me = multiset_init(sizeof(int), compare_int);
+    key = 10;
+    multiset_put(me, &key);
+    key = 5;
+    multiset_put(me, &key);
+    key = 15;
+    multiset_put(me, &key);
+    key = 3;
+    multiset_put(me, &key);
+    key = 8;
+    multiset_put(me, &key);
+    key = 12;
+    multiset_put(me, &key);
+    key = 18;
+    multiset_put(me, &key);
+    key = 12;
+    multiset_remove(me, &key);
+    key = 5;
+    multiset_remove(me, &key);
+    key = 3;
+    multiset_remove(me, &key);
+    key = 8;
+    multiset_remove(me, &key);
+    multiset_clear(me);
+    // Allocate many nodes.
+    for (int i = 8123; i < 12314; i += 3) {
+        multiset_put(me, &i);
+        assert(multiset_contains(me, &i));
+    }
+    for (int i = 13000; i > 8000; i--) {
+        multiset_remove(me, &i);
+        assert(!multiset_contains(me, &i));
+    }
+    multiset_clear(me);
+    // Create another odd shape graph.
+    key = 20;
+    multiset_put(me, &key);
+    key = 10;
+    multiset_put(me, &key);
+    key = 40;
+    multiset_put(me, &key);
+    key = 5;
+    multiset_put(me, &key);
+    key = 15;
+    multiset_put(me, &key);
+    key = 30;
+    multiset_put(me, &key);
+    key = 50;
+    multiset_put(me, &key);
+    key = 25;
+    multiset_put(me, &key);
+    key = 35;
+    multiset_put(me, &key);
+    key = 36;
+    multiset_put(me, &key);
+    key = 34;
+    multiset_put(me, &key);
+    key = 33;
+    multiset_put(me, &key);
+    key = 32;
+    multiset_put(me, &key);
+    key = 30;
+    multiset_remove(me, &key);
+    key = 32;
+    assert(multiset_contains(me, &key));
+    multiset_clear(me);
+    // One sided tree.
+    key = 10;
+    multiset_put(me, &key);
+    key = 9;
+    multiset_put(me, &key);
+    key = 8;
+    multiset_put(me, &key);
+    key = 7;
+    multiset_put(me, &key);
+    key = 8;
+    multiset_remove(me, &key);
+    key = 7;
+    assert(multiset_contains(me, &key));
+    multiset_destroy(me);
+    // Replace two sided two children.
+    me = multiset_init(sizeof(int), compare_int);
+    key = 5;
+    multiset_put(me, &key);
+    key = 1;
+    multiset_put(me, &key);
+    key = 6;
+    multiset_put(me, &key);
+    key = -1;
+    multiset_put(me, &key);
+    key = 3;
+    multiset_put(me, &key);
+    key = 7;
+    multiset_put(me, &key);
+    key = -2;
+    multiset_put(me, &key);
+    key = 0;
+    multiset_put(me, &key);
+    key = 2;
+    multiset_put(me, &key);
+    key = 4;
+    multiset_put(me, &key);
+    key = 1;
+    multiset_remove(me, &key);
+    assert(!multiset_contains(me, &key));
+    multiset_clear(me);
+    key = 5;
+    multiset_put(me, &key);
+    key = 1;
+    multiset_put(me, &key);
+    key = 6;
+    multiset_put(me, &key);
+    key = -1;
+    multiset_put(me, &key);
+    key = 3;
+    multiset_put(me, &key);
+    key = 7;
+    multiset_put(me, &key);
+    key = -2;
+    multiset_put(me, &key);
+    key = 0;
+    multiset_put(me, &key);
+    key = 4;
+    multiset_put(me, &key);
+    key = 1;
+    multiset_remove(me, &key);
+    assert(!multiset_contains(me, &key));
+    me = multiset_destroy(me);
+    assert(!me);
+    me = multiset_init(sizeof(int), compare_int);
+    for (int i = 4817; i > -2983; i -= 11) {
+        multiset_put(me, &i);
+        assert(multiset_contains(me, &i));
+    }
+    for (int i = -432; i < 3849; i += 7) {
+        multiset_remove(me, &i);
+        assert(!multiset_contains(me, &i));
+    }
+    multiset_clear(me);
+    key = 5;
+    multiset_put(me, &key);
+    key = 7;
+    multiset_put(me, &key);
+    key = 5;
+    multiset_remove(me, &key);
+    multiset_clear(me);
+    // Two children edge case other side.
+    key = 8;
+    multiset_put(me, &key);
+    key = 4;
+    multiset_put(me, &key);
+    key = 12;
+    multiset_put(me, &key);
+    key = 2;
+    multiset_put(me, &key);
+    key = 6;
+    multiset_put(me, &key);
+    key = 10;
+    multiset_put(me, &key);
+    key = 16;
+    multiset_put(me, &key);
+    key = 1;
+    multiset_put(me, &key);
+    key = 3;
+    multiset_put(me, &key);
+    key = 5;
+    multiset_put(me, &key);
+    key = 7;
+    multiset_put(me, &key);
+    key = 9;
+    multiset_put(me, &key);
+    key = 11;
+    multiset_put(me, &key);
+    key = 15;
+    multiset_put(me, &key);
+    key = 17;
+    multiset_put(me, &key);
+    key = 13;
+    multiset_put(me, &key);
+    multiset_clear(me);
+    assert(multiset_count(me, &key) == 0);
+    assert(!multiset_remove_all(me, &key));
 }

tst/priority_queue.c

@@ -55,11 +55,16 @@ bool stub_priority_queue_pop(void *const data, priority_queue me)
 
 void test_priority_queue(void)
 {
+    assert(!priority_queue_init(0, compare_int));
+    assert(!priority_queue_init(sizeof(int), NULL));
     priority_queue me = priority_queue_init(sizeof(int), compare_int);
     assert(me);
     assert(priority_queue_size(me) == 0);
     assert(priority_queue_is_empty(me));
-    int item = 5;
+    int item = 0xdeadbeef;
+    assert(!priority_queue_pop(&item, me));
+    assert(item == 0xdeadbeef);
+    item = 5;
     stub_priority_queue_push(me, &item);
     item = 2;
     stub_priority_queue_push(me, &item);

tst/queue.c

@@ -3,6 +3,7 @@
 
 void test_queue(void)
 {
+    assert(!queue_init(0));
     int val[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     queue me = queue_init(sizeof(int));
     assert(me);

tst/set.c

@@ -114,6 +114,8 @@ static int compare_int(const void *const one, const void *const two)
 
 void test_set(void)
 {
+    assert(!set_init(0, compare_int));
+    assert(!set_init(sizeof(int), NULL));
     set me = set_init(sizeof(int), compare_int);
     assert(me);
     int key;
@@ -476,4 +478,55 @@ void test_set(void)
     assert(!stub_set_contains(me, &key));
     me = stub_set_destroy(me);
     assert(!me);
+    me = set_init(sizeof(int), compare_int);
+    for (int i = 4817; i > -2983; i -= 11) {
+        stub_set_put(me, &i);
+        assert(stub_set_contains(me, &i));
+    }
+    for (int i = -432; i < 3849; i += 7) {
+        stub_set_remove(me, &i);
+        assert(!stub_set_contains(me, &i));
+    }
+    stub_set_clear(me);
+    key = 5;
+    stub_set_put(me, &key);
+    key = 7;
+    stub_set_put(me, &key);
+    key = 5;
+    stub_set_remove(me, &key);
+    stub_set_clear(me);
+    // Two children edge case other side.
+    key = 8;
+    stub_set_put(me, &key);
+    key = 4;
+    stub_set_put(me, &key);
+    key = 12;
+    stub_set_put(me, &key);
+    key = 2;
+    stub_set_put(me, &key);
+    key = 6;
+    stub_set_put(me, &key);
+    key = 10;
+    stub_set_put(me, &key);
+    key = 16;
+    stub_set_put(me, &key);
+    key = 1;
+    stub_set_put(me, &key);
+    key = 3;
+    stub_set_put(me, &key);
+    key = 5;
+    stub_set_put(me, &key);
+    key = 7;
+    stub_set_put(me, &key);
+    key = 9;
+    stub_set_put(me, &key);
+    key = 11;
+    stub_set_put(me, &key);
+    key = 15;
+    stub_set_put(me, &key);
+    key = 17;
+    stub_set_put(me, &key);
+    key = 13;
+    stub_set_put(me, &key);
+    stub_set_clear(me);
 }

tst/stack.c

@@ -3,6 +3,7 @@
 
 void test_stack(void)
 {
+    assert(!stack_init(0));
     int val[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     stack me = stack_init(sizeof(int));
     assert(me);

tst/unordered_map.c

@@ -18,10 +18,19 @@ static unsigned long hash_int(const void *const key)
     return hash;
 }
 
+static unsigned long bad_hash_int(const void *const key)
+{
+    return 5;
+}
+
 void test_unordered_map(void)
 {
+    assert(!unordered_map_init(0, sizeof(int), hash_int, compare_int));
+    assert(!unordered_map_init(sizeof(int), 0, hash_int, compare_int));
+    assert(!unordered_map_init(sizeof(int), sizeof(int), NULL, compare_int));
+    assert(!unordered_map_init(sizeof(int), sizeof(int), hash_int, NULL));
     unordered_map me = unordered_map_init(sizeof(int), sizeof(int),
-                                         hash_int, compare_int);
+                                          hash_int, compare_int);
     assert(unordered_map_size(me) == 0);
     assert(unordered_map_is_empty(me));
     int key = 4;
@@ -129,5 +138,27 @@ void test_unordered_map(void)
     assert(unordered_map_size(me) == 0);
     assert(unordered_map_is_empty(me));
     me = unordered_map_destroy(me);
-    assert(me == NULL);
+    assert(!me);
+    me = unordered_map_init(sizeof(int), sizeof(int), bad_hash_int,
+                            compare_int);
+    num = 1;
+    unordered_map_put(me, &num, &num);
+    num = 2;
+    unordered_map_put(me, &num, &num);
+    num = 3;
+    unordered_map_put(me, &num, &num);
+    num = 4;
+    unordered_map_put(me, &num, &num);
+    assert(unordered_map_size(me) == 4);
+    unordered_map_put(me, &num, &num);
+    assert(unordered_map_size(me) == 4);
+    assert(unordered_map_remove(me, &num));
+    assert(!unordered_map_remove(me, &num));
+    assert(unordered_map_size(me) == 3);
+    unordered_map_rehash(me);
+    assert(unordered_map_size(me) == 3);
+    key = 5;
+    value = 0xdeadbeef;
+    assert(!unordered_map_get(&value, me, &key));
+    assert(value == 0xdeadbeef);
 }

tst/unordered_multimap.c

@@ -18,8 +18,23 @@ static unsigned long hash_int(const void *const key)
     return hash;
 }
 
+static unsigned long bad_hash_int(const void *const key)
+{
+    return 5;
+}
+
 void test_unordered_multimap(void)
 {
+    assert(!unordered_multimap_init(0, sizeof(int), hash_int, compare_int,
+                                    compare_int));
+    assert(!unordered_multimap_init(sizeof(int), 0, hash_int, compare_int,
+                                    compare_int));
+    assert(!unordered_multimap_init(sizeof(int), sizeof(int), NULL, compare_int,
+                                    compare_int));
+    assert(!unordered_multimap_init(sizeof(int), sizeof(int), hash_int, NULL,
+                                    compare_int));
+    assert(!unordered_multimap_init(sizeof(int), sizeof(int), hash_int,
+                                    compare_int, NULL));
     unordered_multimap me =
             unordered_multimap_init(sizeof(int), sizeof(int), hash_int,
                                     compare_int, compare_int);
@@ -160,4 +175,72 @@ void test_unordered_multimap(void)
     assert(unordered_multimap_size(me) == 1);
     me = unordered_multimap_destroy(me);
     assert(!me);
+    me = unordered_multimap_init(sizeof(int), sizeof(int), bad_hash_int,
+                                 compare_int, compare_int);
+    key = 1;
+    unordered_multimap_put(me, &key, &value);
+    key = 2;
+    unordered_multimap_put(me, &key, &value);
+    key = 3;
+    unordered_multimap_put(me, &key, &value);
+    assert(unordered_multimap_size(me) == 3);
+    unordered_multimap_put(me, &key, &value);
+    assert(unordered_multimap_size(me) == 4);
+    key = 4;
+    unordered_multimap_put(me, &key, &value);
+    assert(unordered_multimap_size(me) == 5);
+    assert(unordered_multimap_remove(me, &key, &value));
+    assert(!unordered_multimap_remove(me, &key, &value));
+    assert(unordered_multimap_size(me) == 4);
+    unordered_multimap_rehash(me);
+    assert(unordered_multimap_size(me) == 4);
+    me = unordered_multimap_init(sizeof(int), sizeof(int), bad_hash_int,
+                                 compare_int, compare_int);
+    key = 1;
+    unordered_multimap_put(me, &key, &value);
+    key = 2;
+    unordered_multimap_put(me, &key, &value);
+    key = 3;
+    unordered_multimap_put(me, &key, &value);
+    assert(unordered_multimap_size(me) == 3);
+    unordered_multimap_put(me, &key, &value);
+    assert(unordered_multimap_size(me) == 4);
+    key = 4;
+    unordered_multimap_put(me, &key, &value);
+    assert(unordered_multimap_size(me) == 5);
+    assert(unordered_multimap_remove_all(me, &key));
+    assert(!unordered_multimap_remove_all(me, &key));
+    assert(unordered_multimap_size(me) == 4);
+    unordered_multimap_rehash(me);
+    assert(unordered_multimap_size(me) == 4);
+    unordered_multimap_clear(me);
+    assert(unordered_multimap_size(me) == 0);
+    assert(!unordered_multimap_remove_all(me, &key));
+    assert(unordered_multimap_size(me) == 0);
+    me = unordered_multimap_init(sizeof(int), sizeof(int), bad_hash_int,
+                                 compare_int, compare_int);
+    key = 1;
+    value = 10;
+    unordered_multimap_put(me, &key, &value);
+    key = 2;
+    value = 11;
+    unordered_multimap_put(me, &key, &value);
+    key = 3;
+    value = 12;
+    unordered_multimap_put(me, &key, &value);
+    key = 4;
+    value = 14;
+    unordered_multimap_put(me, &key, &value);
+    key = 3;
+    value = 13;
+    unordered_multimap_put(me, &key, &value);
+    unordered_multimap_get_start(me, &key);
+    value = 20;
+    unordered_multimap_get_next(&value, me);
+    assert(value == 12);
+    unordered_multimap_get_next(&value, me);
+    assert(value == 13);
+    value = 30;
+    assert(!unordered_multimap_get_next(&value, me));
+    assert(value == 30);
 }

tst/unordered_multiset.c

@@ -18,8 +18,16 @@ static unsigned long hash_int(const void *const key)
     return hash;
 }
 
+static unsigned long bad_hash_int(const void *const key)
+{
+    return 5;
+}
+
 void test_unordered_multiset(void)
 {
+    assert(!unordered_multiset_init(0, hash_int, compare_int));
+    assert(!unordered_multiset_init(sizeof(int), NULL, compare_int));
+    assert(!unordered_multiset_init(sizeof(int), hash_int, NULL));
     unordered_multiset me =
             unordered_multiset_init(sizeof(int), hash_int, compare_int);
     assert(me);
@@ -148,4 +156,44 @@ void test_unordered_multiset(void)
     assert(unordered_multiset_size(me) == 1);
     me = unordered_multiset_destroy(me);
     assert(!me);
+    me = unordered_multiset_init(sizeof(int), bad_hash_int, compare_int);
+    num = 1;
+    unordered_multiset_put(me, &num);
+    num = 2;
+    unordered_multiset_put(me, &num);
+    num = 3;
+    unordered_multiset_put(me, &num);
+    assert(unordered_multiset_size(me) == 3);
+    unordered_multiset_put(me, &num);
+    assert(unordered_multiset_size(me) == 4);
+    num = 4;
+    unordered_multiset_put(me, &num);
+    assert(unordered_multiset_size(me) == 5);
+    assert(unordered_multiset_remove(me, &num));
+    assert(!unordered_multiset_remove(me, &num));
+    assert(unordered_multiset_size(me) == 4);
+    unordered_multiset_rehash(me);
+    assert(unordered_multiset_size(me) == 4);
+    me = unordered_multiset_init(sizeof(int), bad_hash_int, compare_int);
+    num = 1;
+    unordered_multiset_put(me, &num);
+    num = 2;
+    unordered_multiset_put(me, &num);
+    num = 3;
+    unordered_multiset_put(me, &num);
+    assert(unordered_multiset_size(me) == 3);
+    unordered_multiset_put(me, &num);
+    assert(unordered_multiset_size(me) == 4);
+    num = 4;
+    unordered_multiset_put(me, &num);
+    assert(unordered_multiset_size(me) == 5);
+    assert(unordered_multiset_remove_all(me, &num));
+    assert(!unordered_multiset_remove_all(me, &num));
+    assert(unordered_multiset_size(me) == 4);
+    unordered_multiset_rehash(me);
+    assert(unordered_multiset_size(me) == 4);
+    unordered_multiset_clear(me);
+    assert(unordered_multiset_size(me) == 0);
+    assert(!unordered_multiset_remove_all(me, &num));
+    assert(unordered_multiset_size(me) == 0);
 }

tst/unordered_set.c

@@ -18,8 +18,16 @@ static unsigned long hash_int(const void *const key)
     return hash;
 }
 
+static unsigned long bad_hash_int(const void *const key)
+{
+    return 5;
+}
+
 void test_unordered_set(void)
 {
+    assert(!unordered_set_init(0, hash_int, compare_int));
+    assert(!unordered_set_init(sizeof(int), NULL, compare_int));
+    assert(!unordered_set_init(sizeof(int), hash_int, NULL));
     unordered_set me = unordered_set_init(sizeof(int), hash_int, compare_int);
     assert(me);
     assert(unordered_set_size(me) == 0);
@@ -125,4 +133,21 @@ void test_unordered_set(void)
     assert(unordered_set_is_empty(me));
     me = unordered_set_destroy(me);
     assert(!me);
+    me = unordered_set_init(sizeof(int), bad_hash_int, compare_int);
+    num = 1;
+    unordered_set_put(me, &num);
+    num = 2;
+    unordered_set_put(me, &num);
+    num = 3;
+    unordered_set_put(me, &num);
+    num = 4;
+    unordered_set_put(me, &num);
+    assert(unordered_set_size(me) == 4);
+    unordered_set_put(me, &num);
+    assert(unordered_set_size(me) == 4);
+    assert(unordered_set_remove(me, &num));
+    assert(!unordered_set_remove(me, &num));
+    assert(unordered_set_size(me) == 3);
+    unordered_set_rehash(me);
+    assert(unordered_set_size(me) == 3);
 }

tst/vector.c

@@ -63,6 +63,7 @@ static void test_vector_dynamic(void)
 
 void test_vector(void)
 {
+    assert(!vector_init(0));
     int val[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     vector me = vector_init(sizeof(int));
     assert(me);
@@ -158,6 +159,7 @@ void test_vector(void)
     assert(arr[0] == -5);
     assert(arr[1] == -6);
     assert(arr[2] == -7);
+    assert(vector_reserve(me, 100) == 0);
     assert(vector_set_at(me, 4, &set) == -EINVAL);
     assert(vector_get_at(&set, me, 4) == -EINVAL);
     assert(vector_remove_at(me, 4) == -EINVAL);
@@ -167,6 +169,11 @@ void test_vector(void)
     assert(vector_remove_at(me, -1) == -EINVAL);
     assert(vector_add_at(me, -1, &set) == -EINVAL);
     vector_clear(me);
+    for (int i = 0; i < 32; i++) {
+        vector_add_last(me, &i);
+    }
+    vector_clear(me);
+    assert(vector_capacity(me) == 8);
     assert(vector_size(me) == 0);
     assert(vector_is_empty(me));
     assert(vector_remove_first(me) == -EINVAL);