add basic logging function

10 files changed, 790 insertions, 26 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a29a6f1..6b37672 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -16,7 +16,7 @@ include_directories(${LUA_INCLUDE_DIR} ${CMAKE_SOURCE_DIR}/src)
 link_directories(${LIB_ROOT}/assimp/lib)
 link_directories(${LIB_ROOT}/honeysuckle)
 
-add_library(glad ${SRC_ROOT}/gl/glad/glad.c)
+# add_library(glad ${SRC_ROOT}/gl/glad/glad.c)
 # add_library(stb_image src/stb_image/stb_image.c)
 add_subdirectory(${LIB_ROOT}/assimp)
 add_subdirectory(${LIB_ROOT}/honeysuckle)
@@ -24,47 +24,39 @@ add_subdirectory(${LIB_ROOT}/cglm)
 
 
 set(HONEY_LIB_FILES
-  ${SRC_ROOT}/logging/logging.c
-  
-  ${SRC_ROOT}/gl/honey_window.c
-  ${SRC_ROOT}/gl/honey_shader.c
-  ${SRC_ROOT}/gl/honey_gl_error.c
-  ${SRC_ROOT}/gl/honey_gl.c
-  
-  ${SRC_ROOT}/options/honey_options.c
-  )
+	${SRC_ROOT}/logging/logging.c
+)
 
 set(SOURCE_FILES
-  ${SRC_ROOT}/main.c
-  ${HONEY_LIB_FILES}
-  )
-  
+	${SRC_ROOT}/main.c
+	${HONEY_LIB_FILES}
+	)
+	
 add_executable(honey ${SOURCE_FILES})
 
 set(LIBRARIES ${LUA_LIBRARIES} honeysuckle assimp glad cairo m)
 if (WIN32)
-  set(LIBRARIES ${LIBRARIES} glfw3 opengl32)
+	set(LIBRARIES ${LIBRARIES} glfw3 opengl32)
 else()
-  set(LIBRARIES ${LIBRARIES} glfw GL dl)
+	set(LIBRARIES ${LIBRARIES} glfw GL dl)
 endif()
 target_link_libraries(honey ${LIBRARIES})
 
 
 # build tests (optional)
 
-set(TEST_SOURCES
-  ${SRC_ROOT}/test/test_main.c
-  ${HONEY_LIB_FILES}
+string(LENGTH "${CMAKE_SOURCE_DIR}/" SOURCE_PATH_SIZE)
+add_definitions("-DSOURCE_PATH_SIZE=${SOURCE_PATH_SIZE}")
 
-  ${SRC_ROOT}/test/mock_queue.c
-  ${SRC_ROOT}/test/mock_queue.test.c
+set(TEST_SOURCES
+	${SRC_ROOT}/test/lily-test.c
+	${SRC_ROOT}/test/honey-test.c
 
-  ${SRC_ROOT}/logging/logging.test.c
-  ${SRC_ROOT}/gl/honey_gl.test.c
-  )
+	${SRC_ROOT}/logging/logging.test.c
+)
 
 add_executable(test EXCLUDE_FROM_ALL ${TEST_SOURCES})
 set_target_properties(test PROPERTIES
-  C_STANDARD 99
-  CMAKE_C_FLAGS "-Wall -Wextra -Werror -Wfatal-errors -Wpedantic")
+	C_STANDARD 99
+	CMAKE_C_FLAGS "-Wall -Wextra -Werror -Wfatal-errors -Wpedantic")
 target_link_libraries(test ${LUA_LIBRARIES} honeysuckle)
