diff --git a/tests/main/Makefile b/tests/main/Makefile index 73df4e5..43e887b 100644 --- a/tests/main/Makefile +++ b/tests/main/Makefile @@ -1,6 +1,7 @@ CC = gcc CFLAGS = -std=c11 -Wall -Wextra CFLAGS += -Wno-unused -Wno-missing-braces +DBFLAGS = -g3 CVFLAGS = --coverage -O0 INCLUDE = ../../src/ @@ -31,4 +32,10 @@ bare: FORCE ./main.exe rm *.exe +debug: FORCE + $(CC) main.c -o main.exe $(CFLAGS) -I $(INCLUDE) -DCMC_TEST_COLOR $(DBFLAGS) + +valgrind: debug + valgrind --leak-check=full ./main.exe + FORCE: diff --git a/tests/main/main.c b/tests/main/main.c index d162a69..9e792f0 100644 --- a/tests/main/main.c +++ b/tests/main/main.c @@ -30,6 +30,17 @@ int main(void) { + // clang-format off + printf(" +---------------------------------------------------------------+\n"); + printf(" | C Macro Collections Library |\n"); + printf(" | |\n"); + printf(" | Test Suite |\n"); + printf(" | |\n"); + printf(" | https://github.com/LeoVen/C-Macro-Collections |\n"); + printf(" | Leonardo Vencovsky (leonardo.vencovsky@gmail.com) |\n"); + printf(" +---------------------------------------------------------------+\n\n"); + // clang-format on + struct cmc_timer timer; cmc_timer_start(timer); diff --git a/tests/main/unt/deque.c b/tests/main/unt/deque.c index e54f209..08a68c0 100644 --- a/tests/main/unt/deque.c +++ b/tests/main/unt/deque.c @@ -77,7 +77,6 @@ CMC_CREATE_UNIT(Deque, true, { CMC_CREATE_TEST(PFX##_clear(), { v_total_free = 0; - struct deque *d = d_new(100, d_fval_counter); cmc_assert_not_equals(ptr, NULL, d); @@ -91,7 +90,7 @@ CMC_CREATE_UNIT(Deque, true, { d_clear(d); cmc_assert_equals(size_t, 50, v_total_free); - cmc_assert_equals(int32_t, cmc_flags.OK, d->flag); + cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); cmc_assert_equals(size_t, 0, d_count(d)); cmc_assert_equals(size_t, 100, d_capacity(d)); @@ -117,7 +116,7 @@ CMC_CREATE_UNIT(Deque, true, { d_clear(d); cmc_assert_equals(size_t, 1050, v_total_free); - cmc_assert_equals(int32_t, cmc_flags.OK, d->flag); + cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); sum = 0; for (size_t i = 0; i < d->capacity; i++) @@ -166,19 +165,21 @@ CMC_CREATE_UNIT(Deque, true, { CMC_CREATE_TEST(PFX##_customize(), { struct deque *d = d_new(100, d_fval); + cmc_assert_not_equals(ptr, NULL, d); + d->flag = cmc_flags.ERROR; d_customize(d, d_alloc_node, callbacks); cmc_assert_equals(ptr, d_alloc_node, d->alloc); cmc_assert_equals(ptr, callbacks, d->callbacks); - cmc_assert_equals(int32_t, cmc_flags.OK, d->flag); + cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); d->flag = cmc_flags.ERROR; d_customize(d, NULL, NULL); cmc_assert_equals(ptr, &cmc_alloc_node_default, d->alloc); cmc_assert_equals(ptr, NULL, d->callbacks); - cmc_assert_equals(int32_t, cmc_flags.OK, d->flag); + cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); d_free(d); }); @@ -189,10 +190,12 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_not_equals(ptr, NULL, d); + d->flag = cmc_flags.ERROR; cmc_assert(d_push_front(d, 10)); - cmc_assert_equals(size_t, 1, d_count(d)); + cmc_assert_equals(size_t, 1, d_count(d)); cmc_assert_equals(int32_t, 1, total_create); + cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); d_customize(d, NULL, NULL); @@ -210,7 +213,7 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_not_equals(ptr, NULL, d); - for (size_t i = 1; i <= 1000; i++) + for (size_t i = 1; i <= 10000; i++) d_push_front(d, i); size_t sum = 0; @@ -221,7 +224,7 @@ CMC_CREATE_UNIT(Deque, true, { sum += d->buffer[i]; } - cmc_assert_equals(size_t, 500500, sum); + cmc_assert_equals(size_t, 50005000, sum); d_free(d); @@ -235,10 +238,12 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_not_equals(ptr, NULL, d); + d->flag = cmc_flags.ERROR; cmc_assert(d_push_front(d, 10)); - cmc_assert_equals(size_t, 1, d_count(d)); + cmc_assert_equals(size_t, 1, d_count(d)); cmc_assert_equals(int32_t, 1, total_create); + cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); d_customize(d, NULL, NULL); @@ -256,7 +261,7 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_not_equals(ptr, NULL, d); - for (size_t i = 1; i <= 1000; i++) + for (size_t i = 1; i <= 10000; i++) d_push_back(d, i); size_t sum = 0; @@ -267,7 +272,7 @@ CMC_CREATE_UNIT(Deque, true, { sum += d->buffer[i]; } - cmc_assert_equals(size_t, 500500, sum); + cmc_assert_equals(size_t, 50005000, sum); d_free(d); @@ -280,10 +285,15 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_not_equals(ptr, NULL, d); + cmc_assert(!d_pop_front(d)); + cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d)); + cmc_assert(d_push_front(d, 10)); + d->flag = cmc_flags.ERROR; cmc_assert(d_pop_front(d)); cmc_assert_equals(size_t, 0, d_count(d)); + cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); cmc_assert(d_push_back(d, 10)); cmc_assert(d_pop_front(d)); @@ -296,11 +306,13 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_not_equals(ptr, NULL, d); - for (size_t i = 1; i <= 200; i++) - cmc_assert(d_push_front(d, i)); + for (size_t i = 1; i <= 20000; i++) + d_push_front(d, i); - for (size_t i = 0; i < 100; i++) - cmc_assert(d_pop_front(d)); + cmc_assert_equals(size_t, 20000, d_count(d)); + + for (size_t i = 0; i < 10000; i++) + d_pop_front(d); size_t sum = 0; @@ -310,20 +322,45 @@ CMC_CREATE_UNIT(Deque, true, { sum += d->buffer[i]; } - cmc_assert_equals(size_t, 5050, sum); + cmc_assert_equals(size_t, 50005000, sum); + + d_clear(d); + + for (size_t i = 1; i <= 20000; i++) + d_push_front(d, i); + + cmc_assert_equals(size_t, 20000, d_count(d)); + + for (size_t i = 0; i < 10000; i++) + d_pop_front(d); + + sum = 0; + + for (size_t i = d->front, j = 0; j < d->count; + i = (i + 1) % d->capacity, j++) + { + sum += d->buffer[i]; + } + + cmc_assert_equals(size_t, 50005000, sum); d_free(d); }); - CMC_CREATE_TEST(pop_back[count capacity], { + CMC_CREATE_TEST(PFX##_pop_back(), { struct deque *d = d_new(100, d_fval); cmc_assert_not_equals(ptr, NULL, d); + cmc_assert(!d_pop_back(d)); + cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d)); + cmc_assert(d_push_front(d, 10)); + d->flag = cmc_flags.ERROR; cmc_assert(d_pop_back(d)); cmc_assert_equals(size_t, 0, d_count(d)); + cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); cmc_assert(d_push_back(d, 10)); cmc_assert(d_pop_back(d)); @@ -331,18 +368,16 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_equals(size_t, 0, d_count(d)); d_free(d); - }); - CMC_CREATE_TEST(pop_back[item preservation], { - struct deque *d = d_new(100, d_fval); + d = d_new(100, d_fval); cmc_assert_not_equals(ptr, NULL, d); - for (size_t i = 1; i <= 200; i++) - cmc_assert(d_push_back(d, i)); + for (size_t i = 1; i <= 20000; i++) + d_push_back(d, i); - for (size_t i = 0; i < 100; i++) - cmc_assert(d_pop_back(d)); + for (size_t i = 0; i < 10000; i++) + d_pop_back(d); size_t sum = 0; @@ -352,11 +387,432 @@ CMC_CREATE_UNIT(Deque, true, { sum += d->buffer[i]; } - cmc_assert_equals(size_t, 5050, sum); + cmc_assert_equals(size_t, 50005000, sum); + + d_clear(d); + + for (size_t i = 1; i <= 20000; i++) + d_push_back(d, i); + + cmc_assert_equals(size_t, 20000, d_count(d)); + + for (size_t i = 0; i < 10000; i++) + d_pop_back(d); + + sum = 0; + + for (size_t i = d->front, j = 0; j < d->count; + i = (i + 1) % d->capacity, j++) + { + sum += d->buffer[i]; + } + + cmc_assert_equals(size_t, 50005000, sum); d_free(d); }); + CMC_CREATE_TEST(PFX##_front(), { + struct deque *d = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d); + + d_front(d); + + cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d)); + + cmc_assert(d_push_front(d, 99)); + d->flag = cmc_flags.ERROR; + cmc_assert_equals(size_t, 99, d_front(d)); + + cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + + cmc_assert(d_push_back(d, 98)); + cmc_assert_equals(size_t, 99, d_front(d)); + cmc_assert(d_pop_front(d)); + cmc_assert_equals(size_t, 98, d_front(d)); + + d_clear(d); + + cmc_assert(d_push_back(d, 99)); + cmc_assert_equals(size_t, 99, d_front(d)); + + d_clear(d); + + cmc_assert_equals(size_t, 0, d_count(d)); + + for (size_t i = 1; i <= 10000; i++) + { + if (i % 2 == 0) + d_push_front(d, i); + else + d_push_back(d, i); + } + + size_t sum = 0; + for (size_t i = 0; i < 5000; i++) + { + sum += d_front(d); + cmc_assert_equals(int32_t, 0, d_front(d) % 2); + d_pop_front(d); + } + + cmc_assert_equals(size_t, 5000, d_count(d)); + cmc_assert_equals(size_t, 25005000, sum); + + d_clear(d); + + d_free(d); + }); + + CMC_CREATE_TEST(PFX##_back(), { + struct deque *d = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d); + + d_back(d); + + cmc_assert_equals(int32_t, cmc_flags.EMPTY, d_flag(d)); + + cmc_assert(d_push_back(d, 99)); + d->flag = cmc_flags.ERROR; + cmc_assert_equals(size_t, 99, d_back(d)); + + cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); + + cmc_assert(d_push_front(d, 98)); + cmc_assert_equals(size_t, 99, d_back(d)); + cmc_assert(d_pop_back(d)); + cmc_assert_equals(size_t, 98, d_back(d)); + + d_clear(d); + + cmc_assert(d_push_front(d, 99)); + cmc_assert_equals(size_t, 99, d_back(d)); + + d_clear(d); + + cmc_assert_equals(size_t, 0, d_count(d)); + + for (size_t i = 1; i <= 10000; i++) + { + if (i % 2 == 0) + d_push_back(d, i); + else + d_push_front(d, i); + } + + size_t sum = 0; + for (size_t i = 0; i < 5000; i++) + { + sum += d_back(d); + cmc_assert_equals(int32_t, 0, d_back(d) % 2); + d_pop_back(d); + } + + cmc_assert_equals(size_t, 5000, d_count(d)); + cmc_assert_equals(size_t, 25005000, sum); + + d_free(d); + }); + + CMC_CREATE_TEST(PFX##_contains(), { + struct deque *d = d_new(100, d_fval); + + for (size_t i = 0; i < 100; i++) + { + if (i % 2 == 0) + d_push_back(d, i); + else + d_push_front(d, i); + } + + for (size_t i = 0; i < 100; i++) + cmc_assert(d_contains(d, i)); + + d_free(d); + + d = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d); + + for (size_t i = 1; i <= 20; i++) + d_push_back(d, i); + + for (size_t i = 1; i <= 20; i++) + cmc_assert(d_contains(d, i)); + + d_clear(d); + + for (size_t i = 1; i <= 20; i++) + d_push_front(d, i); + + for (size_t i = 1; i <= 20; i++) + cmc_assert(d_contains(d, i)); + + d_free(d); + + d = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d); + + cmc_assert(!d_contains(d, 10)); + + d_free(d); + + d = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d); + + cmc_assert(!d_contains(d, 10)); + + cmc_assert(d_push_back(d, 100)); + + cmc_assert(d_contains(d, 100)); + cmc_assert(!d_contains(d, 101)); + + cmc_assert(d_pop_front(d)); + cmc_assert(d_push_front(d, 100)); + + cmc_assert(d_contains(d, 100)); + cmc_assert(!d_contains(d, 101)); + + d_free(d); + }); + + CMC_CREATE_TEST(PFX##_empty(), { + struct deque *d = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d); + + cmc_assert(d_empty(d)); + + cmc_assert(d_push_back(d, 1)); + + cmc_assert(!d_empty(d)); + + cmc_assert(d_pop_front(d)); + + cmc_assert(d_empty(d)); + + cmc_assert(d_push_front(d, 1)); + + cmc_assert(!d_empty(d)); + + cmc_assert(d_pop_back(d)); + + cmc_assert(d_empty(d)); + + d_free(d); + }); + + CMC_CREATE_TEST(PFX##_full(), { + struct deque *d = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d); + + cmc_assert(!d_full(d)); + + for (size_t i = 0; i != d_capacity(d); i++) + d_push_front(d, i); + + cmc_assert(d_full(d)); + + d_free(d); + }); + + CMC_CREATE_TEST(PFX##_count(), { + struct deque *d = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d); + + cmc_assert_equals(size_t, 0, d_count(d)); + + for (size_t i = 0; i < 100; i++) + d_push_back(d, i); + + cmc_assert_equals(size_t, 100, d_count(d)); + + d_free(d); + }); + + CMC_CREATE_TEST(PFX##_capacity(), { + struct deque *d = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d); + + cmc_assert_equals(size_t, 100, d_capacity(d)); + + d_free(d); + }); + + CMC_CREATE_TEST(PFX##_resize(), { + total_resize = 0; + struct deque *d = d_new_custom(100, d_fval, NULL, callbacks); + + cmc_assert_not_equals(ptr, NULL, d); + + cmc_assert_equals(size_t, 100, d_capacity(d)); + d->flag = cmc_flags.ERROR; + cmc_assert(d_resize(d, 100)); + cmc_assert_equals(size_t, 100, d_capacity(d)); + + cmc_assert_equals(int32_t, 1, total_resize); + + cmc_assert(d_resize(d, 200)); + cmc_assert_equals(size_t, 200, d_capacity(d)); + + cmc_assert(d_resize(d, 100)); + cmc_assert_equals(size_t, 100, d_capacity(d)); + + cmc_assert_equals(int32_t, 3, total_resize); + + for (size_t i = 0; i < 150; i++) + { + if (i % 2 == 0) + cmc_assert(d_push_back(d, i)); + else + cmc_assert(d_push_front(d, i)); + } + + cmc_assert_equals(size_t, 150, d_count(d)); + cmc_assert(d_resize(d, d_count(d))); + cmc_assert_equals(size_t, 150, d_capacity(d)); + + cmc_assert(!d_resize(d, d_count(d) - 10)); + cmc_assert_equals(int32_t, cmc_flags.INVALID, d_flag(d)); + + d_free(d); + + // item preservation + d = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d); + + for (size_t i = 1; i <= 150; i++) + { + if (i % 2 != 0) + cmc_assert(d_push_back(d, i)); + else + cmc_assert(d_push_front(d, i)); + } + + cmc_assert(d_resize(d, d_count(d))); + + size_t sum = 0; + + for (size_t i = d->front, j = 0; j < d->count; + i = (i + 1) % d->capacity, j++) + { + sum += d->buffer[i]; + } + + cmc_assert_equals(size_t, 11325, sum); + + d_free(d); + total_resize = 0; + }); + + CMC_CREATE_TEST(PFX##_copy_of(), { + struct deque *d1 = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d1); + + for (size_t i = 1; i <= 150; i++) + { + if (i % 2 != 0) + cmc_assert(d_push_back(d1, i)); + else + cmc_assert(d_push_front(d1, i)); + } + + struct deque *d2 = d_copy_of(d1); + + cmc_assert_not_equals(ptr, NULL, d2); + cmc_assert_equals(size_t, d_count(d1), d_count(d2)); + + 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; + } + + cmc_assert(d_push_front(d1, 10)); + cmc_assert(d_push_front(d2, 10)); + cmc_assert(d_push_back(d1, 11)); + cmc_assert(d_push_back(d2, 11)); + + cmc_assert(d_equals(d1, d2)); + + d_free(d1); + d_free(d2); + }); + + CMC_CREATE_TEST(PFX##_equals(), { + struct deque *d1 = d_new(100, d_fval); + struct deque *d2 = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d1); + cmc_assert_not_equals(ptr, NULL, d2); + + for (size_t i = 1; i <= 150; i++) + { + if (i % 2 != 0) + { + cmc_assert(d_push_back(d1, i)); + cmc_assert(d_push_back(d2, i)); + } + else + { + cmc_assert(d_push_front(d1, i)); + cmc_assert(d_push_front(d2, i)); + } + } + + cmc_assert(d_equals(d1, d2)); + + d_free(d1); + d_free(d2); + + // from copy + d1 = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d1); + + for (size_t i = 1; i <= 150; i++) + { + if (i % 2 != 0) + cmc_assert(d_push_back(d1, i)); + else + cmc_assert(d_push_front(d1, i)); + } + + d2 = d_copy_of(d1); + + cmc_assert_not_equals(ptr, NULL, d2); + + cmc_assert(d_equals(d1, d2)); + + d_free(d1); + d_free(d2); + + // count = 0 + d1 = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d1); + + d2 = d_copy_of(d1); + + cmc_assert_not_equals(ptr, NULL, d2); + + cmc_assert(d_equals(d1, d2)); + + d_free(d1); + d_free(d2); + }); + CMC_CREATE_TEST(Mixed IO, { struct deque *d = d_new(100, d_fval); @@ -421,345 +877,6 @@ CMC_CREATE_UNIT(Deque, true, { d_free(d); }); - CMC_CREATE_TEST(front[count = 0], { - struct deque *d = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d); - - size_t r = d_front(d); - - cmc_assert_equals(size_t, (size_t){ 0 }, r); - - d_free(d); - }); - - CMC_CREATE_TEST(front[sum], { - struct deque *d = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d); - - size_t sum = 0; - - for (size_t i = 0; i <= 100; i++) - { - if (i % 2 == 0) - cmc_assert(d_push_back(d, i)); - else - cmc_assert(d_push_front(d, i)); - } - - while (!d_empty(d)) - { - size_t r = d_front(d); - - sum += r; - - cmc_assert(d_pop_front(d)); - } - - cmc_assert_equals(size_t, 5050, sum); - - d_free(d); - }); - - CMC_CREATE_TEST(back[count = 0], { - struct deque *d = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d); - - size_t r = d_back(d); - - cmc_assert_equals(size_t, (size_t){ 0 }, r); - - d_free(d); - }); - - CMC_CREATE_TEST(back[sum], { - struct deque *d = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d); - - size_t sum = 0; - - for (size_t i = 0; i <= 100; i++) - { - if (i % 2 == 0) - cmc_assert(d_push_back(d, i)); - else - cmc_assert(d_push_front(d, i)); - } - - while (!d_empty(d)) - { - size_t r = d_back(d); - - sum += r; - - cmc_assert(d_pop_back(d)); - } - - cmc_assert_equals(size_t, 5050, sum); - - d_free(d); - }); - - CMC_CREATE_TEST(contains, { - struct deque *d = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d); - - for (size_t i = 1; i <= 20; i++) - cmc_assert(d_push_back(d, i)); - - for (size_t i = 1; i <= 20; i++) - cmc_assert(d_contains(d, i)); - - d_clear(d); - - for (size_t i = 1; i <= 20; i++) - cmc_assert(d_push_front(d, i)); - - for (size_t i = 1; i <= 20; i++) - cmc_assert(d_contains(d, i)); - - d_free(d); - }); - - CMC_CREATE_TEST(contains[count = 0], { - struct deque *d = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d); - - cmc_assert(!d_contains(d, 10)); - - d_free(d); - }); - - CMC_CREATE_TEST(contains[count = 1], { - struct deque *d = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d); - - cmc_assert(!d_contains(d, 10)); - - cmc_assert(d_push_back(d, 100)); - - cmc_assert(d_contains(d, 100)); - cmc_assert(!d_contains(d, 101)); - - cmc_assert(d_pop_front(d)); - cmc_assert(d_push_front(d, 100)); - - cmc_assert(d_contains(d, 100)); - cmc_assert(!d_contains(d, 101)); - - d_free(d); - }); - - CMC_CREATE_TEST(empty, { - struct deque *d = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d); - - cmc_assert(d_empty(d)); - - cmc_assert(d_push_front(d, 1)); - - cmc_assert(!d_empty(d)); - - d_free(d); - }); - - CMC_CREATE_TEST(full, { - struct deque *d = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d); - - cmc_assert(!d_full(d)); - - for (size_t i = 0; i != d_capacity(d); i++) - cmc_assert(d_push_front(d, i)); - - cmc_assert(d_full(d)); - - d_free(d); - }); - - CMC_CREATE_TEST(count, { - struct deque *d = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d); - - cmc_assert_equals(size_t, 0, d_count(d)); - - for (size_t i = 0; i < 100; i++) - cmc_assert(d_push_back(d, i)); - - cmc_assert_equals(size_t, 100, d_count(d)); - - d_free(d); - }); - - CMC_CREATE_TEST(capacity, { - struct deque *d = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d); - - cmc_assert_equals(size_t, 100, d_capacity(d)); - - d_free(d); - }); - - CMC_CREATE_TEST(resize, { - struct deque *d = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d); - - for (size_t i = 0; i < 150; i++) - { - if (i % 2 == 0) - cmc_assert(d_push_back(d, i)); - else - cmc_assert(d_push_front(d, i)); - } - - cmc_assert_equals(size_t, 150, d_count(d)); - cmc_assert(d_resize(d, d_count(d))); - cmc_assert_equals(size_t, 150, d_capacity(d)); - - d_free(d); - }); - - CMC_CREATE_TEST(resize[item preservation], { - struct deque *d = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d); - - for (size_t i = 1; i <= 150; i++) - { - if (i % 2 != 0) - cmc_assert(d_push_back(d, i)); - else - cmc_assert(d_push_front(d, i)); - } - - cmc_assert(d_resize(d, d_count(d))); - - size_t sum = 0; - - for (size_t i = d->front, j = 0; j < d->count; - i = (i + 1) % d->capacity, j++) - { - sum += d->buffer[i]; - } - - cmc_assert_equals(size_t, 11325, sum); - - d_free(d); - }); - - CMC_CREATE_TEST(copy_of, { - struct deque *d1 = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d1); - - for (size_t i = 1; i <= 150; i++) - { - if (i % 2 != 0) - cmc_assert(d_push_back(d1, i)); - else - cmc_assert(d_push_front(d1, i)); - } - - struct deque *d2 = d_copy_of(d1); - - cmc_assert_not_equals(ptr, NULL, d2); - cmc_assert_equals(size_t, d_count(d1), d_count(d2)); - - 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; - } - - cmc_assert(d_push_front(d1, 10)); - cmc_assert(d_push_front(d2, 10)); - cmc_assert(d_push_back(d1, 11)); - cmc_assert(d_push_back(d2, 11)); - - cmc_assert(d_equals(d1, d2)); - - d_free(d1); - d_free(d2); - }); - - CMC_CREATE_TEST(equals, { - struct deque *d1 = d_new(100, d_fval); - struct deque *d2 = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d1); - cmc_assert_not_equals(ptr, NULL, d2); - - for (size_t i = 1; i <= 150; i++) - { - if (i % 2 != 0) - { - cmc_assert(d_push_back(d1, i)); - cmc_assert(d_push_back(d2, i)); - } - else - { - cmc_assert(d_push_front(d1, i)); - cmc_assert(d_push_front(d2, i)); - } - } - - cmc_assert(d_equals(d1, d2)); - - d_free(d1); - d_free(d2); - }); - - CMC_CREATE_TEST(equals[from copy], { - struct deque *d1 = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d1); - - for (size_t i = 1; i <= 150; i++) - { - if (i % 2 != 0) - cmc_assert(d_push_back(d1, i)); - else - cmc_assert(d_push_front(d1, i)); - } - - struct deque *d2 = d_copy_of(d1); - - cmc_assert_not_equals(ptr, NULL, d2); - - cmc_assert(d_equals(d1, d2)); - - d_free(d1); - d_free(d2); - }); - - CMC_CREATE_TEST(equals[count = 0], { - struct deque *d1 = d_new(100, d_fval); - - cmc_assert_not_equals(ptr, NULL, d1); - - struct deque *d2 = d_copy_of(d1); - - cmc_assert_not_equals(ptr, NULL, d2); - - cmc_assert(d_equals(d1, d2)); - - d_free(d1); - d_free(d2); - }); - CMC_CREATE_TEST(buffer_growth[capacity = 1], { struct deque *d = d_new(1, d_fval);