From 13a7c902c051fa8da1e476687c17bb5431d258e1 Mon Sep 17 00:00:00 2001 From: sanine Date: Tue, 3 Jan 2023 23:31:48 -0600 Subject: add kai_expand_array --- src/test/lily-test.c | 366 ---------------------- src/test/lily-test.h | 837 +++++++++++++++++++++++++++++++++++++++------------ src/test/test.c | 7 +- src/test/test.h | 13 +- 4 files changed, 659 insertions(+), 564 deletions(-) delete mode 100644 src/test/lily-test.c (limited to 'src/test') diff --git a/src/test/lily-test.c b/src/test/lily-test.c deleted file mode 100644 index 30f96d5..0000000 --- a/src/test/lily-test.c +++ /dev/null @@ -1,366 +0,0 @@ -/**************************************************************** - * - * ======== lily-test ======== - * - * a midsize C unit testing library - * copyright (c) 2022 kate swanson (sanine) - * - * This is anti-capitalist software, released for free use by individuals and - * organizations that do not operate by capitalist principles. - * - * 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: - * - * 1. The above copyright notice and this permission notice shall be included - * in all copies or modified versions of the Software. - * - * 2. The User is one of the following: - * a. An individual person, laboring for themselves - * b. A non-profit organization - * c. An educational institution - * d. An organization that seeks shared profit for all of its members, and - * allows non-members to set the cost of their labor - * - * 3. If the User is an organization with owners, then all owners are workers - * and all workers are owners with equal equity and/or equal vote. - * - * 4. If the User is an organization, then the User is not law enforcement or - * military, or working for or under either. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT EXPRESS OR IMPLIED WARRANTY OF - * ANY KIND, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN - * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN - * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - * - * https://anticapitalist.software/ - * https://sanine.net - * - ****************************************************************/ - - -#include -#include -#include -#include -#include -#include "lily-test.h" - -struct lily_globals_t _lily_globals = { {0}, 0, NULL, "" }; - -/* run an individual test */ -void _lily_run_test(const char *name, lily_test_t test) -{ - printf(" %s: ", name); - - _lily_globals.error_msg = NULL; - _lily_globals.error_location = ""; - int val = setjmp(_lily_globals.env); - - if (val) { - /* test failed */ - printf("FAIL - %s (%s)\n", - _lily_globals.error_msg, - _lily_globals.error_location); - free(_lily_globals.error_msg); /* error message was allocated! */ - return; - } - - test(); - - /* test succeeded */ - printf("OK\n"); -} - -/* run a suite */ -void _lily_run_suite(const char *name, lily_test_t suite) -{ - printf("=== %s ===\n", name); - suite(); - printf("\n"); -} - - -/* ======== ASSERTIONS ======== */ - -static void _lily_assert_msg(bool statement, const char *location, - const char *format_string, va_list args) -{ - if (statement) { - va_end(args); - return; // no error, return - } - - _lily_globals.error_location = location; - - va_list args_len; - va_copy(args_len, args); - size_t length = vsnprintf(NULL, 0, format_string, args_len); - va_end(args_len); - - if (_lily_globals.error_msg_len < length+1 || - _lily_globals.error_msg == NULL) { - if (_lily_globals.error_msg != NULL) - free(_lily_globals.error_msg); - - char *msg = malloc((length+2) * sizeof(char)); - - if (msg == NULL) { - fprintf(stderr, "WARNING: failed to allocate memory for failed test message!\n"); - _lily_globals.error_msg = NULL; - va_end(args); - longjmp(_lily_globals.env, 1); - return; - } - else { - _lily_globals.error_msg = msg; - _lily_globals.error_msg_len = length+1; - } - } - - vsnprintf(_lily_globals.error_msg, length+1, format_string, args); - - va_end(args); - longjmp(_lily_globals.env, 1); -} - - -void lily_assert_msg(bool statement, const char *location, - const char *format_string, ...) -{ - va_list args; - va_start(args, format_string); - // _lily_assert_msg may long jump, so it takes calls va_end(args) for you - _lily_assert_msg(statement, location, format_string, args); -} - - -void _lily_assert_true(const char *statement, bool value, const char *location) -{ - lily_assert_msg(value, location, - "%s is not true", - statement); -} - - -void _lily_assert_false(const char *statement, bool value, const char *location) -{ - lily_assert_msg(!value, location, - "%s is not false", - statement); -} - - -void _lily_assert_not_null(const char *name, void *ptr, const char *location) -{ - lily_assert_msg(ptr != NULL, location, - "%s is NULL", - name); -} - - -void _lily_assert_null(const char *name, void *ptr, const char *location) -{ - lily_assert_msg(ptr == NULL, location, - "%s (%p) is not NULL", - name, ptr); -} - - -void _lily_assert_ptr_equal(const char *name_a, const char *name_b, - void *a, void *b, const char *location) -{ - lily_assert_msg(a == b, location, - "%s (%p) is not equal to %s (%p)", - name_a, a, name_b, b); -} - - -void _lily_assert_ptr_not_equal(const char *name_a, const char *name_b, - void *a, void *b, const char *location) -{ - lily_assert_msg(a != b, location, - "%s (%p) is equal to %s", - name_a, a, name_b); -} - - -void _lily_assert_int_equal(const char *name_a, const char *name_b, - intmax_t a, intmax_t b, const char *location) -{ - lily_assert_msg(a == b, location, - "%s (%d) is not equal to %s (%d)", - name_a, a, name_b, b); -} - - -void _lily_assert_int_not_equal(const char *name_a, const char *name_b, - intmax_t a, intmax_t b, const char *location) -{ - lily_assert_msg(a != b, location, - "%s (%d) is equal to %s", - name_a, a, name_b); -} - - -void _lily_assert_float_equal(const char *name_a, const char *name_b, - double a, double b, double epsilon, const char *location) -{ - lily_assert_msg(fabs(a - b) <= epsilon, location, - "%s (%f) is not equal to %s (%f) (epsilon: %f)", - name_a, a, name_b, b, epsilon); -} - - -void _lily_assert_float_not_equal(const char *name_a, const char *name_b, - double a, double b, double epsilon, const char *location) -{ - lily_assert_msg(fabs(a - b) > epsilon, location, - "%s (%f) is equal to %s (%f) (epsilon: %f)", - name_a, a, name_b, b, epsilon); -} - - -void _lily_assert_string_equal(const char *name_a, const char *name_b, - char *a, char *b, const char *location) -{ - lily_assert_msg(strcmp(a, b) == 0, location, - "%s ('%s') is not equal to %s ('%s')", - name_a, a, name_b, b); -} - - -void _lily_assert_string_not_equal(const char *name_a, const char *name_b, - char *a, char *b, const char *location) -{ - lily_assert_msg(strcmp(a, b) != 0, location, - "%s ('%s') is equal to %s", - name_a, a, name_b); -} - - -void _lily_assert_memory_equal(const char *name_a, const char *name_b, - void *a, void *b, size_t size, const char *location) -{ - lily_assert_msg(memcmp(a, b, size) == 0, location, - "%s and %s contain different data", name_a, name_b); -} - - -void _lily_assert_memory_not_equal(const char *name_a, const char *name_b, - void *a, void *b, size_t size, const char *location) -{ - lily_assert_msg(memcmp(a, b, size) == 0, location, - "%s contains the same data s %s", name_a, name_b); -} - - -/* ======== MOCKS ======== */ - -lily_queue_t* lily_queue_create() -{ - const size_t size = 256 * sizeof(uint8_t); - - lily_queue_t *q = malloc(sizeof(lily_queue_t)); - q->buf_size = size; - q->buf = malloc(size); - q->front = q->buf; - q->back = q->front; - - return q; -} - - -void lily_queue_destroy(lily_queue_t *q) -{ - free(q->buf); - free(q); -} - - -void _lily_enqueue(lily_queue_t *q, size_t size, uint8_t *data) -{ - size_t used = q->back - q->buf; - size_t remaining = q->buf_size - used; - - if (remaining < size) { - /* re-allocate bigger buffer */ - size_t size_new = 2 * q->buf_size; - uint8_t *buf_new = realloc(q->buf, size_new); - if (buf_new == NULL) { - fprintf(stderr, "failed to allocated %lu bytes for queue %p!\n", - size_new, q); - return; - } - q->buf = buf_new; - } - - memcpy(q->back, data, size); - q->back += size; -} - - -void _lily_dequeue(lily_queue_t *q, size_t size, uint8_t *ptr) -{ - size_t dist = q->back - q->front; - if (dist < size) { - fprintf(stderr, "attempted to read %lu bytes out of queue %p, " - "which has %lu bytes presently queued\n", size, q, dist); - return; - } - - memcpy(ptr, q->front, size); - q->front += size; -} - - -lily_mock_t * lily_mock_create() -{ - lily_mock_t *m = malloc(sizeof(lily_mock_t)); - m->n_calls = 0; - m->arguments = lily_queue_create(); - m->values = lily_queue_create(); - return m; -} - -void lily_mock_destroy(lily_mock_t *m) -{ - lily_queue_destroy(m->arguments); - lily_queue_destroy(m->values); - free(m); -} - -void lily_mock_use(lily_mock_t **m) -{ - if (*m != NULL) lily_mock_destroy(*m); - *m = lily_mock_create(); -} - -void _lily_mock_call(lily_mock_t *m, struct lily_mock_arg_t *args, size_t n_args) -{ - m->n_calls += 1; - - for (int i=0; iarguments, args[i].size, args[i].var); - } -} - -void _lily_get_call(lily_mock_t *m, - struct lily_mock_arg_t *args, - size_t n_args, - unsigned int call_num) -{ - size_t stride = 0; - for (int i=0; iarguments->front = m->arguments->buf + (call_num * stride); - for (int i=0; iarguments, args[i].size, args[i].var); - } -} 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 #include #include +#include +#include +#include +#include #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 diff --git a/src/test/test.c b/src/test/test.c index c97f325..7d71fbb 100644 --- a/src/test/test.c +++ b/src/test/test.c @@ -1,7 +1,12 @@ +#define LILY_IMPLEMENTATION #include "test.h" int main() { - RUN_TESTS(); + lily_begin(); + #define X(test) test(); + TESTS + #undef X + lily_finish(); return 0; } diff --git a/src/test/test.h b/src/test/test.h index b50fda5..f8d07c9 100644 --- a/src/test/test.h +++ b/src/test/test.h @@ -1,17 +1,16 @@ #ifndef KALMIA_TEST_H #define KALMIA_TEST_H +#define LILY_TEST_H_LOCATION #include "lily-test.h" -void suite_transform(); -void suite_geometry(); +#define TESTS \ + X(util_suite) \ -#define RUN_TESTS() \ - do { \ - lily_run_suite(suite_transform); \ - lily_run_suite(suite_geometry); \ - } while (0) +#define X(test) extern void (*test)(); +TESTS +#undef X #endif -- cgit v1.2.1