summaryrefslogtreecommitdiff
path: root/src/test
diff options
context:
space:
mode:
Diffstat (limited to 'src/test')
-rw-r--r--src/test/lily-test.c366
-rw-r--r--src/test/lily-test.h837
-rw-r--r--src/test/test.c7
-rw-r--r--src/test/test.h13
4 files changed, 659 insertions, 564 deletions
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 <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-#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; i<n_args; i++) {
- _lily_enqueue(m->arguments, 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; i<n_args; i++) {
- stride += args[i].size;
- }
-
- m->arguments->front = m->arguments->buf + (call_num * stride);
- for (int i=0; i<n_args; i++) {
- _lily_dequeue(m->arguments, 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 <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
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 <test/lily-test.h>
#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
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-01 02:33:21 +0000