diff options
Diffstat (limited to 'src/test/lily-test.h')
| -rw-r--r-- | src/test/lily-test.h | 837 |
1 files changed, 647 insertions, 190 deletions
diff --git a/src/test/lily-test.h b/src/test/lily-test.h index b5f380c..8b1d9ad 100644 --- a/src/test/lily-test.h +++ b/src/test/lily-test.h @@ -11,7 +11,8 @@ * Permission is hereby granted, free of charge, to any person or * organization (the "User") obtaining a copy of this software and associated * documentation files (the "Software"), to use, copy, modify, merge, - * distribute, and/or sell copies of the Software, subject to the following conditions: + * distribute, and/or sell copies of the Software, subject to the following + * conditions: * * 1. The above copyright notice and this permission notice shall be included * in all copies or modified versions of the Software. @@ -45,7 +46,7 @@ #ifndef LILY_TEST_H #define LILY_TEST_H -#define LILY_VERSION_MAJOR 1 +#define LILY_VERSION_MAJOR 2 #define LILY_VERSION_MINOR 0 #define LILY_VERSION_PATCH 0 @@ -53,211 +54,667 @@ #include <stddef.h> #include <stdint.h> #include <setjmp.h> +#include <stdio.h> +#include <stdarg.h> +#include <stdlib.h> +#include <math.h> #define STR_IMP(x) #x #define STR(x) STR_IMP(x) /* define SOURCE_PATH_SIZE to strip away the - leading parts of the full compilation path */ + leading parts of the full compilation path */ #ifndef SOURCE_PATH_SIZE #define LILY_LOCATION (__FILE__ ":" STR(__LINE__)) #else #define LILY_LOCATION ((__FILE__ ":" STR(__LINE__)) + SOURCE_PATH_SIZE) #endif -/** a few nasty globals that make everything clean for the end user */ -struct lily_globals_t { - jmp_buf env; - size_t error_msg_len; - char *error_msg; - const char *error_location; -}; -extern struct lily_globals_t _lily_globals; - -typedef void (*lily_test_t)(void); - -/** run a single test */ -#define lily_run_test(test) _lily_run_test(#test, test) -void _lily_run_test(const char *name, lily_test_t test); - -/** run a suite */ -#define lily_run_suite(suite) _lily_run_suite(#suite, suite) -void _lily_run_suite(const char *name, lily_test_t suite); - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * assertions - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -/** basic assertion function, mostly used by the other assertions */ -void lily_assert_msg(bool statement, const char *location, - const char *format_string, ...); - -#define lily_assert_true(statement) _lily_assert_true(#statement, statement, LILY_LOCATION) -void _lily_assert_true(const char *statement, bool value, const char *location); - - -#define lily_assert_false(statement) _lily_assert_false(#statement, statement, LILY_LOCATION) -void _lily_assert_false(const char *statement, bool value, const char *location); - - -#define lily_assert_not_null(ptr) _lily_assert_not_null(#ptr, ptr, LILY_LOCATION) -void _lily_assert_not_null(const char *name, void *ptr, const char *location); - - -#define lily_assert_null(ptr) _lily_assert_null(#ptr, ptr, LILY_LOCATION) -void _lily_assert_null(const char *name, void *ptr, const char *location); - - -#define lily_assert_ptr_equal(a, b) _lily_assert_ptr_equal(#a, #b, a, b, LILY_LOCATION) -void _lily_assert_ptr_equal(const char *name_a, const char *name_b, - void *a, void *b, const char *location); - - -#define lily_assert_ptr_not_equal(a, b) _lily_assert_ptr_not_equal(#a, #b, a, b, LILY_LOCATION) -void _lily_assert_ptr_not_equal(const char *name_a, const char *name_b, - void *a, void *b, const char *location); - - -#define lily_assert_int_equal(a, b) _lily_assert_int_equal(#a, #b, a, b, LILY_LOCATION) -void _lily_assert_int_equal(const char *name_a, const char *name_b, - intmax_t a, intmax_t b, const char *location); - - -#define lily_assert_int_not_equal(a, b) _lily_assert_int_not_equal(#a, #b, a, b, LILY_LOCATION) -void _lily_assert_int_not_equal(const char *name_a, const char *name_b, - intmax_t a, intmax_t b, const char *location); - -#define lily_assert_float_equal(a, b, epsilon) \ - _lily_assert_float_equal(#a, #b, a, b, epsilon, LILY_LOCATION) -void _lily_assert_float_equal(const char *name_a, const char *name_b, - double a, double b, double epsilon, const char *location); - - -#define lily_assert_float_not_equal(a, b, epsilon) \ - _lily_assert_float_not_equal(#a, #b, a, b, epsilon, LILY_LOCATION) -void _lily_assert_float_not_equal(const char *name_a, const char *name_b, - double a, double b, double epsilon, const char *location); - - -#define lily_assert_string_equal(a, b) _lily_assert_string_equal(#a, #b, a, b, LILY_LOCATION) -void _lily_assert_string_equal(const char *name_a, const char *name_b, - char *a, char *b, const char *location); - - -#define lily_assert_string_not_equal(a, b) _lily_assert_string_not_equal(#a, #b, a, b, LILY_LOCATION) -void _lily_assert_string_not_equal(const char *name_a, const char *name_b, - char *a, char *b, const char *location); - - -#define lily_assert_memory_equal(a, b, size) \ - _lily_assert_memory_equal(#a, #b, a, b, size, LILY_LOCATION) -void _lily_assert_memory_equal(const char *name_a, const char *name_b, - void *a, void *b, size_t size, const char *location); - - -#define lily_assert_memory_not_equal(a, b, size) \ - _lily_assert_memory_not_equal(#a, #b, a, b, size, LILY_LOCATION) -void _lily_assert_memory_not_equal(const char *name_a, const char *name_b, - void *a, void *b, size_t size, const char *location); - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * mocks - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - - -/** queue structure capable of containing arbitrary data */ -typedef struct lily_queue_t { - size_t buf_size; - uint8_t *buf; - uint8_t *front, *back; -} lily_queue_t; +/* self-location macro */ +#ifndef LILY_TEST_H_LOCATION +#define LILY_TEST_H_LOCATION "lily-test.h" +#endif -/** create a queue */ -lily_queue_t* lily_queue_create(); +/* counter macros */ +#define LILY_HEX_(x) 0x##x +#define LILY_HEX(x) LILY_HEX_(x) +#define LILY_COUNTER_POS_0 0 +#define LILY_COUNTER_POS_1 0 +#define LILY_COUNTER_POS_2 0 +#define LILY_COUNTER__(a, b, c) 0x##a##b##c +#define LILY_COUNTER_(a, b, c) LILY_COUNTER__(a, b, c) +#define LILY_COUNTER LILY_COUNTER_(LILY_COUNTER_POS_2, LILY_COUNTER_POS_1, LILY_COUNTER_POS_0) + +/* automatic registration macros */ +typedef struct lily_ll_node_t { + struct lily_ll_node_t *next; + void (*f)(); +} lily_ll_node_t; +#define LILY_FILE_BEGIN(unique_id) \ +static lily_ll_node_t lily_ll_last = { NULL, NULL }; \ +static void file_runner(); \ +void (*unique_id)() = file_runner; + +#define LILY_LIST_HEAD lily_ll_last +#define LILY_LIST_NEXT lily_ll_last +#define LILY_PUSH_TEST() LILY_TEST_H_LOCATION +#define LILY_REGISTER_TESTS() LILY_TEST_H_LOCATION + +#define LILY_CAT_(x, y) x##y +#define LILY_CAT(x, y) LILY_CAT_(x, y) +#define LILY_ANON(x) LILY_CAT(x, LILY_COUNTER) +#define LILY_ANON_WRAP LILY_ANON(LILY_WRAP_) +#define LILY_ANON_FUNC LILY_ANON(LILY_FUNCTION_) +#define LILY_ANON_NODE LILY_ANON(LILY_NODE_) +#define LILY_ANON_DESC LILY_ANON(LILY_DESCRIPTION_) + +#define LILY_TEST_(wrap, f, desc_str, description) \ +static void f(); \ +static void wrap() \ +{ \ + lily_g.test_name = description; \ + f(); \ +} \ +static void f() + +#define LILY_TEST(description) LILY_TEST_(LILY_ANON_WRAP, LILY_ANON_FUNC, LILY_ANON_DESC, description) + +/* assertions */ +typedef struct lily_test_msg_t { + struct lily_test_msg_t *next; + char *msg; + const char *location; +} lily_test_msg_t; +void lily_msg_destroy(lily_test_msg_t *m); + +void lily_info(const char *location, const char *fmt, ...); +#define LILY_INFO_(location, ...) \ + lily_info(location, __VA_ARGS__) +#define LILY_INFO(...) LILY_INFO_(LILY_LOCATION, __VA_ARGS__) +#define INFO(...) LILY_INFO(__VA_ARGS__) + +void lily_check(int x, const char *location, const char *fmt, ...); +#define LILY_CHECK_(str, x, location) \ + lily_check(x, location, "CHECK failed: %s", str) +#define LILY_CHECK(x) LILY_CHECK_(STR(x), x, LILY_LOCATION) +#define CHECK(x) LILY_CHECK(x) + +#define LILY_CHECK_CMP_(x, y, xstr, ystr, cmp, cmpstr, fmt) \ + lily_check(x cmp y, LILY_LOCATION, \ + "CHECK failed: %s " cmpstr " %s\n %s = " fmt "\n %s = " fmt,\ + xstr, ystr, xstr, x, ystr, y) +#define LILY_CHECK_CMP(x, cmp, y, fmt) LILY_CHECK_CMP_(x, y, #x, #y, cmp, #cmp, fmt) + +/* check comparision assertions */ +#define CHECK_EQ(x, y, fmt) LILY_CHECK_CMP(x, ==, y, fmt) +#define CHECK_NEQ(x, y, fmt) LILY_CHECK_CMP(x, !=, y, fmt) +#define CHECK_LT(x, y, fmt) LILY_CHECK_CMP(x, <, y, fmt) +#define CHECK_LE(x, y, fmt) LILY_CHECK_CMP(x, <=, y, fmt) +#define CHECK_GT(x, y, fmt) LILY_CHECK_CMP(x, >, y, fmt) +#define CHECK_GE(x, y, fmt) LILY_CHECK_CMP(x, >=, y, fmt) + +#define LILY_CHECK_EQF(x, y, xstr, ystr, fmt) \ + lily_check(fabs(x-y) < lily_g.epsilon, LILY_LOCATION, \ + "CHECK failed: %s == %s\n %s = " fmt "\n %s = " fmt "\n epsilon: %f", \ + xstr, ystr, xstr, x, ystr, y, lily_g.epsilon) +#define CHECK_EQF(x, y, fmt) LILY_CHECK_EQF(x, y, #x, #y, fmt) + +#define LILY_CHECK_EQS(x, y, xstr, ystr) \ + lily_check(strcmp(x, y) == 0, LILY_LOCATION, \ + "CHECK failed: %s == %s\n %s = \"%s\"\n %s = \"%s\"", \ + xstr, ystr, xstr, x, ystr, y) +#define CHECK_EQS(x, y) LILY_CHECK_EQS(x, y, #x, #y) + + +void lily_require(int x, const char *location, const char *fmt, ...); +#define LILY_REQUIRE_(str, x, location) \ + lily_require(x, location, "REQUIRE failed: %s", str) +#define LILY_REQUIRE(x) LILY_REQUIRE_(STR(x), x, LILY_LOCATION) +#define REQUIRE(x) LILY_REQUIRE(x) + +#define LILY_REQUIRE_CMP_(x, y, xstr, ystr, cmp, cmpstr, fmt) \ + lily_require(x cmp y, LILY_LOCATION, \ + "REQUIRE failed: %s " cmpstr " %s\n %s = " fmt "\n %s = " fmt,\ + xstr, ystr, xstr, x, ystr, y) +#define LILY_REQUIRE_CMP(x, cmp, y, fmt) LILY_REQUIRE_CMP_(x, y, #x, #y, cmp, #cmp, fmt) + +/* require comparison assertions */ +#define REQUIRE_EQ(x, y, fmt) LILY_REQUIRE_CMP(x, ==, y, fmt) +#define REQUIRE_NEQ(x, y, fmt) LILY_REQUIRE_CMP(x, !=, y, fmt) +#define REQUIRE_LT(x, y, fmt) LILY_REQUIRE_CMP(x, <, y, fmt) +#define REQUIRE_LE(x, y, fmt) LILY_REQUIRE_CMP(x, <=, y, fmt) +#define REQUIRE_GT(x, y, fmt) LILY_REQUIRE_CMP(x, >, y, fmt) +#define REQUIRE_GE(x, y, fmt) LILY_REQUIRE_CMP(x, >=, y, fmt) + +#define LILY_REQUIRE_EQF(x, y, xstr, ystr, fmt) \ + lily_require(fabs(x-y) < lily_g.epsilon, LILY_LOCATION, \ + "REQUIRE failed: %s == %s\n %s = " fmt "\n %s = " fmt "\n epsilon: %f", \ + xstr, ystr, xstr, x, ystr, y, lily_g.epsilon) +#define REQUIRE_EQF(x, y, fmt) LILY_REQUIRE_EQF(x, y, #x, #y, fmt) + +#define LILY_REQUIRE_EQS(x, y, xstr, ystr) \ + lily_require(strcmp(x, y) == 0, LILY_LOCATION, \ + "REQUIRE failed: %s == %s\n %s = \"%s\"\n %s = \"%s\"", \ + xstr, ystr, xstr, x, ystr, y) +#define REQUIRE_EQS(x, y) LILY_REQUIRE_EQS(x, y, #x, #y) + + +void lily_begin(); +void lily_finish(); +void lily_run_test(void (*test)()); +void lily_set_epsilon(double epsilon); + + +struct lily_global_t { + int failed; + jmp_buf env; + const char *test_name; + lily_test_msg_t HEAD; + lily_test_msg_t *TAIL; + int n_assertions; + int n_assertions_failed; + int n_tests; + int n_tests_failed; + double epsilon; +} extern lily_g; + +#ifdef LILY_IMPLEMENTATION +struct lily_global_t lily_g; + +lily_test_msg_t *lily_msg_create(const char *location, const char *fmt, va_list args) +{ + lily_test_msg_t *m = malloc(sizeof(lily_test_msg_t)); + if (m == NULL) { + return NULL; + } + m->next = NULL; + m->location = location; + + va_list args_len; + va_copy(args_len, args); + size_t len = vsnprintf(NULL, 0, fmt, args_len) + 1; + va_end(args_len); + + m->msg = malloc(len * sizeof(char)); + if (m->msg == NULL) { + free(m); + return NULL; + } + vsnprintf(m->msg, len, fmt, args); + + return m; +} + +void lily_msg_destroy(lily_test_msg_t *m) +{ + if (m == NULL) { + /* ignore */ + return; + } + + if (m->next != NULL) { + // destroy the whole chain + lily_msg_destroy(m->next); + } + + free(m->msg); + free(m); +} + + +void lily_run_test(void (*test)()) +{ + lily_g.n_tests += 1; + lily_g.HEAD.next = NULL; + lily_g.TAIL = &(lily_g.HEAD); + lily_g.failed = 0; + int jumped = setjmp(lily_g.env); + + if (!jumped) { + test(); + } + + if (lily_g.failed) { + lily_g.n_tests_failed += 1; + printf("================================================================================\n"); + printf("test \"%s\" failed!\n\n", lily_g.test_name); + lily_test_msg_t *n = lily_g.HEAD.next; + while(n != NULL) { + printf(" %s\n [%s]\n\n", n->msg, n->location); + n = n->next; + } + lily_msg_destroy(lily_g.HEAD.next); + } +} + + +void lily_info(const char *location, const char *fmt, ...) +{ + va_list args; + va_start(args, fmt); + lily_test_msg_t *m = lily_msg_create(location, fmt, args); + va_end(args); + + lily_g.TAIL->next = m; + lily_g.TAIL = m; +} + +void lily_check(int x, const char *location, const char *fmt, ...) +{ + lily_g.n_assertions += 1; + if (!x) { + // assertion failed + lily_g.n_assertions_failed += 1; + + va_list args; + va_start(args, fmt); + lily_test_msg_t *m = lily_msg_create(location, fmt, args); + va_end(args); + + lily_g.TAIL->next = m; + lily_g.TAIL = m; + lily_g.failed = 1; + } +} + + +void lily_require(int x, const char *location, const char *fmt, ...) +{ + lily_g.n_assertions += 1; + if (!x) { + // assertion failed + lily_g.n_assertions_failed += 1; + + va_list args; + va_start(args, fmt); + lily_test_msg_t *m = lily_msg_create(location, fmt, args); + va_end(args); + + lily_g.TAIL->next = m; + lily_g.TAIL = m; + lily_g.failed = 1; + + /* longjump out of test */ + longjmp(lily_g.env, 1); + } +} + + +void lily_begin() +{ + lily_g.n_tests = 0; + lily_g.n_tests_failed = 0; + lily_g.n_assertions_failed = 0; + lily_g.n_assertions_failed = 0; + lily_g.epsilon = 1e-3; + + printf("================================================================================\n"); + printf("lily-test version %d.%d.%d\n", LILY_VERSION_MAJOR, LILY_VERSION_MINOR, LILY_VERSION_PATCH); +} + + +void lily_finish() +{ + printf("================================================================================\n"); + printf("ran %d tests (%d failed)\n", + lily_g.n_tests, lily_g.n_tests_failed); + printf("checked %d asserts (%d failed)\n", + lily_g.n_assertions, lily_g.n_assertions_failed); +} + + +void lily_set_epsilon(double epsilon) +{ + lily_g.epsilon = epsilon; +} +#endif -/** destroy a queue */ -void lily_queue_destroy(lily_queue_t *q); +/* ifdef LILY_TEST_H */ +#else +/* counter incrementing */ +/* this counter can count up to 4096, but it should be pretty trivial to extend it more or less arbitrarily far */ +/* to increment the counter, just #define LILY_COUNTER_INCREMENT and then include this file again */ +#ifdef LILY_COUNTER_INCREMENT +#undef LILY_COUNTER_INCREMENT + /* ones position */ +# if LILY_HEX(LILY_COUNTER_POS_0) == 0 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 1 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 1 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 2 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 2 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 3 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 3 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 4 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 4 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 5 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 5 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 6 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 6 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 7 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 7 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 8 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 8 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 9 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 9 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 a +# elif LILY_HEX(LILY_COUNTER_POS_0) == 10 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 b +# elif LILY_HEX(LILY_COUNTER_POS_0) == 11 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 c +# elif LILY_HEX(LILY_COUNTER_POS_0) == 12 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 d +# elif LILY_HEX(LILY_COUNTER_POS_0) == 13 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 e +# elif LILY_HEX(LILY_COUNTER_POS_0) == 14 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 f +# elif LILY_HEX(LILY_COUNTER_POS_0) == 15 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 0 + /* sixteens position */ +# if LILY_HEX(LILY_COUNTER_POS_1) == 0 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 1 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 1 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 2 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 2 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 3 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 3 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 4 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 4 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 5 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 5 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 6 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 6 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 7 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 7 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 8 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 8 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 9 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 9 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 a +# elif LILY_HEX(LILY_COUNTER_POS_1) == 10 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 b +# elif LILY_HEX(LILY_COUNTER_POS_1) == 11 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 c +# elif LILY_HEX(LILY_COUNTER_POS_1) == 12 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 d +# elif LILY_HEX(LILY_COUNTER_POS_1) == 13 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 e +# elif LILY_HEX(LILY_COUNTER_POS_1) == 14 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 f +# elif LILY_HEX(LILY_COUNTER_POS_1) == 15 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 0 + /* 256s position */ +# if LILY_HEX(LILY_COUNTER_POS_2) == 0 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 1 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 1 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 2 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 2 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 3 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 3 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 4 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 4 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 5 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 5 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 6 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 6 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 7 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 7 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 8 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 8 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 9 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 9 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 a +# elif LILY_HEX(LILY_COUNTER_POS_2) == 10 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 b +# elif LILY_HEX(LILY_COUNTER_POS_2) == 11 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 c +# elif LILY_HEX(LILY_COUNTER_POS_2) == 12 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 d +# elif LILY_HEX(LILY_COUNTER_POS_2) == 13 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 e +# elif LILY_HEX(LILY_COUNTER_POS_2) == 14 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 f +# elif LILY_HEX(LILY_COUNTER_POS_2) == 15 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 0 +# endif +# endif +# endif + +#elif defined(LILY_COUNTER_DECREMENT) +#undef LILY_COUNTER_DECREMENT + /* ones position */ +# if LILY_HEX(LILY_COUNTER_POS_0) == 15 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 e +# elif LILY_HEX(LILY_COUNTER_POS_0) == 14 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 d +# elif LILY_HEX(LILY_COUNTER_POS_0) == 13 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 c +# elif LILY_HEX(LILY_COUNTER_POS_0) == 12 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 b +# elif LILY_HEX(LILY_COUNTER_POS_0) == 11 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 a +# elif LILY_HEX(LILY_COUNTER_POS_0) == 10 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 9 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 9 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 8 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 8 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 7 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 7 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 6 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 6 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 5 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 5 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 4 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 4 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 3 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 3 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 2 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 2 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 1 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 1 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 0 +# elif LILY_HEX(LILY_COUNTER_POS_0) == 0 +# undef LILY_COUNTER_POS_0 +# define LILY_COUNTER_POS_0 f + /* sixteens position */ +# if LILY_HEX(LILY_COUNTER_POS_1) == 15 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 e +# elif LILY_HEX(LILY_COUNTER_POS_1) == 14 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 d +# elif LILY_HEX(LILY_COUNTER_POS_1) == 13 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 c +# elif LILY_HEX(LILY_COUNTER_POS_1) == 12 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 b +# elif LILY_HEX(LILY_COUNTER_POS_1) == 11 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 a +# elif LILY_HEX(LILY_COUNTER_POS_1) == 10 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 9 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 9 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 8 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 8 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 7 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 7 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 6 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 6 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 5 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 5 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 4 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 4 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 3 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 3 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 2 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 2 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 1 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 1 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 0 +# elif LILY_HEX(LILY_COUNTER_POS_1) == 0 +# undef LILY_COUNTER_POS_1 +# define LILY_COUNTER_POS_1 f + /* 256s position */ +# if LILY_HEX(LILY_COUNTER_POS_2) == 15 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 e +# elif LILY_HEX(LILY_COUNTER_POS_2) == 14 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 d +# elif LILY_HEX(LILY_COUNTER_POS_2) == 13 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 c +# elif LILY_HEX(LILY_COUNTER_POS_2) == 12 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 b +# elif LILY_HEX(LILY_COUNTER_POS_2) == 11 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 a +# elif LILY_HEX(LILY_COUNTER_POS_2) == 10 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 9 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 9 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 8 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 8 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 7 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 7 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 6 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 6 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 5 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 5 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 4 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 4 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 3 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 3 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 2 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 2 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 1 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 1 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 0 +# elif LILY_HEX(LILY_COUNTER_POS_2) == 0 +# undef LILY_COUNTER_POS_2 +# define LILY_COUNTER_POS_2 f +# endif +# endif +# endif + + +#elif defined(LILY_FILE_END) +/* ending a file */ + +/* LILY_LIST_HEAD is one too high, so we decrement */ +#define LILY_COUNTER_DECREMENT +#include LILY_TEST_H_LOCATION + +void file_runner() +{ + lily_ll_node_t *n = &LILY_LIST_HEAD; + while (n->next != NULL) { + lily_run_test(n->f); + n = n->next; + } +} -/** enqueue a value - * - * q - the queue to append to - * type - the type of the value to append - * value - the value to append - */ -#define lily_enqueue(q, type, value) \ - do { \ - type _var = value; \ - _lily_enqueue(q, sizeof(type), (uint8_t*)(&_var)); \ - } while(0) -void _lily_enqueue(lily_queue_t *q, size_t size, uint8_t *data); - - -/** pop a value from the queue - * - * q - the queue to pop from - * type - the type of the value to pop - * ptr - the location to store the popped value - */ -#define lily_dequeue(q, type, ptr) \ - _lily_dequeue(q, sizeof(type), (uint8_t*) ptr) -void _lily_dequeue(lily_queue_t *q, size_t size, uint8_t *ptr); - - -struct lily_mock_arg_t { - size_t size; - void *var; +#else +/* register new test */ + +static lily_ll_node_t LILY_ANON_NODE = { +#define LILY_COUNTER_DECREMENT +#include LILY_TEST_H_LOCATION + &LILY_LIST_HEAD, +#define LILY_COUNTER_INCREMENT +#include LILY_TEST_H_LOCATION + LILY_ANON_WRAP, }; +#undef LILY_LIST_HEAD +#define LILY_LIST_HEAD LILY_ANON_NODE +#define LILY_COUNTER_INCREMENT +#include LILY_TEST_H_LOCATION -#define LILY_NARGS(args) (sizeof(args)/sizeof(struct lily_mock_arg_t)) - -/** structure to store data for mock functions */ -typedef struct lily_mock_t { - unsigned int n_calls; - lily_queue_t *arguments; - lily_queue_t *values; -} lily_mock_t; - -/** setup mock function storage */ -lily_mock_t * lily_mock_create(); -/** tear down mock function storage */ -void lily_mock_destroy(lily_mock_t *m); -/** automatically re-create mock function storage */ -void lily_mock_use(lily_mock_t **m); - -/** store a call to a mock function */ -#define lily_mock_store_call(m, args) \ - _lily_mock_call(m, args, LILY_NARGS(args)) -/* lily_mock_call is deprecated!! do not use it in new programs */ -#define lily_mock_call(m, args) \ - _lily_mock_call(m, args, LILY_NARGS(args)) -void _lily_mock_call(lily_mock_t *m, struct lily_mock_arg_t *args, size_t n_args); - -/** retrieve a call to a mock function */ -#define lily_mock_get_call(m, args, call_num) \ - _lily_get_call(m, args, LILY_NARGS(args), call_num) -/* lily_get_call is deprecated!! do not use it in new programs */ -#define lily_get_call(m, args, call_num) \ - _lily_get_call(m, args, LILY_NARGS(args), call_num) -void _lily_get_call(lily_mock_t *m, - struct lily_mock_arg_t *args, - size_t n_args, - unsigned int call_num); - -/** store a value in a mock structure */ -#define lily_store_value(m, type, value) \ - lily_enqueue(m->values, type, value) -/** retrieve a value from a mock structure */ -#define lily_get_value(m, type, ptr) \ - lily_dequeue(m->values, type, ptr) +#endif #endif |