add kai_expand_array

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