Adding more deque tests and valgrind option to tests makefile
Also added a nice header for the main unit test
This commit is contained in:
Leonardo Vencovsky committed
1 parent
64201cb630
commit
af5abff115
3 files changed
+499
-364
No files matched your search
@@ -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:
|
||||
@@ -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);
|
||||
|
||||
+481
-364
@@ -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);
|
||||
|
||||
|
||||
Reference in new issue
Block a user