diff --git a/src/logging/.logging.h.swp b/src/logging/.logging.h.swp
new file mode 100644
index 0000000..e2c510a
--- /dev/null
+++ b/src/logging/.logging.h.swp
diff --git a/src/logging/logging.c b/src/logging/logging.c
new file mode 100644
index 0000000..4f717cb
--- /dev/null
+++ b/src/logging/logging.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+#include "logging/logging.h"
+
+int _honey_log_level = HONEY_WARN;
+
+void honey_log(int level, const char *fmt, ...) {
+	//if (level > _honey_log_level) return;
+
+	va_list args;
+	va_start(args, fmt);
+	vfprintf(stderr, fmt, args);
+	va_end(args);
+}
diff --git a/src/logging/logging.h b/src/logging/logging.h
new file mode 100644
index 0000000..2618d2b
--- /dev/null
+++ b/src/logging/logging.h
@@ -0,0 +1,22 @@
+#ifndef HONEY_LOGGING_H
+#define HONEY_LOGGING_H
+
+#define HONEY_FATAL 0
+#define HONEY_ERROR 1
+#define HONEY_WARN  2
+#define HONEY_INFO  3
+#define HONEY_DEBUG 4
+#define HONEY_TRACE 5
+
+extern int _honey_log_level;
+
+void honey_log(int level, const char *fmt, ...);
+
+#define honey_fatal(...) honey_log(HONEY_FATAL, "[FATAL] "__VA_ARGS__)
+#define honey_error(...) honey_log(HONEY_ERROR, "[ERROR] "__VA_ARGS__)
+#define honey_warn(...)  honey_log(HONEY_WARN,  "[WARN] " __VA_ARGS__)
+#define honey_info(...)  honey_log(HONEY_INFO,  "[INFO] " __VA_ARGS__)
+#define honey_debug(...) honey_log(HONEY_DEBUG, "[DEBUG] "__VA_ARGS__)
+#define honey_trace(...) honey_log(HONEY_TRACE, "[TRACE] "__VA_ARGS__)
+
+#endif
diff --git a/src/logging/logging.test.c b/src/logging/logging.test.c
new file mode 100644
index 0000000..e227381
--- /dev/null
+++ b/src/logging/logging.test.c
@@ -0,0 +1,110 @@
+#include <string.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "test/lily-test.h"
+#include "test/honey-test.h"
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * include C file and declare mocks
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+#define vfprintf(file, fmt, vl) mock_vfprintf(file, fmt, vl)
+void mock_vfprintf(FILE*, const char*, va_list vl);
+#include "logging.c"
+#undef vfprintf
+
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * define mock functions
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+lily_mock_t *vfprintf_mock_data;
+void mock_vfprintf(FILE *file, const char *fmt, va_list vl)
+{
+	/* to avoid basically just re-implementing printf parsing here,
+	   i am limiting this function to be able to receive strings only */
+	
+	/* count format specifiers */
+	char *ptr = strchr(fmt, '%');
+	int n_args = 0;
+	while (ptr != NULL) {
+		n_args += 1;
+		ptr = strchr(ptr+1, '%');
+	}
+
+	/* store arguments */
+	struct lily_mock_arg_t args[] = {
+		{ sizeof(FILE*), &file },
+		{ sizeof(const char*), &fmt },
+		{ sizeof(int), &n_args },
+	};
+	lily_mock_call(vfprintf_mock_data, args);
+
+	/* store format arguments */
+	lily_queue_t *queue = vfprintf_mock_data->values;
+	for (int i=0; i<n_args; i++) {
+		char *str = va_arg(vl, char*);
+		lily_enqueue(queue, char*, str);
+	}
+}
+
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * declare tests and define suite
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+void clean_mock(lily_mock_t **m)
+{
+	if (*m != NULL) {
+		lily_mock_destroy(*m);
+		*m = NULL;
+	}
+}
+
+void test_log_fatal_succeeds();
+
+void suite_logging()
+{
+	vfprintf_mock_data = NULL;
+	lily_run_test(test_log_fatal_succeeds);
+	if (vfprintf_mock_data != NULL)
+		lily_mock_destroy(vfprintf_mock_data);
+}
+
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * define tests
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+void test_log_fatal_succeeds()
+{
+	clean_mock(&vfprintf_mock_data);
+	vfprintf_mock_data = lily_mock_create();
+
+	honey_fatal("some message");
+	lily_assert_int_equal(vfprintf_mock_data->n_calls, 1);
+
+	FILE *file; const char *fmt; int n_strings;
+	struct lily_mock_arg_t args[] = {
+		{ sizeof(FILE*), &file },
+		{ sizeof(const char*), &fmt },
+		{ sizeof(int), &n_strings },
+	};
+	lily_get_call(vfprintf_mock_data, args, 0);
+
+	lily_assert_ptr_equal(file, stderr);
+	lily_assert_string_equal(fmt, "[FATAL] some message");
+	lily_assert_int_equal(n_strings, 0);
+}
diff --git a/src/main.c b/src/main.c
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/main.c
diff --git a/src/test/honey-test.c b/src/test/honey-test.c
new file mode 100644
index 0000000..6980d36
--- /dev/null
+++ b/src/test/honey-test.c
@@ -0,0 +1,7 @@
+#include "test/honey-test.h"
+
+int main()
+{
+	RUN_TESTS();
+	return 0;
+}
diff --git a/src/test/honey-test.h b/src/test/honey-test.h
new file mode 100644
index 0000000..4aa1827
--- /dev/null
+++ b/src/test/honey-test.h
@@ -0,0 +1,9 @@
+#ifndef HONEY_TEST_H
+#define HONEY_TEST_H
+
+void suite_logging();
+
+#define RUN_TESTS() \
+	suite_logging();
+
+#endif
diff --git a/src/test/lily-test.c b/src/test/lily-test.c
new file mode 100644
index 0000000..20728fe
--- /dev/null
+++ b/src/test/lily-test.c
@@ -0,0 +1,359 @@
+/****************************************************************
+ *
+ * ======== 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 "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(abs(a - b) <= epsilon,
+		   "%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(abs(a - b) > epsilon,
+		   "%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,
+		   "%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,
+		   "%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,
+		   "%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,
+		   "%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/src/test/lily-test.h b/src/test/lily-test.h
new file mode 100644
index 0000000..90fc2c8
--- /dev/null
+++ b/src/test/lily-test.h
@@ -0,0 +1,252 @@
+/****************************************************************
+ *
+ * ======== 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
+ *
+ ****************************************************************/
+
+
+#ifndef LILY_TEST_H
+#define LILY_TEST_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <setjmp.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 */
+#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;
+
+
+/** 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