admin/C-Macro-Collections
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reworked assert.h and test.h and added the cmc prefix to the logging utility

Browse Source 
Integrated the assert utility with the test utility. Now any assertion that fails inside the unit test will trigger failure and is no longer needed to manually pass or fail a test.
Also reworked makefiles.
This commit is contained in:
Leonardo committed 2019-09-06 12:17:11 -03:00
1 parent abdbfa2018
commit 1928fdd6d5
20 files changed
+368 -414
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

tests/main/Makefile
+9 -1
View File
@@ -4,7 +4,7 @@ CFLAGS += -Wno-unused-function -Wno-unused-parameter -Wno-unused-variable -Wno-u
CVFLAGS = --coverage -O0
INCLUDE = ../../src/
main:
main: FORCE
$(CC) main.c -o main $(CFLAGS) $(CVFLAGS) -I $(INCLUDE)
./main
gcov ./main.c
@@ -14,3 +14,11 @@ dev:
./main
gcov ./main.c -n
rm *.gcda *.gcno *.exe
windev:
$(CC) main.c -o main $(CFLAGS) $(CVFLAGS) -I $(INCLUDE)
./main
gcov ./main.c -n
del *.gcda *.gcno *.exe
FORCE:
tests/main/main.c
+15 -13
View File
@@ -14,20 +14,22 @@
int main(void)
{
deque_test();
hashmap_test();
hashset_test();
heap_test();
linkedlist_test();
list_test();
queue_test();
stack_test();
treemap_test();
treeset_test();
uintmax_t failed = 0;
failed += deque_test();
failed += hashmap_test();
failed += hashset_test();
failed += heap_test();
failed += linkedlist_test();
failed += list_test();
failed += queue_test();
failed += stack_test();
failed += treemap_test();
failed += treeset_test();
/* ext */
multimap_test();
multiset_test();
failed += multimap_test();
failed += multiset_test();
return 0;
return failed;
}
tests/main/unt/deque.c
+1 -14
View File
@@ -7,14 +7,9 @@ CMC_CREATE_UNIT(deque_test, true, {
deque *d = d_new(1000000);
cmc_assert_not_equals(ptr, NULL, d);
bool passed = d->capacity == 1000000 && d->count == 0 && d->buffer;
cmc_assert_not_equals(ptr, NULL, d->buffer);
cmc_assert_equals(size_t, 1000000, d->capacity);
cmc_assert_equals(size_t, 0, d_count(d));
cmc_assert_not_equals(ptr, NULL, d->buffer);
CMC_TEST_PASS_ELSE_FAIL(passed);
d_free(d);
});
@@ -23,16 +18,12 @@ CMC_CREATE_UNIT(deque_test, true, {
deque *d = d_new(0);
cmc_assert_equals(ptr, NULL, d);
CMC_TEST_PASS_ELSE_FAIL(d == NULL);
});
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
deque *d = d_new(UINT64_MAX);
cmc_assert_equals(ptr, NULL, d);
CMC_TEST_PASS_ELSE_FAIL(d == NULL);
});
CMC_CREATE_TEST(clear[count capacity], {
@@ -50,8 +41,6 @@ CMC_CREATE_UNIT(deque_test, true, {
cmc_assert_equals(size_t, 0, d_count(d));
cmc_assert_equals(size_t, 100, d_capacity(d));
CMC_TEST_PASS_ELSE_FAIL(d_count(d) == 0 && d_capacity(d) == 100);
d_free(d);
});
@@ -66,8 +55,6 @@ CMC_CREATE_UNIT(deque_test, true, {
cmc_assert_equals(size_t, 50, d_count(d));
cmc_assert_lesser_equals(size_t, d_capacity(d), d_count(d));
CMC_TEST_PASS_ELSE_FAIL(d_count(d) == 50 && d_count(d) <= d_capacity(d));
d_free(d);
});
tests/main/unt/hashmap.c
+2 -10
View File
@@ -8,13 +8,11 @@ CMC_CREATE_UNIT(hashmap_test, true, {
CMC_CREATE_TEST(new, {
hashmap *map = hm_new(943722, 0.6, cmp, hash);
bool passed = (map->capacity >= (943722 / 0.6)) && map->count == 0 && map->buffer;
cmc_assert_not_equals(ptr, NULL, map);
cmc_assert_not_equals(ptr, NULL, map->buffer);
cmc_assert_equals(size_t, 0, hm_count(map));
cmc_assert_greater_equals(size_t, (943722 / 0.6), hm_capacity(map));
CMC_TEST_PASS_ELSE_FAIL(passed);
hm_free(map);
});
@@ -22,16 +20,12 @@ CMC_CREATE_UNIT(hashmap_test, true, {
hashmap *map = hm_new(0, 0.6, cmp, hash);
cmc_assert_equals(ptr, NULL, map);
CMC_TEST_PASS_ELSE_FAIL(map == NULL);
});
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
hashmap *map = hm_new(UINT64_MAX, 0.6, cmp, hash);
cmc_assert_equals(ptr, NULL, map);
CMC_TEST_PASS_ELSE_FAIL(map == NULL);
});
CMC_CREATE_TEST(clear[count capacity], {
@@ -48,8 +42,6 @@ CMC_CREATE_UNIT(hashmap_test, true, {
cmc_assert_equals(size_t, 0, hm_count(map));
CMC_TEST_PASS_ELSE_FAIL(hm_count(map) == 0);
hm_free(map);
});
tests/main/unt/hashset.c
+3 -11
View File
@@ -8,12 +8,10 @@ CMC_CREATE_UNIT(hashset_test, true, {
CMC_CREATE_TEST(new, {
hashset *set = hs_new(943722, 0.6, cmp, hash);
bool passed = (set->capacity >= (943722 / 0.6)) && set->count == 0 && set->buffer;
cmc_assert_not_equals(ptr, NULL, set);
cmc_assert(hs_capacity(set) > (943722 / 0.6));
CMC_TEST_PASS_ELSE_FAIL(passed);
cmc_assert_not_equals(ptr, NULL, set->buffer);
cmc_assert_equals(size_t, 0, hs_count(set));
cmc_assert_greater_equals(size_t, (943722 / 0.6), hs_capacity(set));
hs_free(set);
});
@@ -22,16 +20,12 @@ CMC_CREATE_UNIT(hashset_test, true, {
hashset *set = hs_new(0, 0.6, cmp, hash);
cmc_assert_equals(ptr, NULL, set);
CMC_TEST_PASS_ELSE_FAIL(set == NULL);
});
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
hashset *set = hs_new(UINT64_MAX, 0.6, cmp, hash);
cmc_assert_equals(ptr, NULL, set);
CMC_TEST_PASS_ELSE_FAIL(set == NULL);
});
CMC_CREATE_TEST(clear[count capacity], {
@@ -48,8 +42,6 @@ CMC_CREATE_UNIT(hashset_test, true, {
cmc_assert_equals(size_t, 0, hs_count(set));
CMC_TEST_PASS_ELSE_FAIL(hs_count(set) == 0);
hs_free(set);
});
tests/main/unt/heap.c
+2 -15
View File
@@ -9,14 +9,9 @@ CMC_CREATE_UNIT(heap_test, true, {
heap *h = h_new(1000000, cmc_max_heap, cmp);
cmc_assert_not_equals(ptr, NULL, h);
bool passed = h->capacity == 1000000 && h->count == 0 && h->buffer;
cmc_assert_equals(size_t, 1000000, h->capacity);
cmc_assert_equals(size_t, 0, h_count(h));
cmc_assert_not_equals(ptr, NULL, h->buffer);
CMC_TEST_PASS_ELSE_FAIL(passed);
cmc_assert_equals(size_t, 1000000, h_capacity(h));
cmc_assert_equals(size_t, 0, h_count(h));
h_free(h);
});
@@ -25,16 +20,12 @@ CMC_CREATE_UNIT(heap_test, true, {
heap *h = h_new(0, cmc_max_heap, cmp);
cmc_assert_equals(ptr, NULL, h);
CMC_TEST_PASS_ELSE_FAIL(h == NULL);
});
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
heap *h = h_new(UINT64_MAX, cmc_max_heap, cmp);
cmc_assert_equals(ptr, NULL, h);
CMC_TEST_PASS_ELSE_FAIL(h == NULL);
});
CMC_CREATE_TEST(clear[count capacity], {
@@ -52,8 +43,6 @@ CMC_CREATE_UNIT(heap_test, true, {
cmc_assert_equals(size_t, 0, h_count(h));
cmc_assert_equals(size_t, 100, h_capacity(h));
CMC_TEST_PASS_ELSE_FAIL(h_count(h) == 0 && h_capacity(h) == 100);
h_free(h);
});
@@ -67,8 +56,6 @@ CMC_CREATE_UNIT(heap_test, true, {
cmc_assert_equals(size_t, 50, h_count(h));
CMC_TEST_PASS_ELSE_FAIL(h_count(h) == 50);
h_free(h);
});
tests/main/unt/linkedlist.c
-19
View File
@@ -7,15 +7,10 @@ CMC_CREATE_UNIT(linkedlist_test, true, {
linkedlist *ll = ll_new();
cmc_assert_not_equals(ptr, NULL, ll);
bool passed = ll->count == 0 && ll->head == NULL && ll->tail == NULL;
cmc_assert_equals(size_t, 0, ll_count(ll));
cmc_assert_equals(ptr, NULL, ll->head);
cmc_assert_equals(ptr, NULL, ll->tail);
CMC_TEST_PASS_ELSE_FAIL(passed);
ll_free(ll);
});
@@ -33,8 +28,6 @@ CMC_CREATE_UNIT(linkedlist_test, true, {
cmc_assert_equals(size_t, 0, ll_count(ll));
CMC_TEST_PASS_ELSE_FAIL(ll_count(ll) == 0);
ll_free(ll);
});
@@ -47,8 +40,6 @@ CMC_CREATE_UNIT(linkedlist_test, true, {
cmc_assert_equals(size_t, 0, ll_count(ll));
CMC_TEST_PASS_ELSE_FAIL(ll_count(ll) == 0);
ll_free(ll);
});
@@ -63,8 +54,6 @@ CMC_CREATE_UNIT(linkedlist_test, true, {
cmc_assert_not_equals(ptr, NULL, ll->tail);
cmc_assert_equals(size_t, 1, ll_count(ll));
CMC_TEST_PASS_ELSE_FAIL(ll->head && ll->tail && ll_count(ll) == 1);
ll_free(ll);
});
@@ -76,16 +65,8 @@ CMC_CREATE_UNIT(linkedlist_test, true, {
for (size_t i = 0; i < 200; i++)
ll_push_front(ll, i);
bool passed = true;
for (size_t i = 0; i < ll_count(ll); i++)
{
passed = passed && ll_get(ll, i) == (ll_count(ll) - i - 1);
cmc_assert_equals(size_t, ll_get(ll, i), ll_count(ll) - i - 1);
}
CMC_TEST_PASS_ELSE_FAIL(passed && ll_count(ll) == 200);
ll_free(ll);
});
tests/main/unt/list.c
+5 -90
View File
@@ -7,14 +7,9 @@ CMC_CREATE_UNIT(list_test, true, {
list *l = l_new(1000000);
cmc_assert_not_equals(ptr, NULL, l);
bool passed = l->capacity == 1000000 && l->count == 0 && l->buffer;
cmc_assert_equals(size_t, 1000000, l->capacity);
cmc_assert_equals(size_t, 0, l_count(l));
cmc_assert_not_equals(ptr, NULL, l->buffer);
CMC_TEST_PASS_ELSE_FAIL(passed);
cmc_assert_equals(size_t, 1000000, l_capacity(l));
cmc_assert_equals(size_t, 0, l_count(l));
l_free(l);
});
@@ -23,16 +18,12 @@ CMC_CREATE_UNIT(list_test, true, {
list *l = l_new(0);
cmc_assert_equals(ptr, NULL, l);
CMC_TEST_PASS_ELSE_FAIL(l == NULL);
});
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
list *l = l_new(UINT64_MAX);
cmc_assert_equals(ptr, NULL, l);
CMC_TEST_PASS_ELSE_FAIL(l == NULL);
});
CMC_CREATE_TEST(new_from[count item_preservation], {
@@ -47,17 +38,9 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_not_equals(ptr, NULL, l);
bool passed = true;
for (size_t i = 0; i < 5; i++)
{
cmc_assert_equals(size_t, i, l_get(l, i));
passed = passed && l_get(l, i) == i;
}
CMC_TEST_PASS_ELSE_FAIL(passed && l_count(l) == 5);
l_free(l);
});
@@ -70,8 +53,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_not_equals(ptr, NULL, l);
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 1);
l_free(l);
});
@@ -90,8 +71,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_equals(size_t, 0, l_count(l));
cmc_assert_equals(size_t, 100, l_capacity(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 0 && l_capacity(l) == 100);
l_free(l);
});
@@ -105,15 +84,8 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_equals(size_t, 100, l_count(l));
bool passed = true;
for (size_t i = 0; i < 100; i++)
{
passed = passed && l_get(l, i) == i;
cmc_assert_equals(size_t, i, l_get(l, i));
}
CMC_TEST_PASS_ELSE_FAIL(passed);
l_free(l);
});
@@ -128,8 +100,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_equals(size_t, 250, l_count(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 250);
l_free(l);
});
@@ -143,8 +113,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) <= l_capacity(l));
l_free(l);
});
@@ -156,16 +124,8 @@ CMC_CREATE_UNIT(list_test, true, {
for (size_t i = 0; i < 250; i++)
cmc_assert(l_push_front(l, i));
bool passed = true;
for (size_t i = 0; i < l_count(l); i++)
{
passed = passed && l_get(l, i) == (l_count(l) - i - 1);
cmc_assert_equals(size_t, l_get(l, i), l_count(l) - i - 1);
}
CMC_TEST_PASS_ELSE_FAIL(passed);
l_free(l);
});
@@ -183,8 +143,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_equals(size_t, 250, l_count(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 250);
l_free(l);
});
@@ -201,8 +159,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) <= l_capacity(l));
l_free(l);
});
@@ -217,16 +173,8 @@ CMC_CREATE_UNIT(list_test, true, {
for (size_t i = 1; i < 249; i++)
cmc_assert(l_push(l, i, l_count(l) - 1));
bool passed = true;
for (size_t i = 0; i < l_count(l); i++)
{
passed = passed && l_get(l, i) == i;
cmc_assert_equals(size_t, l_get(l, i), i);
}
CMC_TEST_PASS_ELSE_FAIL(passed);
l_free(l);
});
@@ -241,8 +189,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_equals(size_t, 250, l_count(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 250);
l_free(l);
});
@@ -256,8 +202,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) <= l_capacity(l));
l_free(l);
});
@@ -269,16 +213,8 @@ CMC_CREATE_UNIT(list_test, true, {
for (size_t i = 0; i < 250; i++)
cmc_assert(l_push_back(l, i));
bool passed = true;
for (size_t i = 0; i < l_count(l); i++)
{
passed = passed && l_get(l, i) == i;
cmc_assert_equals(size_t, l_get(l, i), i);
}
CMC_TEST_PASS_ELSE_FAIL(passed);
l_free(l);
});
@@ -293,8 +229,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert(l_pop_front(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 250 - 1);
l_free(l);
});
@@ -306,16 +240,10 @@ CMC_CREATE_UNIT(list_test, true, {
for (size_t i = 0; i < 250; i++)
l_push_back(l, i);
bool passed = l_pop_front(l);
cmc_assert(l_pop_front(l));
for (size_t i = 0; i < l_count(l); i++)
{
passed = passed && l_get(l, i) == i + 1;
cmc_assert_equals(size_t, l_get(l, i), i + 1);
}
CMC_TEST_PASS_ELSE_FAIL(passed);
l_free(l);
});
@@ -325,7 +253,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_not_equals(ptr, NULL, l);
cmc_assert(!l_pop_front(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 0);
l_free(l);
});
@@ -337,8 +264,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert(l_push_back(l, 10));
cmc_assert(l_pop_front(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 0);
l_free(l);
});
@@ -349,12 +274,10 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert(l_push_back(l, 1));
cmc_assert(l_push_front(l, 2));
bool passed = l_pop_front(l) && l->buffer[1] == 0;
cmc_assert(l_pop_front(l));
cmc_assert_equals(size_t, 0, l->buffer[1]);
CMC_TEST_PASS_ELSE_FAIL(passed && l_count(l) == 1);
l_free(l);
});
@@ -364,8 +287,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_not_equals(ptr, NULL, l);
cmc_assert(!l_pop(l, 1));
CMC_TEST_PASS_ELSE_FAIL(!l_pop(l, 1));
l_free(l);
});
@@ -374,8 +295,7 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_not_equals(ptr, NULL, l);
cmc_assert(l_push_back(l, 1));
CMC_TEST_PASS_ELSE_FAIL(l_pop(l, 0));
cmc_assert(l_pop(l, 0));
cmc_assert_equals(size_t, 0, l->buffer[0]);
@@ -391,8 +311,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert(l_push_back(l, 3));
cmc_assert(l_pop(l, 1));
CMC_TEST_PASS_ELSE_FAIL(0 == l->buffer[2]);
l_free(l);
});
@@ -401,7 +319,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert_not_equals(ptr, NULL, l);
cmc_assert(!l_pop_back(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 0);
l_free(l);
});
@@ -413,8 +330,6 @@ CMC_CREATE_UNIT(list_test, true, {
cmc_assert(l_push_back(l, 10));
cmc_assert(l_pop_back(l));
CMC_TEST_PASS_ELSE_FAIL(l_count(l) == 0);
l_free(l);
});
})
tests/main/unt/multimap.c
+2 -24
View File
@@ -8,13 +8,11 @@ CMC_CREATE_UNIT(multimap_test, true, {
CMC_CREATE_TEST(new, {
multimap *map = mm_new(943722, 0.8, cmp, hash);
bool passed = (map->capacity >= (943722 / 0.8)) && map->count == 0 && map->buffer;
cmc_assert_not_equals(ptr, NULL, map);
cmc_assert_not_equals(ptr, NULL, map->buffer);
cmc_assert_equals(size_t, 0, mm_count(map));
cmc_assert_greater_equals(size_t, (943722 / 0.8), mm_capacity(map));
CMC_TEST_PASS_ELSE_FAIL(passed);
mm_free(map);
});
@@ -22,16 +20,12 @@ CMC_CREATE_UNIT(multimap_test, true, {
multimap *map = mm_new(0, 0.8, cmp, hash);
cmc_assert_equals(ptr, NULL, map);
CMC_TEST_PASS_ELSE_FAIL(map == NULL);
});
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
multimap *map = mm_new(UINT64_MAX, 0.8, cmp, hash);
cmc_assert_equals(ptr, NULL, map);
CMC_TEST_PASS_ELSE_FAIL(map == NULL);
});
CMC_CREATE_TEST(clear[count capacity], {
@@ -48,8 +42,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert_equals(size_t, 0, mm_count(map));
CMC_TEST_PASS_ELSE_FAIL(mm_count(map) == 0);
mm_free(map);
});
@@ -63,8 +55,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert_equals(size_t, 200, mm_count(map));
CMC_TEST_PASS_ELSE_FAIL(mm_count(map) == 200);
mm_free(map);
});
@@ -83,8 +73,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert_equals(size_t, 140, mm_count(map));
CMC_TEST_PASS_ELSE_FAIL(mm_count(map) == 140);
mm_free(map);
});
@@ -97,8 +85,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert(!mm_remove(map, 10, &r));
CMC_TEST_PASS_ELSE_FAIL(!mm_remove(map, 10, &r));
mm_free(map);
});
@@ -112,8 +98,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert(mm_insert(map, 10, 11));
cmc_assert(mm_remove(map, 10, &r));
CMC_TEST_PASS_ELSE_FAIL(mm_count(map) == 0);
mm_free(map);
});
@@ -127,8 +111,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert_equals(size_t, 50, mm_count(map));
CMC_TEST_PASS_ELSE_FAIL(mm_count(map) == 50);
mm_free(map);
});
@@ -147,8 +129,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert_equals(size_t, 50, mm_count(map));
CMC_TEST_PASS_ELSE_FAIL(mm_count(map) == 50);
mm_free(map);
});
@@ -165,8 +145,6 @@ CMC_CREATE_UNIT(multimap_test, true, {
cmc_assert_equals(size_t, 100, mm_get(map, 10));
CMC_TEST_PASS_ELSE_FAIL(mm_get(map, 10) == 100);
mm_free(map);
});
tests/main/unt/multiset.c
+5 -21
View File
@@ -8,12 +8,10 @@ CMC_CREATE_UNIT(multiset_test, true, {
CMC_CREATE_TEST(new, {
multiset *set = ms_new(943722, 0.6, cmp, hash);
bool passed = (set->capacity >= (943722 / 0.6)) && set->count == 0 && set->buffer;
cmc_assert_not_equals(ptr, NULL, set);
cmc_assert(ms_capacity(set) > (943722 / 0.6));
CMC_TEST_PASS_ELSE_FAIL(passed);
cmc_assert_not_equals(ptr, NULL, set->buffer);
cmc_assert_equals(size_t, 0, ms_count(set));
cmc_assert_greater_equals(size_t, ((size_t)(943722 / 0.6)), ms_capacity(set));
ms_free(set);
});
@@ -22,16 +20,12 @@ CMC_CREATE_UNIT(multiset_test, true, {
multiset *set = ms_new(0, 0.6, cmp, hash);
cmc_assert_equals(ptr, NULL, set);
CMC_TEST_PASS_ELSE_FAIL(set == NULL);
});
CMC_CREATE_TEST(new[edge_case:capacity = UINTMAX_MAX], {
multiset *set = ms_new(UINTMAX_MAX, 0.99, cmp, hash);
cmc_assert_equals(ptr, NULL, set);
CMC_TEST_PASS_ELSE_FAIL(set == NULL);
});
CMC_CREATE_TEST(clear[count capacity], {
@@ -48,8 +42,6 @@ CMC_CREATE_UNIT(multiset_test, true, {
cmc_assert_equals(size_t, 0, ms_count(set));
CMC_TEST_PASS_ELSE_FAIL(ms_count(set) == 0);
ms_free(set);
});
@@ -68,12 +60,8 @@ CMC_CREATE_UNIT(multiset_test, true, {
cmc_assert_equals(size_t, 3, ms_count(set));
cmc_assert_equals(size_t, 6, ms_cardinality(set));
bool passed = ms_count(set) == 3 && ms_cardinality(set) == 6;
for (size_t i = 0; i <= 3; i++)
passed = passed && ms_multiplicity_of(set, i) == i;
CMC_TEST_PASS_ELSE_FAIL(passed);
cmc_assert_equals(size_t, i, ms_multiplicity_of(set, i));
ms_free(set);
});
@@ -89,12 +77,8 @@ CMC_CREATE_UNIT(multiset_test, true, {
cmc_assert_equals(size_t, 20, ms_count(set));
cmc_assert_equals(size_t, 100, ms_cardinality(set));
bool passed = ms_count(set) == 20 && ms_cardinality(set) == 100;
for (size_t i = 0; i < 20; i++)
passed = passed && ms_multiplicity_of(set, i) == 5;
CMC_TEST_PASS_ELSE_FAIL(passed);
cmc_assert_equals(size_t, 5, ms_multiplicity_of(set, i));
ms_free(set);
});
tests/main/unt/queue.c
+4 -16
View File
@@ -7,15 +7,11 @@ CMC_CREATE_UNIT(queue_test, true, {
queue *q = q_new(1000000);
cmc_assert_not_equals(ptr, NULL, q);
bool passed = q->capacity == 1000000 && q->count == 0 && q->buffer;
cmc_assert_equals(size_t, 1000000, q->capacity);
cmc_assert_not_equals(ptr, NULL, q->buffer);
cmc_assert_equals(size_t, 1000000, q_capacity(q));
cmc_assert_equals(size_t, 0, q_count(q));
cmc_assert_not_equals(ptr, NULL, q->buffer);
CMC_TEST_PASS_ELSE_FAIL(passed);
q_free(q);
});
@@ -23,16 +19,12 @@ CMC_CREATE_UNIT(queue_test, true, {
queue *q = q_new(0);
cmc_assert_equals(ptr, NULL, q);
CMC_TEST_PASS_ELSE_FAIL(q == NULL);
});
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
queue *q = q_new(UINT64_MAX);
cmc_assert_equals(ptr, NULL, q);
CMC_TEST_PASS_ELSE_FAIL(q == NULL);
});
CMC_CREATE_TEST(clear[count capacity], {
@@ -41,7 +33,7 @@ CMC_CREATE_UNIT(queue_test, true, {
cmc_assert_not_equals(ptr, NULL, q);
for (size_t i = 0; i < 50; i++)
q_enqueue(q, i);
cmc_assert(q_enqueue(q, i));
cmc_assert_equals(size_t, 50, q_count(q));
@@ -50,8 +42,6 @@ CMC_CREATE_UNIT(queue_test, true, {
cmc_assert_equals(size_t, 0, q_count(q));
cmc_assert_equals(size_t, 100, q_capacity(q));
CMC_TEST_PASS_ELSE_FAIL(q_count(q) == 0 && q_capacity(q) == 100);
q_free(q);
});
@@ -61,12 +51,10 @@ CMC_CREATE_UNIT(queue_test, true, {
cmc_assert_not_equals(ptr, NULL, q);
for (size_t i = 0; i < 50; i++)
q_enqueue(q, i);
cmc_assert(q_enqueue(q, i));
cmc_assert_equals(size_t, 50, q_count(q));
CMC_TEST_PASS_ELSE_FAIL(q_count(q) == 50);
q_free(q);
});
tests/main/unt/stack.c
+6 -118
View File
@@ -9,15 +9,11 @@ CMC_CREATE_UNIT(stack_test, true, {
stack *s = s_new(1000000);
cmc_assert_not_equals(ptr, NULL, s);
bool passed = s->capacity == 1000000 && s->count == 0 && s->buffer;
cmc_assert_equals(size_t, 1000000, s->capacity);
cmc_assert_not_equals(ptr, NULL, s->buffer);
cmc_assert_equals(size_t, 1000000, s_capacity(s));
cmc_assert_equals(size_t, 0, s_count(s));
cmc_assert_not_equals(ptr, NULL, s->buffer);
CMC_TEST_PASS_ELSE_FAIL(passed);
s_free(s);
});
@@ -25,16 +21,12 @@ CMC_CREATE_UNIT(stack_test, true, {
stack *s = s_new(0);
cmc_assert_equals(ptr, NULL, s);
CMC_TEST_PASS_ELSE_FAIL(s == NULL);
});
CMC_CREATE_TEST(new[edge_case:capacity = UINT64_MAX], {
stack *s = s_new(UINT64_MAX);
cmc_assert_equals(ptr, NULL, s);
CMC_TEST_PASS_ELSE_FAIL(s == NULL);
});
CMC_CREATE_TEST(clear[count capacity], {
@@ -52,8 +44,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 0, s_count(s));
cmc_assert_equals(size_t, 100, s_capacity(s));
CMC_TEST_PASS_ELSE_FAIL(s_count(s) == 0 && s_capacity(s) == 100);
s_free(s);
});
@@ -68,8 +58,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 50, s_count(s));
cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s));
CMC_TEST_PASS_ELSE_FAIL(s_count(s) == 50 && s_count(s) <= s_capacity(s));
s_free(s);
});
@@ -83,8 +71,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 250, s_count(s));
CMC_TEST_PASS_ELSE_FAIL(s_count(s) == 250);
s_free(s);
});
@@ -98,8 +84,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s));
CMC_TEST_PASS_ELSE_FAIL(s_count(s) <= s_capacity(s));
s_free(s);
});
@@ -111,16 +95,8 @@ CMC_CREATE_UNIT(stack_test, true, {
for (size_t i = 0; i < 250; i++)
cmc_assert(s_push(s, i));
bool passed = true;
for (size_t i = 0; i < s_count(s); i++)
{
passed = s->buffer[i] == i;
cmc_assert_equals(size_t, i, s->buffer[i]);
}
CMC_TEST_PASS_ELSE_FAIL(passed);
s_free(s);
});
@@ -137,8 +113,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 249, s_count(s));
CMC_TEST_PASS_ELSE_FAIL(s_count(s) == 249);
s_free(s);
});
@@ -154,8 +128,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_lesser_equals(size_t, s_capacity(s), s_count(s));
CMC_TEST_PASS_ELSE_FAIL(s_count(s) <= s_capacity(s));
s_free(s);
});
@@ -170,16 +142,8 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert(s_pop(s));
cmc_assert(s_pop(s));
bool passed = true;
for (size_t i = 0; i < s_count(s); i++)
{
passed = s->buffer[i] == i;
cmc_assert_equals(size_t, i, s->buffer[i]);
}
CMC_TEST_PASS_ELSE_FAIL(passed);
s_free(s);
});
@@ -191,8 +155,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(bool, false, s_pop(s));
CMC_TEST_PASS_ELSE_FAIL(!s_pop(s));
s_free(s);
});
@@ -204,16 +166,8 @@ CMC_CREATE_UNIT(stack_test, true, {
for (size_t i = 0; i < 250; i++)
s_push_if(s, i, i % 2 == 0);
bool passed = true;
for (size_t i = 0; i < s_count(s); i++)
{
passed = passed && s->buffer[i] % 2 == 0;
cmc_assert(s->buffer[i] % 2 == 0);
}
CMC_TEST_PASS_ELSE_FAIL(passed);
s_free(s);
});
@@ -229,16 +183,8 @@ CMC_CREATE_UNIT(stack_test, true, {
s_pop_if(s, s_top(s) % 2 == 0);
}
bool passed = true;
for (size_t i = 0; i < s_count(s); i++)
{
passed = passed && !(s->buffer[i] % 2 == 0);
cmc_assert(!(s->buffer[i] % 2 == 0));
}
CMC_TEST_PASS_ELSE_FAIL(passed);
cmc_assert_not_equals(uint32_t, 0, s->buffer[i] % 2);
s_free(s);
});
@@ -256,8 +202,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 247, s_top(s));
CMC_TEST_PASS_ELSE_FAIL(247 == s_top(s));
s_free(s);
});
@@ -272,8 +216,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, s_impl_default_value(), s_top(s));
CMC_TEST_PASS_ELSE_FAIL(s_impl_default_value() == s_top(s));
s_free(s);
});
@@ -286,8 +228,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 1, s_count(s));
cmc_assert_equals(size_t, 10, s_top(s));
CMC_TEST_PASS_ELSE_FAIL(10 == s_top(s));
s_free(s);
});
@@ -299,12 +239,8 @@ CMC_CREATE_UNIT(stack_test, true, {
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);
cmc_assert(s_contains(s, i, cmp));
s_free(s);
});
@@ -316,8 +252,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(bool, false, s_contains(s, 10, cmp));
CMC_TEST_PASS_ELSE_FAIL(!s_contains(s, 10, cmp));
s_free(s);
});
@@ -328,8 +262,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert(s_empty(s));
CMC_TEST_PASS_ELSE_FAIL(s_empty(s));
s_free(s);
});
@@ -342,8 +274,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert(s_pop(s));
cmc_assert(s_empty(s));
CMC_TEST_PASS_ELSE_FAIL(s_empty(s));
s_free(s);
});
@@ -357,8 +287,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert(s_full(s));
CMC_TEST_PASS_ELSE_FAIL(s_full(s));
s_free(s);
});
@@ -371,8 +299,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert(s_full(s));
CMC_TEST_PASS_ELSE_FAIL(s_full(s));
s_free(s);
});
@@ -385,8 +311,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_not_equals(ptr, NULL, iter);
CMC_TEST_PASS_ELSE_FAIL(s && iter);
s_iter_free(iter);
s_free(s);
});
@@ -405,10 +329,6 @@ CMC_CREATE_UNIT(stack_test, true, {
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);
});
@@ -421,7 +341,7 @@ CMC_CREATE_UNIT(stack_test, true, {
s_iter_init(&iter, s);
CMC_TEST_PASS_ELSE_FAIL(s_iter_start(&iter));
cmc_assert(s_iter_start(&iter));
s_free(s);
});
@@ -435,7 +355,7 @@ CMC_CREATE_UNIT(stack_test, true, {
s_iter_init(&iter, s);
CMC_TEST_PASS_ELSE_FAIL(s_iter_end(&iter));
cmc_assert(s_iter_end(&iter));
s_free(s);
});
@@ -464,8 +384,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 40200, total);
CMC_TEST_PASS_ELSE_FAIL(total == 40200);
s_free(s);
});
@@ -496,8 +414,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 40200, total);
CMC_TEST_PASS_ELSE_FAIL(total == 40200);
s_free(s);
});
@@ -521,8 +437,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 20, total);
CMC_TEST_PASS_ELSE_FAIL(total == 20);
s_free(s);
});
@@ -552,8 +466,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 2000, total);
CMC_TEST_PASS_ELSE_FAIL(total == 2000);
s_free(s);
});
@@ -565,7 +477,6 @@ CMC_CREATE_UNIT(stack_test, true, {
for (size_t i = 0; i < 50; i++)
cmc_assert(s_push(s, i));
bool passed = true;
stack_iter it1;
stack_iter it2;
@@ -581,7 +492,6 @@ CMC_CREATE_UNIT(stack_test, true, {
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);
@@ -590,9 +500,6 @@ CMC_CREATE_UNIT(stack_test, true, {
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);
});
@@ -608,14 +515,10 @@ CMC_CREATE_UNIT(stack_test, true, {
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);
});
@@ -634,14 +537,10 @@ CMC_CREATE_UNIT(stack_test, true, {
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);
});
@@ -657,8 +556,6 @@ CMC_CREATE_UNIT(stack_test, true, {
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);
});
@@ -673,8 +570,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(ptr, NULL, s_iter_rvalue(&iter));
CMC_TEST_PASS_ELSE_FAIL(NULL == s_iter_rvalue(&iter));
s_free(s);
});
@@ -688,18 +583,15 @@ CMC_CREATE_UNIT(stack_test, true, {
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));
}
@@ -717,8 +609,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 90, total);
CMC_TEST_PASS_ELSE_FAIL(passed && total == 90);
s_free(s);
});
@@ -732,8 +622,6 @@ CMC_CREATE_UNIT(stack_test, true, {
cmc_assert_equals(size_t, 0, s_iter_index(&iter));
CMC_TEST_PASS_ELSE_FAIL(0 == s_iter_index(&iter));
s_free(s);
});
tests/main/unt/treemap.c
-4
View File
@@ -10,8 +10,6 @@ CMC_CREATE_UNIT(treemap_test, true, {
cmc_assert_not_equals(ptr, NULL, map);
CMC_TEST_PASS_ELSE_FAIL(map);
tm_free(map);
});
@@ -30,8 +28,6 @@ CMC_CREATE_UNIT(treemap_test, true, {
cmc_assert_equals(size_t, 0, tm_count(map));
cmc_assert_equals(ptr, NULL, map->root);
CMC_TEST_PASS_ELSE_FAIL(tm_count(map) == 0);
tm_free(map);
});
tests/main/unt/treeset.c
-5
View File
@@ -10,8 +10,6 @@ CMC_CREATE_UNIT(treeset_test, true, {
cmc_assert_not_equals(ptr, NULL, set);
CMC_TEST_PASS_ELSE_FAIL(set);
ts_free(set);
});
@@ -30,9 +28,6 @@ CMC_CREATE_UNIT(treeset_test, true, {
cmc_assert_equals(size_t, 0, ts_count(set));
cmc_assert_equals(ptr, NULL, set->root);
CMC_TEST_PASS_ELSE_FAIL(ts_count(set) == 0);
ts_free(set);
});