begin refactor

8 files changed, 23 insertions, 1011 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 397284c..3949e14 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,12 +10,10 @@ add_definitions("-DSOURCE_PATH_SIZE=${SOURCE_PATH_SIZE}")
 include_directories(${CMAKE_SOURCE_DIR})
 set (TEST_SRC ${CMAKE_SOURCE_DIR}/tests)
 add_executable(lily-metatest
-  ${CMAKE_SOURCE_DIR}/lily-test.c
   ${TEST_SRC}/main.c
   ${TEST_SRC}/helpers.c
-  ${TEST_SRC}/assertions.c
-  ${TEST_SRC}/mock_queue.c
+  ${TEST_SRC}/macro-tests.c
   )
 set_target_properties(lily-metatest PROPERTIES
-  C_STANDARD 99
+  C_STANDARD 90
   CMAKE_C_FLAGS "-Wall -Wextra -Werror -Wfatal-errors -Wpedantic")
diff --git a/lily-test.c b/lily-test.c
deleted file mode 100644
index e9be911..0000000
--- a/lily-test.c
+++ /dev/null
@@ -1,360 +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_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/lily-test.h b/lily-test.h
index b3df728..d04b9c2 100644
--- a/lily-test.h
+++ b/lily-test.h
@@ -64,193 +64,4 @@
 #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;
