mherrb/seatd
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

test: Add test_run and test_assert macros

Browse source 
test_run and test_assert replaces regular assert with better logging
which include the currently running test name. The tests can now also be
built without DEBUG.
This commit is contained in:
Kenny Levinsen 2020-08-31 14:30:28 +02:00
parent 8610ec4aac
commit aef19fe383
2 changed files with 96 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

23
include/test.h Normal file
View file

@ -0,0 +1,23 @@
#ifndef _TEST_H
#define _TEST_H
char *__curtestname = "<none>";
#define test_run(func) \
do { \
char *orig = __curtestname; \
__curtestname = #func; \
func(); \
__curtestname = orig; \
} while (0)
#define test_assert(cond) \
do { \
if (!(cond)) { \
fprintf(stderr, "%s:%d: %s: test_assert failed: %s\n", __FILE__, __LINE__, \
__curtestname, #cond); \
abort(); \
} \
} while (0)
#endif

146
tests/linked_list.c
View file

@ -1,9 +1,9 @@
#include <assert.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include "linked_list.h" #include "linked_list.h"
#include "test.h"
struct list_elem { struct list_elem {
struct linked_list link; struct linked_list link;
@ -15,10 +15,10 @@ static void test_linked_list_init(void) {
linked_list_init(&list); linked_list_init(&list);
// Both next and prev should point to self // Both next and prev should point to self
assert(list.next == &list && list.prev == &list); test_assert(list.next == &list && list.prev == &list);
// The list should be empty // The list should be empty
assert(linked_list_empty(&list)); test_assert(linked_list_empty(&list));
} }
static void test_linked_list_single_insert(void) { static void test_linked_list_single_insert(void) {
@ -29,14 +29,14 @@ static void test_linked_list_single_insert(void) {
linked_list_insert(&list, &elem1.link); linked_list_insert(&list, &elem1.link);
// Both next and prev on list should point to the elem // Both next and prev on list should point to the elem
assert(list.next == &elem1.link && list.prev == &elem1.link); test_assert(list.next == &elem1.link && list.prev == &elem1.link);
// Both next and prev on elem should point to the list // Both next and prev on elem should point to the list
assert(elem1.link.next == &list && elem1.link.prev == &list); test_assert(elem1.link.next == &list && elem1.link.prev == &list);
// The list and element should not be empty // The list and element should not be empty
assert(!linked_list_empty(&list)); test_assert(!linked_list_empty(&list));
assert(!linked_list_empty(&elem1.link)); test_assert(!linked_list_empty(&elem1.link));
} }
static void test_linked_list_single_remove(void) { static void test_linked_list_single_remove(void) {
@ -48,13 +48,13 @@ static void test_linked_list_single_remove(void) {
linked_list_remove(&elem1.link); linked_list_remove(&elem1.link);
// Both next and prev on elem be NULL // Both next and prev on elem be NULL
assert(elem1.link.next == NULL && elem1.link.prev == NULL); test_assert(elem1.link.next == NULL && elem1.link.prev == NULL);
// Both next and prev should point to self // Both next and prev should point to self
assert(list.next == &list && list.prev == &list); test_assert(list.next == &list && list.prev == &list);
// The list should be empty // The list should be empty
assert(linked_list_empty(&list)); test_assert(linked_list_empty(&list));
} }
static void test_linked_list_alternate_remove(void) { static void test_linked_list_alternate_remove(void) {
@ -66,13 +66,13 @@ static void test_linked_list_alternate_remove(void) {
linked_list_remove(&list); linked_list_remove(&list);
// Both next and prev on list be NULL // Both next and prev on list be NULL
assert(list.next == NULL && list.prev == NULL); test_assert(list.next == NULL && list.prev == NULL);
// Both next and prev should point to self // Both next and prev should point to self
assert(elem1.link.next == &elem1.link && elem1.link.prev == &elem1.link); test_assert(elem1.link.next == &elem1.link && elem1.link.prev == &elem1.link);
// The elem should be empty // The elem should be empty
assert(linked_list_empty(&elem1.link)); test_assert(linked_list_empty(&elem1.link));
} }
static void test_linked_list_sequential_remove(void) { static void test_linked_list_sequential_remove(void) {
@ -85,35 +85,35 @@ static void test_linked_list_sequential_remove(void) {
linked_list_insert(&elem2.link, &elem3.link); linked_list_insert(&elem2.link, &elem3.link);
// The order should now be list→elem1→elem2→elem3→list // The order should now be list→elem1→elem2→elem3→list
assert(list.next == &elem1.link && list.prev == &elem3.link); test_assert(list.next == &elem1.link && list.prev == &elem3.link);
assert(elem1.link.next == &elem2.link && elem1.link.prev == &list); test_assert(elem1.link.next == &elem2.link && elem1.link.prev == &list);
assert(elem2.link.next == &elem3.link && elem2.link.prev == &elem1.link); test_assert(elem2.link.next == &elem3.link && elem2.link.prev == &elem1.link);
assert(elem3.link.next == &list && elem3.link.prev == &elem2.link); test_assert(elem3.link.next == &list && elem3.link.prev == &elem2.link);
linked_list_remove(list.next); linked_list_remove(list.next);
// The order should now be list→elem2→elem3→list // The order should now be list→elem2→elem3→list
assert(list.next == &elem2.link && list.prev == &elem3.link); test_assert(list.next == &elem2.link && list.prev == &elem3.link);
assert(elem2.link.next == &elem3.link && elem2.link.prev == &list); test_assert(elem2.link.next == &elem3.link && elem2.link.prev == &list);
assert(elem3.link.next == &list && elem3.link.prev == &elem2.link); test_assert(elem3.link.next == &list && elem3.link.prev == &elem2.link);
assert(elem1.link.next == NULL && elem1.link.prev == NULL); test_assert(elem1.link.next == NULL && elem1.link.prev == NULL);
linked_list_remove(list.next); linked_list_remove(list.next);
// The order should now be list→elem3→list // The order should now be list→elem3→list
assert(list.next == &elem3.link && list.prev == &elem3.link); test_assert(list.next == &elem3.link && list.prev == &elem3.link);
assert(elem3.link.next == &list && elem3.link.prev == &list); test_assert(elem3.link.next == &list && elem3.link.prev == &list);
assert(elem1.link.next == NULL && elem1.link.prev == NULL); test_assert(elem1.link.next == NULL && elem1.link.prev == NULL);
assert(elem2.link.next == NULL && elem2.link.prev == NULL); test_assert(elem2.link.next == NULL && elem2.link.prev == NULL);
linked_list_remove(list.next); linked_list_remove(list.next);
// The list should now be empty // The list should now be empty
assert(elem1.link.next == NULL && elem1.link.prev == NULL); test_assert(elem1.link.next == NULL && elem1.link.prev == NULL);
assert(elem2.link.next == NULL && elem2.link.prev == NULL); test_assert(elem2.link.next == NULL && elem2.link.prev == NULL);
assert(elem3.link.next == NULL && elem3.link.prev == NULL); test_assert(elem3.link.next == NULL && elem3.link.prev == NULL);
assert(list.next == &list && list.prev == &list); test_assert(list.next == &list && list.prev == &list);
assert(linked_list_empty(&list)); test_assert(linked_list_empty(&list));
} }
static void test_linked_list_insert_after(void) { static void test_linked_list_insert_after(void) {
@ -126,10 +126,10 @@ static void test_linked_list_insert_after(void) {
linked_list_insert(&elem1.link, &elem2.link); linked_list_insert(&elem1.link, &elem2.link);
// The order should now be list→elem1→elem2→elem3→list // The order should now be list→elem1→elem2→elem3→list
assert(list.next == &elem1.link && list.prev == &elem3.link); test_assert(list.next == &elem1.link && list.prev == &elem3.link);
assert(elem1.link.next == &elem2.link && elem1.link.prev == &list); test_assert(elem1.link.next == &elem2.link && elem1.link.prev == &list);
assert(elem2.link.next == &elem3.link && elem2.link.prev == &elem1.link); test_assert(elem2.link.next == &elem3.link && elem2.link.prev == &elem1.link);
assert(elem3.link.next == &list && elem3.link.prev == &elem2.link); test_assert(elem3.link.next == &list && elem3.link.prev == &elem2.link);
} }
static void test_linked_list_remove_loop(void) { static void test_linked_list_remove_loop(void) {
@ -147,13 +147,13 @@ static void test_linked_list_remove_loop(void) {
linked_list_remove(&elem->link); linked_list_remove(&elem->link);
cnt++; cnt++;
} }
assert(cnt == 3); test_assert(cnt == 3);
// Link should now be empty, and next and prev on all elements hsould be NULL // Link should now be empty, and next and prev on all elements hsould be NULL
assert(linked_list_empty(&list)); test_assert(linked_list_empty(&list));
assert(elem1.link.next == NULL && elem1.link.prev == NULL); test_assert(elem1.link.next == NULL && elem1.link.prev == NULL);
assert(elem2.link.next == NULL && elem2.link.prev == NULL); test_assert(elem2.link.next == NULL && elem2.link.prev == NULL);
assert(elem3.link.next == NULL && elem3.link.prev == NULL); test_assert(elem3.link.next == NULL && elem3.link.prev == NULL);
} }
static void test_linked_list_manual_iterate(void) { static void test_linked_list_manual_iterate(void) {
@ -170,15 +170,15 @@ static void test_linked_list_manual_iterate(void) {
struct list_elem *ptr = NULL; struct list_elem *ptr = NULL;
ptr = (struct list_elem *)list.next; ptr = (struct list_elem *)list.next;
assert(strcmp("elem1", ptr->content) == 0); test_assert(strcmp("elem1", ptr->content) == 0);
ptr = (struct list_elem *)ptr->link.next; ptr = (struct list_elem *)ptr->link.next;
assert(strcmp("elem2", ptr->content) == 0); test_assert(strcmp("elem2", ptr->content) == 0);
ptr = (struct list_elem *)ptr->link.next; ptr = (struct list_elem *)ptr->link.next;
assert(strcmp("elem3", ptr->content) == 0); test_assert(strcmp("elem3", ptr->content) == 0);
assert(ptr->link.next == &list); test_assert(ptr->link.next == &list);
} }
static void test_linked_list_loop_iterate(void) { static void test_linked_list_loop_iterate(void) {
@ -195,10 +195,10 @@ static void test_linked_list_loop_iterate(void) {
size_t cnt = 0; size_t cnt = 0;
for (struct linked_list *ptr = list.next; ptr != &list; ptr = ptr->next) { for (struct linked_list *ptr = list.next; ptr != &list; ptr = ptr->next) {
struct list_elem *elem = (struct list_elem *)ptr; struct list_elem *elem = (struct list_elem *)ptr;
assert(strcmp("elem", elem->content) == 0); test_assert(strcmp("elem", elem->content) == 0);
cnt++; cnt++;
} }
assert(cnt == 3); test_assert(cnt == 3);
} }
static void test_linked_list_take_empty(void) { static void test_linked_list_take_empty(void) {
@ -208,8 +208,8 @@ static void test_linked_list_take_empty(void) {
linked_list_take(&list2, &list1); linked_list_take(&list2, &list1);
assert(linked_list_empty(&list1)); test_assert(linked_list_empty(&list1));
assert(linked_list_empty(&list2)); test_assert(linked_list_empty(&list2));
} }
static void test_linked_list_take_single(void) { static void test_linked_list_take_single(void) {
@ -222,9 +222,9 @@ static void test_linked_list_take_single(void) {
linked_list_take(&list2, &list1); linked_list_take(&list2, &list1);
assert(linked_list_empty(&list1)); test_assert(linked_list_empty(&list1));
assert(list2.next == &elem1.link && list2.prev == &elem1.link); test_assert(list2.next == &elem1.link && list2.prev == &elem1.link);
assert(elem1.link.next == &list2 && elem1.link.prev == &list2); test_assert(elem1.link.next == &list2 && elem1.link.prev == &list2);
} }
static void test_linked_list_take_many(void) { static void test_linked_list_take_many(void) {
@ -239,10 +239,10 @@ static void test_linked_list_take_many(void) {
linked_list_take(&list2, &list1); linked_list_take(&list2, &list1);
assert(linked_list_empty(&list1)); test_assert(linked_list_empty(&list1));
assert(list2.next == &elem1.link && list2.prev == &elem2.link); test_assert(list2.next == &elem1.link && list2.prev == &elem2.link);
assert(elem1.link.next == &elem2.link && elem1.link.prev == &list2); test_assert(elem1.link.next == &elem2.link && elem1.link.prev == &list2);
assert(elem2.link.next == &list2 && elem2.link.prev == &elem1.link); test_assert(elem2.link.next == &list2 && elem2.link.prev == &elem1.link);
} }
static void test_linked_list_take_concat(void) { static void test_linked_list_take_concat(void) {
@ -261,31 +261,31 @@ static void test_linked_list_take_concat(void) {
linked_list_take(&list2, &list1); linked_list_take(&list2, &list1);
assert(linked_list_empty(&list1)); test_assert(linked_list_empty(&list1));
assert(list2.next == &elem1.link && list2.prev == &elem4.link); test_assert(list2.next == &elem1.link && list2.prev == &elem4.link);
assert(elem1.link.next == &elem2.link && elem1.link.prev == &list2); test_assert(elem1.link.next == &elem2.link && elem1.link.prev == &list2);
assert(elem2.link.next == &elem3.link && elem2.link.prev == &elem1.link); test_assert(elem2.link.next == &elem3.link && elem2.link.prev == &elem1.link);
assert(elem3.link.next == &elem4.link && elem3.link.prev == &elem2.link); test_assert(elem3.link.next == &elem4.link && elem3.link.prev == &elem2.link);
assert(elem4.link.next == &list2 && elem4.link.prev == &elem3.link); test_assert(elem4.link.next == &list2 && elem4.link.prev == &elem3.link);
} }
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
(void)argc; (void)argc;
(void)argv; (void)argv;
test_linked_list_init(); test_run(test_linked_list_init);
test_linked_list_single_insert(); test_run(test_linked_list_single_insert);
test_linked_list_single_remove(); test_run(test_linked_list_single_remove);
test_linked_list_alternate_remove(); test_run(test_linked_list_alternate_remove);
test_linked_list_sequential_remove(); test_run(test_linked_list_sequential_remove);
test_linked_list_insert_after(); test_run(test_linked_list_insert_after);
test_linked_list_remove_loop(); test_run(test_linked_list_remove_loop);
test_linked_list_manual_iterate(); test_run(test_linked_list_manual_iterate);
test_linked_list_loop_iterate(); test_run(test_linked_list_loop_iterate);
test_linked_list_take_empty(); test_run(test_linked_list_take_empty);
test_linked_list_take_single(); test_run(test_linked_list_take_single);
test_linked_list_take_many(); test_run(test_linked_list_take_many);
test_linked_list_take_concat(); test_run(test_linked_list_take_concat);
return 0; return 0;
} }