Update stack unit test

tests/main/src/stack.c

@@ -141,7 +141,10 @@ void s_iter_free(stack_iter *iter) { free(iter); }
 void s_iter_init(stack_iter *iter, stack *target)
 {
     iter->target = target;
-    iter->cursor = iter->target->count - 1;
+    if (s_empty(target))
+        iter->cursor = 0;
+    else
+        iter->cursor = iter->target->count - 1;
     iter->start = true;
     iter->end = s_empty(target);
 }
@@ -165,7 +168,10 @@ bool s_iter_next(stack_iter *iter)
         return false;
     iter->start = s_empty(iter->target);
     if (iter->cursor == 0)
+    {
         iter->end = true;
+        return false;
+    }
     else
         iter->cursor--;
     return true;
@@ -176,7 +182,10 @@ bool s_iter_prev(stack_iter *iter)
         return false;
     iter->end = s_empty(iter->target);
     if (iter->cursor == iter->target->count - 1)
+    {
         iter->start = true;
+        return false;
+    }
     else
         iter->cursor++;
     return true;
@@ -193,7 +202,12 @@ size_t *s_iter_rvalue(stack_iter *iter)
         return NULL;
     return &(iter->target->buffer[iter->cursor]);
 }
-size_t s_iter_index(stack_iter *iter) { return iter->target->count - 1 - iter->cursor; }
+size_t s_iter_index(stack_iter *iter)
+{
+    if (s_empty(iter->target))
+        return 0;
+    return iter->target->count - 1 - iter->cursor;
+}
 static bool s_impl_grow(stack *_stack_)
 {
     size_t new_capacity = _stack_->capacity * 2;

tests/main/unt/stack.c

@@ -2,6 +2,8 @@
 #include "utl/test.h"
 #include "../src/stack.c"
 
+#include "utl.c"
+
 CMC_CREATE_UNIT(stack_test, true, {
     CMC_CREATE_TEST(new, {
         stack *s = s_new(1000000);
@@ -182,6 +184,18 @@ CMC_CREATE_UNIT(stack_test, true, {
         s_free(s);
     });
 
+    CMC_CREATE_TEST(pop[edge_case:count = 0], {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        cmc_assert_equals(bool, false, s_pop(s));
+
+        CMC_TEST_PASS_ELSE_FAIL(!s_pop(s));
+
+        s_free(s);
+    });
+
     CMC_CREATE_TEST(push_if, {
         stack *s = s_new(100);
 
@@ -277,6 +291,36 @@ CMC_CREATE_UNIT(stack_test, true, {
         s_free(s);
     });
 
+    CMC_CREATE_TEST(contains, {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        for (size_t i = 0; i < 150; i++)
+            cmc_assert(s_push(s, i));
+
+        bool passed = true;
+
+        for (size_t i = 0; i < 150; i++)
+            passed = passed && s_contains(s, i, cmp);
+
+        CMC_TEST_PASS_ELSE_FAIL(passed);
+
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(contains[edge_case:count = 0], {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        cmc_assert_equals(bool, false, s_contains(s, 10, cmp));
+
+        CMC_TEST_PASS_ELSE_FAIL(!s_contains(s, 10, cmp));
+
+        s_free(s);
+    });
+
     CMC_CREATE_TEST(empty, {
         stack *s = s_new(100);
 
@@ -332,4 +376,365 @@ CMC_CREATE_UNIT(stack_test, true, {
         s_free(s);
     });
 
+    CMC_CREATE_TEST(iter_alloc, {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        stack_iter *iter = s_iter_new(s);
+
+        cmc_assert_not_equals(ptr, NULL, iter);
+
+        CMC_TEST_PASS_ELSE_FAIL(s && iter);
+
+        s_iter_free(iter);
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(iter_init[edge_case:count = 0], {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        stack_iter iter;
+
+        s_iter_init(&iter, s);
+
+        cmc_assert_equals(ptr, iter.target, s);
+        cmc_assert_equals(size_t, iter.cursor, 0);
+        cmc_assert(iter.start);
+        cmc_assert(iter.end);
+
+        bool passed = iter.target == s && iter.cursor == 0 && iter.start && iter.end;
+
+        CMC_TEST_PASS_ELSE_FAIL(passed);
+
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(iter_start[edge_case:count = 0], {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        stack_iter iter;
+
+        s_iter_init(&iter, s);
+
+        CMC_TEST_PASS_ELSE_FAIL(s_iter_start(&iter));
+
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(iter_end[edge_case:count = 0], {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        stack_iter iter;
+
+        s_iter_init(&iter, s);
+
+        CMC_TEST_PASS_ELSE_FAIL(s_iter_end(&iter));
+
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(iteration, {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        for (size_t i = 1; i <= 200; i++)
+            cmc_assert(s_push(s, i));
+
+        size_t total = 0;
+
+        for (stack_iter it = s->it_start(s); !s_iter_end(&it); s_iter_next(&it))
+        {
+            total += s_iter_value(&it);
+        }
+
+        cmc_assert_equals(size_t, 20100, total);
+
+        for (stack_iter it = s->it_end(s); !s_iter_start(&it); s_iter_prev(&it))
+        {
+            total += s_iter_value(&it);
+        }
+
+        cmc_assert_equals(size_t, 40200, total);
+
+        CMC_TEST_PASS_ELSE_FAIL(total == 40200);
+
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(iteration[while loop], {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        for (size_t i = 1; i <= 200; i++)
+            cmc_assert(s_push(s, i));
+
+        size_t total = 0;
+        stack_iter it = s->it_start(s);
+
+        do
+        {
+            total += s_iter_value(&it);
+        } while (s_iter_next(&it));
+
+        cmc_assert_equals(size_t, 20100, total);
+
+        it = s->it_end(s);
+
+        do
+        {
+            total += s_iter_value(&it);
+        } while (s_iter_prev(&it));
+
+        cmc_assert_equals(size_t, 40200, total);
+
+        CMC_TEST_PASS_ELSE_FAIL(total == 40200);
+
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(iteration[edge_case:count = 1], {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+        cmc_assert(s_push(s, 10));
+
+        size_t total = 0;
+
+        for (stack_iter it = s->it_start(s); !s_iter_end(&it); s_iter_next(&it))
+        {
+            total += s_iter_value(&it);
+        }
+
+        for (stack_iter it = s->it_end(s); !s_iter_start(&it); s_iter_prev(&it))
+        {
+            total += s_iter_value(&it);
+        }
+
+        cmc_assert_equals(size_t, 20, total);
+
+        CMC_TEST_PASS_ELSE_FAIL(total == 20);
+
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(iteration[edge_case:count = capacity], {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        while (!s_full(s))
+            cmc_assert(s_push(s, 10));
+
+        cmc_assert_equals(size_t, s_capacity(s), s_count(s));
+
+        size_t total = 0;
+
+        for (stack_iter it = s->it_start(s); !s_iter_end(&it); s_iter_next(&it))
+        {
+            total += s_iter_value(&it);
+        }
+
+        cmc_assert_equals(size_t, 1000, total);
+
+        for (stack_iter it = s->it_end(s); !s_iter_start(&it); s_iter_prev(&it))
+        {
+            total += *s_iter_rvalue(&it);
+        }
+
+        cmc_assert_equals(size_t, 2000, total);
+
+        CMC_TEST_PASS_ELSE_FAIL(total == 2000);
+
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(iteration[to_start = it_start and to_end = it_end], {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        for (size_t i = 0; i < 50; i++)
+            cmc_assert(s_push(s, i));
+
+        bool passed = true;
+        stack_iter it1;
+        stack_iter it2;
+
+        memset(&it1, 0, sizeof(stack_iter));
+        memset(&it2, 0, sizeof(stack_iter));
+
+        s_iter_init(&it2, s);
+
+        it1 = s->it_start(s);
+        s_iter_to_start(&it2);
+
+        cmc_assert_equals(ptr, it1.target, it2.target);
+        cmc_assert_equals(size_t, it1.cursor, it2.cursor);
+        cmc_assert_equals(bool, it1.start, it2.start);
+        cmc_assert_equals(bool, it1.end, it2.end);
+        passed = passed && it1.target == it2.target && it1.cursor == it2.cursor && it1.start == it2.start && it1.end == it2.end;
+
+        it1 = s->it_end(s);
+        s_iter_to_end(&it2);
+
+        cmc_assert_equals(ptr, it1.target, it2.target);
+        cmc_assert_equals(size_t, it1.cursor, it2.cursor);
+        cmc_assert_equals(bool, it1.start, it2.start);
+        cmc_assert_equals(bool, it1.end, it2.end);
+        passed = passed && it1.target == it2.target && it1.cursor == it2.cursor && it1.start == it2.start && it1.end == it2.end;
+
+        CMC_TEST_PASS_ELSE_FAIL(passed);
+
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(iteration[boundaries:count = 0], {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        stack_iter iter;
+        s_iter_init(&iter, s);
+
+        s_iter_to_end(&iter);
+
+        cmc_assert_equals(bool, false, s_iter_next(&iter));
+        bool passed = !s_iter_next(&iter);
+
+        s_iter_to_start(&iter);
+
+        cmc_assert_equals(bool, false, s_iter_prev(&iter));
+        passed = !s_iter_prev(&iter);
+
+        CMC_TEST_PASS_ELSE_FAIL(passed);
+
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(iteration[boundaries:count > 0], {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        for (size_t i = 0; i < 200; i++)
+            cmc_assert(s_push(s, i));
+
+        stack_iter iter;
+        s_iter_init(&iter, s);
+
+        s_iter_to_end(&iter);
+
+        cmc_assert_equals(bool, false, s_iter_next(&iter));
+        bool passed = !s_iter_next(&iter);
+
+        s_iter_to_start(&iter);
+
+        cmc_assert_equals(bool, false, s_iter_prev(&iter));
+        passed = !s_iter_prev(&iter);
+
+        CMC_TEST_PASS_ELSE_FAIL(passed);
+
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(iter_value[edge_case:count = 0], {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        stack_iter iter;
+
+        s_iter_init(&iter, s);
+
+        cmc_assert_equals(size_t, s_impl_default_value(), s_iter_value(&iter));
+
+        CMC_TEST_PASS_ELSE_FAIL(s_impl_default_value() == s_iter_value(&iter));
+
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(iter_rvalue[edge_case:count = 0], {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        stack_iter iter;
+
+        s_iter_init(&iter, s);
+
+        cmc_assert_equals(ptr, NULL, s_iter_rvalue(&iter));
+
+        CMC_TEST_PASS_ELSE_FAIL(NULL == s_iter_rvalue(&iter));
+
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(index, {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        for (size_t i = 0; i < 10; i++)
+            cmc_assert(s_push(s, i));
+
+        cmc_assert_equals(size_t, 10, s_count(s));
+
+        bool passed = true;
+        size_t total = 0;
+
+        for (stack_iter it = s->it_start(s); false; )
+        {
+            passed = passed && s_iter_index(&it) == 0;
+            cmc_assert_equals(size_t, 0, s_iter_index(&it));
+        }
+
+        for (stack_iter it = s->it_start(s); false; )
+        {
+            passed = passed && s_iter_index(&it) == s_count(s) - 1;
+            cmc_assert_equals(size_t, s_count(s) - 1, s_iter_index(&it));
+        }
+
+        for (stack_iter it = s->it_start(s); !s_iter_end(&it); s_iter_next(&it))
+        {
+            total += s_iter_index(&it);
+        }
+
+        cmc_assert_equals(size_t, 45, total);
+
+        for (stack_iter it = s->it_end(s); !s_iter_start(&it); s_iter_prev(&it))
+        {
+            total += s_iter_index(&it);
+        }
+
+        cmc_assert_equals(size_t, 90, total);
+
+        CMC_TEST_PASS_ELSE_FAIL(passed && total == 90);
+
+        s_free(s);
+    });
+
+    CMC_CREATE_TEST(index[edge_case:count = 0], {
+        stack *s = s_new(100);
+
+        cmc_assert_not_equals(ptr, NULL, s);
+
+        stack_iter iter;
+        s_iter_init(&iter, s);
+
+        cmc_assert_equals(size_t, 0, s_iter_index(&iter));
+
+        CMC_TEST_PASS_ELSE_FAIL(0 == s_iter_index(&iter));
+
+        s_free(s);
+    });
+
 });