-
-
-/** create a queue */
-lily_queue_t* lily_queue_create();
-
-/** destroy a queue */
-void lily_queue_destroy(lily_queue_t *q);
-
-
-/** 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;
-};
-
-#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);
-
-
-/** store a call to a mock function */
-#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_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
diff --git a/tests/assertions.c b/tests/assertions.c
deleted file mode 100644
index 0e14a2b..0000000
--- a/tests/assertions.c
+++ /dev/null
@@ -1,307 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "lily-test.h"
-#include "tests.h"
-
-const char *test_LILY_LOCATION()
-{
-   // if you move this line, you MUST update the expected string!
-   const char *location = LILY_LOCATION;
-   int diff = strcmp(location, "tests/assertions.c:11");
-   if (diff != 0)
-      return "LILY_LOCATION did not resolve correctly!";
-
-   return 0;
-}
-
-
-/* overarching assert function */
-const char *test_assert_msg()
-{
-   int val = setjmp(_lily_globals.env);
-   if (val != 0)
-      return "true assertion failed incorrectly!";
-
-   lily_assert_msg(true, LILY_LOCATION, "should not fail!");
-
-   int passed_thru = 0;
-   _lily_globals.error_msg = NULL;
-   _lily_globals.error_location = "";
-   val = setjmp(_lily_globals.env);
-
-   if (passed_thru == 0) {
-      passed_thru = 1;
-      // another line that you SHOULD NOT MOVE!
-      lily_assert_msg(false, LILY_LOCATION, "%s %s!", "should", "fail");
-      return "false assertion incorrectly succeeded!";
-   }
-   else {
-      if (strcmp(_lily_globals.error_msg, "should fail!") != 0)
-	 return "false assertion produced incorrect error message!";
-      if (strcmp(_lily_globals.error_location, "tests/assertions.c:37"))
-	 return "false assertion produced incorrect error location!";
-   }
-
-   free(_lily_globals.error_msg);
-   return 0;
-}
-
-
-/* basic asserts */
-const char *test_assert_true()
-{
-   int val = setjmp(_lily_globals.env);
-   if (val != 0)
-      return "true assertion failed incorrectly!";
-
-   lily_assert_true(true);
-
-   int passed_thru = 0;
-   _lily_globals.error_msg = NULL;
-   _lily_globals.error_location = "";
-   val = setjmp(_lily_globals.env);
-
-   if (passed_thru == 0) {
-      passed_thru = 1;
-      lily_assert_true(false);
-      return "false assertion incorrectly succeeded!";
-   }
-   else {
-      if (strcmp(_lily_globals.error_msg, "false is not true") != 0)
-	 return "false assertion produced incorrect error message!";
-   }
-
-   free(_lily_globals.error_msg);
-   return 0;
-}
-
-
-const char *test_assert_false()
-{
-   int val = setjmp(_lily_globals.env);
-   if (val != 0)
-      return "true assertion failed incorrectly!";
-
-   lily_assert_false(false);
-
-   int passed_thru = 0;
-   _lily_globals.error_msg = NULL;
-   _lily_globals.error_location = "";
-   val = setjmp(_lily_globals.env);
-
-   if (passed_thru == 0) {
-      passed_thru = 1;
-      lily_assert_false(true);
-      return "false assertion incorrectly succeeded!";
-   }
-   else {
-      if (strcmp(_lily_globals.error_msg, "true is not false") != 0)
-	 return "false assertion produced incorrect error message!";
-   }
-
-   free(_lily_globals.error_msg);
-   return 0;
-}
-
-
-/* pointer assertions */
-const char *test_assert_not_null()
-{
-   int a = 5;
-
-   int val = setjmp(_lily_globals.env);
-   if (val != 0)
-      return "true assertion failed incorrectly!";
-
-   lily_assert_not_null(&a);
-
-   int passed_thru = 0;
-   _lily_globals.error_msg = NULL;
-   _lily_globals.error_location = "";
-   val = setjmp(_lily_globals.env);
-
-   int *ptr = NULL;
-
-   if (passed_thru == 0) {
-      passed_thru = 1;
-      lily_assert_not_null(ptr);
-      return "false assertion incorrectly succeeded!";
-   }
-   else {
-      if (strcmp(_lily_globals.error_msg, "ptr is NULL") != 0)
-	 return "false assertion produced incorrect error message!";
-   }
-
-   free(_lily_globals.error_msg);
-   return 0;
-}
-
-
-const char *test_assert_null()
-{
-   int a = 5;
-   int *ptr = NULL;
-
-   int val = setjmp(_lily_globals.env);
-   if (val != 0)
-      return "true assertion failed incorrectly!";
-
-   lily_assert_null(ptr);
-
-   int passed_thru = 0;
-   _lily_globals.error_msg = NULL;
-   _lily_globals.error_location = "";
-   val = setjmp(_lily_globals.env);
-
-   if (passed_thru == 0) {
-      passed_thru = 1;
-      lily_assert_null(&a);
-      return "false assertion incorrectly succeeded!";
-   }
-   else {
-      char buf[256];
-      sprintf(buf, "&a (%p) is not NULL", &a);
-      if (strcmp(_lily_globals.error_msg, buf) != 0)
-	 return "false assertion produced incorrect error message!";
-   }
-
-   free(_lily_globals.error_msg);
-   return 0;
-}
-
-
-const char *test_assert_ptr_equal()
-{
-   int a = 0;
-   int b = 0;
-   int *ptr = &a;
-
-   int val = setjmp(_lily_globals.env);
-   if (val != 0)
-      return "true assertion failed incorrectly!";
-
-   lily_assert_ptr_equal(&a, ptr);
-
-   int passed_thru = 0;
-   _lily_globals.error_msg = NULL;
-   _lily_globals.error_location = "";
-   val = setjmp(_lily_globals.env);
-   ptr = &b;
-
-   if (passed_thru == 0) {
-      passed_thru = 1;
-      lily_assert_ptr_equal(&a, ptr);
-      return "false assertion incorrectly succeeded!";
-   }
-   else {
-      char buf[256];
-      sprintf(buf, "&a (%p) is not equal to ptr (%p)", &a, &b);
-      if (strcmp(_lily_globals.error_msg, buf) != 0)
-	 return "false assertion produced incorrect error message!";
-   }
-
-   free(_lily_globals.error_msg);
-   return 0;
-}
-
-
-const char *test_assert_ptr_not_equal()
-{
-   int a = 0;
-   int b = 0;
-   int *ptr = &b;
-
-   int val = setjmp(_lily_globals.env);
-   if (val != 0)
-      return "true assertion failed incorrectly!";
-
-   lily_assert_ptr_not_equal(&a, ptr);
-
-   int passed_thru = 0;
-   _lily_globals.error_msg = NULL;
-   _lily_globals.error_location = "";
-   val = setjmp(_lily_globals.env);
-   ptr = &a;
-
-   if (passed_thru == 0) {
-      passed_thru = 1;
-      lily_assert_ptr_not_equal(&a, ptr);
-      return "false assertion incorrectly succeeded!";
-   }
-   else {
-      char buf[256];
-      sprintf(buf, "&a (%p) is equal to ptr", &a);
-      if (strcmp(_lily_globals.error_msg, buf) != 0)
-	 return "false assertion produced incorrect error message!";
-   }
-
-   free(_lily_globals.error_msg);
-   return 0;
-}
-
-
-/* integer assertions */
-const char *test_assert_int_equal()
-{
-   int a = 56;
-   int b = 56;
-
-   int val = setjmp(_lily_globals.env);
-   if (val != 0)
-      return "true assertion failed incorrectly!";
-
-   lily_assert_int_equal(a, b);
-
-   int passed_thru = 0;
-   _lily_globals.error_msg = NULL;
-   _lily_globals.error_location = "";
-   val = setjmp(_lily_globals.env);
-   a = 25;
-
-   if (passed_thru == 0) {
-      passed_thru = 1;
-      lily_assert_int_equal(a, b);
-      return "false assertion succeeded incorrectly!";
-   }
-   else {
-      if (strcmp(_lily_globals.error_msg, "a (25) is not equal to b (56)") != 0)
-	 return "false assertion produced incorrect error message!";
-   }
-
-   free(_lily_globals.error_msg);
-   return 0;
-}
-
-
-const char *test_assert_int_not_equal()
-{
-   int a = 25;
-   int b = 26;
-
-   int val = setjmp(_lily_globals.env);
-   if (val != 0)
-      return "true assertion failed incorrectly!";
-
-   lily_assert_int_not_equal(a, b);
-
-   int passed_thru = 0;
-   _lily_globals.error_msg = NULL;
-   _lily_globals.error_location = "";
-   val = setjmp(_lily_globals.env);
-   b = 25;
-
-   if (passed_thru == 0) {
-      passed_thru = 1;
-      lily_assert_int_not_equal(a, b);
-      return "false assertion incorrectly succeeded!";
-   }
-   else {
-      if (strcmp(_lily_globals.error_msg, "a (25) is equal to b") != 0)
-	 return "false assertion produced incorrect error message!";
-   }
-
-   free(_lily_globals.error_msg);
-   return 0;
-}
diff --git a/tests/macro-tests.c b/tests/macro-tests.c
new file mode 100644
index 0000000..71e9189
--- /dev/null
+++ b/tests/macro-tests.c
@@ -0,0 +1,12 @@
+#include "lily-test.h"
+#include "tests.h"
+
+
+const char * test_LILY_LOCATION()
+{
+	/* do NOT move the following line, or this test will break! */
+	if (strcmp(LILY_LOCATION, "tests/macro-tests.c:8") != 0) {
+		return "LILY_LOCATION refers to the wrong location!";
+	}
+	return 0;
+}
diff --git a/tests/main.c b/tests/main.c
index f3f1f06..49c6aa8 100644
--- a/tests/main.c
+++ b/tests/main.c
@@ -8,21 +8,8 @@
 
 int main()
 {
-   run_test(test_LILY_LOCATION);
-   run_test(test_assert_msg);
-   run_test(test_assert_true);
-   run_test(test_assert_false);
-   run_test(test_assert_not_null);
-   run_test(test_assert_null);
-   run_test(test_assert_ptr_equal);
-   run_test(test_assert_ptr_not_equal);
-   run_test(test_assert_int_equal);
-   run_test(test_assert_int_not_equal);
-
-   run_test(test_mock_enqueue_dequeue_int);
-   run_test(test_mock_enqueue_dequeue_heterogenous);
-   run_test(test_LILY_NARGS);
-   run_test(test_lily_mock_call);
-
-   return 0;
+	#define X(test) run_test(test);
+	TESTS
+	#undef X
+	return 0;
 }
