Added queue and stack resize

tests/main/unt/queue.c

@@ -62,4 +62,349 @@ CMC_CREATE_UNIT(queue_test, true, {
 
         q_free(q, NULL);
     });
+
+    CMC_CREATE_TEST(buffer_growth[item preservation], {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        for (size_t i = 1; i <= 1200; i++)
+        {
+            q_enqueue(q, i);
+        }
+
+        size_t sum = 0;
+        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));
+        cmc_assert_equals(size_t, 720600, sum);
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(enqueue[count capacity], {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        for (size_t i = 0; i < 150; i++)
+            cmc_assert(q_enqueue(q, i));
+
+        cmc_assert_equals(size_t, 150, q_count(q));
+        cmc_assert_greater(size_t, 100, q_capacity(q));
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(enqueue[item preservation], {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        for (size_t i = 1; i <= 100; i++)
+            cmc_assert(q_enqueue(q, i));
+
+        size_t sum = 0;
+
+        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, 5050, sum);
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(dequeue[count capacity], {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        cmc_assert(q_enqueue(q, 10));
+        cmc_assert(q_dequeue(q));
+
+        cmc_assert_equals(size_t, 0, q_count(q));
+
+        cmc_assert(q_enqueue(q, 10));
+        cmc_assert(q_dequeue(q));
+
+        cmc_assert_equals(size_t, 0, q_count(q));
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(dequeue[item preservation], {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        for (size_t i = 200; i > 0; i--)
+            cmc_assert(q_enqueue(q, i));
+
+        for (size_t i = 0; i < 100; i++)
+            cmc_assert(q_dequeue(q));
+
+        size_t sum = 0;
+
+        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, 5050, sum);
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(peek[count = 0], {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        size_t r = q_peek(q);
+
+        cmc_assert_equals(size_t, q_impl_default_value(), r);
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(peek[sum], {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        size_t sum = 0;
+
+        for (size_t i = 0; i <= 100; i++)
+            cmc_assert(q_enqueue(q, i));
+
+        while (!q_empty(q))
+        {
+            size_t r = q_peek(q);
+
+            sum += r;
+
+            cmc_assert(q_dequeue(q));
+        }
+
+        cmc_assert_equals(size_t, 5050, sum);
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(contains, {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        for (size_t i = 1; i <= 20; i++)
+            cmc_assert(q_enqueue(q, i));
+
+        for (size_t i = 1; i <= 20; i++)
+            cmc_assert(q_contains(q, i, cmp));
+
+        q_clear(q, NULL);
+
+        for (size_t i = 1; i <= 20; i++)
+            cmc_assert(!q_contains(q, i, cmp));
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(contains[count = 0], {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        cmc_assert(!q_contains(q, 10, cmp));
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(contains[count = 1], {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        cmc_assert(!q_contains(q, 10, cmp));
+
+        cmc_assert(q_enqueue(q, 100));
+
+        cmc_assert(q_contains(q, 100, cmp));
+        cmc_assert(!q_contains(q, 101, cmp));
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(empty, {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        cmc_assert(q_empty(q));
+
+        cmc_assert(q_enqueue(q, 1));
+
+        cmc_assert(!q_empty(q));
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(full, {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        cmc_assert(!q_full(q));
+
+        for (size_t i = 0; i != q_capacity(q); i++)
+            cmc_assert(q_enqueue(q, i));
+
+        cmc_assert(q_full(q));
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(count, {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        cmc_assert_equals(size_t, 0, q_count(q));
+
+        for (size_t i = 0; i < 100; i++)
+            cmc_assert(q_enqueue(q, i));
+
+        cmc_assert_equals(size_t, 100, q_count(q));
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(capacity, {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        cmc_assert_equals(size_t, 100, q_capacity(q));
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(resize, {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        for (size_t i = 0; i < 150; i++)
+            cmc_assert(q_enqueue(q, i));
+
+        cmc_assert_equals(size_t, 150, q_count(q));
+        cmc_assert(q_resize(q, q_count(q)));
+        cmc_assert_equals(size_t, 150, q_capacity(q));
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(resize[item preservation], {
+        queue *q = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, q);
+
+        for (size_t i = 1; i <= 150; i++)
+            cmc_assert(q_enqueue(q, i));
+
+        cmc_assert(q_resize(q, q_count(q)));
+
+        size_t sum = 0;
+
+        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, 11325, sum);
+
+        q_free(q, NULL);
+    });
+
+    CMC_CREATE_TEST(copy_of, {
+        queue *d1 = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, d1);
+
+        for (size_t i = 1; i <= 150; i++)
+            cmc_assert(q_enqueue(d1, i));
+
+        queue *d2 = q_copy_of(d1, NULL);
+
+        cmc_assert_not_equals(ptr, NULL, d2);
+        cmc_assert_equals(size_t, q_count(d1), q_count(d2));
+
+        for (size_t i1 = d1->front, i2 = d2->front, j = 0; j < d1->count; j++)
+        {
+            cmc_assert_equals(size_t, d1->buffer[i1], d2->buffer[i2]);
+
+            i1 = (i1 + 1) % d1->capacity;
+            i2 = (i2 + 1) % d2->capacity;
+        }
+
+        q_free(d1, NULL);
+        q_free(d2, NULL);
+    });
+
+    CMC_CREATE_TEST(equals, {
+        queue *d1 = q_new(100);
+        queue *d2 = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, d1);
+        cmc_assert_not_equals(ptr, NULL, d2);
+
+        for (size_t i = 1; i <= 150; i++)
+        {
+            cmc_assert(q_enqueue(d1, i));
+            cmc_assert(q_enqueue(d2, i));
+        }
+
+        cmc_assert(q_equals(d1, d2, cmp));
+
+        q_free(d1, NULL);
+        q_free(d2, NULL);
+    });
+
+    CMC_CREATE_TEST(equals[from copy], {
+        queue *d1 = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, d1);
+
+        for (size_t i = 1; i <= 150; i++)
+        {
+            cmc_assert(q_enqueue(d1, i));
+        }
+
+        queue *d2 = q_copy_of(d1, NULL);
+
+        cmc_assert_not_equals(ptr, NULL, d2);
+
+        cmc_assert(q_equals(d1, d2, cmp));
+
+        q_free(d1, NULL);
+        q_free(d2, NULL);
+    });
+
+    CMC_CREATE_TEST(equals[count = 0], {
+        queue *d1 = q_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, d1);
+
+        queue *d2 = q_copy_of(d1, NULL);
+
+        cmc_assert_not_equals(ptr, NULL, d2);
+
+        cmc_assert(q_equals(d1, d2, cmp));
+
+        q_free(d1, NULL);
+        q_free(d2, NULL);
+    });
 });

tests/main/unt/utl.c

@@ -31,14 +31,14 @@ size_t hashcapminus1(size_t a)
     return cmc_hashtable_primes[0] - 1;
 }
 
+size_t hashcapminus4(size_t a)
+{
+    return cmc_hashtable_primes[0] - 1;
+}
+
 size_t hash0(size_t a)
 {
     return 0;
 }
 
-size_t hashmod40(size_t a)
-{
-    return a % 40;
-}
-
 #endif /* CMC_UNIT_TEST_UTL__ */