diff --git a/tests/mock_queue.c b/tests/mock_queue.c
deleted file mode 100644
index 493d397..0000000
--- a/tests/mock_queue.c
+++ /dev/null
@@ -1,120 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-#include "lily-test.h"
-#include "tests.h"
-
-
-const char* test_mock_enqueue_dequeue_int() {
-   lily_queue_t *q = lily_queue_create();
-
-   /* enqueue A259482, for no particular reason */
-   lily_enqueue(q, int, 2);
-   lily_enqueue(q, int, 6);
-   lily_enqueue(q, int, 44);
-   int n = 2014;
-   lily_enqueue(q, int, n);
-
-   lily_dequeue(q, int, &n);
-   if (n != 2) return "dequeued incorrect first value";
-   lily_dequeue(q, int, &n);
-
-   /* queue next value after already popping */
-   lily_enqueue(q, long, 1651377);
-
-   if (n != 6) return "dequeued incorrect second value";
-   lily_dequeue(q, int, &n);
-   if (n != 44) return "dequeued incorrect third value";
-   lily_dequeue(q, int, &n);
-   if (n != 2014) return "dequeued incorrect fourth value";
-   long m;
-   lily_dequeue(q, long, &m);
-   if (m != 1651377) return "dequeued incorrect fifth value";
-
-   lily_queue_destroy(q);
-
-   return 0;
-}
-
-
-const char* test_mock_enqueue_dequeue_heterogenous()
-{
-   lily_queue_t *q = lily_queue_create();
-
-   lily_enqueue(q, int, 2);
-   lily_enqueue(q, lily_queue_t *, q);
-   lily_enqueue(q, const char *, "hello, world!");
-
-   int n;
-   lily_dequeue(q, int, &n);
-   if (n != 2) return "dequeued incorrect int value";
-   lily_queue_t *p;
-   lily_dequeue(q, lily_queue_t *, &p);
-   if (p != q) return "dequeued incorrect pointer value";
-   const char *str;
-   lily_dequeue(q, const char *, &str);
-   if (strcmp(str, "hello, world!") != 0) return "dequeued incorrect string value";
-
-   lily_queue_destroy(q);
-
-   return 0;
-}
-
-
-const char* test_LILY_NARGS()
-{
-   int n = 5;
-   const char *str = "hello, world!";
-   lily_queue_t *q;
-
-   struct lily_mock_arg_t args[] =
-      { { sizeof(int), &n },
-	{ sizeof(const char *), &str },
-	{ sizeof(lily_queue_t *), &q },
-      };
-   if (LILY_NARGS(args) != 3) return "incorrect argument count!";
-
-   return 0;
-}
-
-
-const char* test_lily_mock_call()
-{
-   lily_mock_t *m = lily_mock_create();
-
-   int n = 5;
-   const char *str = "hello, world!";
-   lily_queue_t *q;
-
-   struct lily_mock_arg_t args[] =
-      { { sizeof(int), &n },
-	{ sizeof(const char *), &str },
-	{ sizeof(lily_queue_t *), &q },
-      };
-
-   lily_mock_call(m, args);
-   n = 16;
-   str = "hi there";
-   lily_mock_call(m, args);
-
-   if (m->n_calls != 2) return "incorrect number of calls registered";
-
-   int k; const char *s; lily_queue_t *p;
-   struct lily_mock_arg_t get_args[] =
-      { { sizeof(int), &k },
-	{ sizeof(const char *), &s },
-	{ sizeof(lily_queue_t *), &p },
-      };
-   lily_get_call(m, get_args, 0);
-   if (k != 5) return "incorrect int argument 0 registered";
-   if (strcmp(s, "hello, world!") != 0) return "incorrect string argument 0 registered";
-   if (p != q) return "incorrect pointer argument 0 registered";
-
-   lily_get_call(m, get_args, 1);
-   if (k != 16) return "incorrect int argument 1 registered";
-   if (strcmp(s, "hi there") != 0) return "incorrect string argument 1 registered";
-   if (p != q) return "incorrect pointer argument 1 registered";
-
-   lily_mock_destroy(m);
-   return 0;
-}
diff --git a/tests/tests.h b/tests/tests.h
index 9584cac..f1ea9c1 100644
--- a/tests/tests.h
+++ b/tests/tests.h
@@ -7,20 +7,11 @@ int validate_message(const char* received, const char* expected,
 		     const char* FILE, unsigned int LINE);
 
 // test cases
-const char* test_LILY_LOCATION();
-const char* test_assert_msg();
-const char* test_assert_true();
-const char* test_assert_false();
-const char* test_assert_not_null();
-const char* test_assert_null();
-const char* test_assert_ptr_equal();
-const char* test_assert_ptr_not_equal();
-const char* test_assert_int_equal();
-const char* test_assert_int_not_equal();
+#define TESTS \
+	X(test_LILY_LOCATION) \
 
-const char* test_mock_enqueue_dequeue_int();
-const char* test_mock_enqueue_dequeue_heterogenous();
-const char* test_LILY_NARGS();
-const char* test_lily_mock_call();
+#define X(test) const char * test();
+TESTS
+#undef X
 
 #endif