begin refactor of tests into individual source files

1 files changed, 0 insertions, 985 deletions

diff --git a/src/test.c b/src/test.c
deleted file mode 100644
index 816500b..0000000
--- a/src/test.c
+++ /dev/null
@@ -1,985 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <stdbool.h>
-
-#include <lua.h>
-#include <lualib.h>
-#include <lauxlib.h>
-
-#include "honeysuckle.h"
-#include "colors.h"
-
-/* minunit testing macros modified from those at
-   www.jera.com/techinfo/jtns/jtn002.html */
-#define mu_assert(message, test) do { if (!(test)) return message; } while (0)
-#define mu_run_test(name, test) do {                            \
-	lua_State *L = luaL_newstate();                         \
-	luaL_openlibs(L);                                       \
-	char *message = test(L);                                \
-	lua_close(L);                                           \
-	tests_run++;                                            \
-	if (message) {                                          \
-	    printf(RED "   test '%s' failed: %s\n" RESET, name, message);	\
-	    tests_failed++;                                     \
-	}                                                       \
-    } while (0)
-
-#define TEST(name) static char* name(lua_State *L)
-
-int tests_run = 0;
-int tests_failed = 0;
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * tests for hs_type_to_string
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-TEST(hs_bool_to_string)
-{
-    mu_assert("HS_BOOL does not result in 'boolean'!",
-	      strcmp(hs_type_to_string(HS_BOOL), "boolean") == 0);
-    return 0;
-}
-
-TEST(hs_int_to_string)
-{
-    mu_assert("HS_INT does not result in 'integer'!",
-	      strcmp(hs_type_to_string(HS_INT), "integer") == 0);
-    return 0;
-}
-
-TEST(hs_num_to_string)
-{
-    mu_assert("HS_NUM does not result in 'number'!",
-	      strcmp(hs_type_to_string(HS_NUM), "number") == 0);
-    return 0;
-}
-
-TEST(hs_str_to_string)
-{
-    mu_assert("HS_STR does not result in 'string'!",
-	      strcmp(hs_type_to_string(HS_STR), "string") == 0);
-    return 0;
-}
-
-TEST(hs_tbl_to_string)
-{
-    mu_assert("HS_TBL does not result in 'table'!",
-	      strcmp(hs_type_to_string(HS_TBL), "table") == 0);
-    return 0;
-}
-
-TEST(hs_func_to_string)
-{
-    mu_assert("HS_FUNC does not result in 'function'!",
-	      strcmp(hs_type_to_string(HS_FUNC), "function") == 0);
-    return 0;
-}
-
-TEST(hs_cfunc_to_string)
-{
-    mu_assert("HS_CFUNC does not result in 'C function'!",
-	      strcmp(hs_type_to_string(HS_CFUNC), "C function") == 0);
-    return 0;
-}
-
-TEST(hs_user_to_string)
-{
-    mu_assert("HS_USER does not result in 'userdata'!",
-	      strcmp(hs_type_to_string(HS_USER), "userdata") == 0);
-    return 0;
-}
-
-TEST(hs_light_to_string)
-{
-    mu_assert("HS_LIGHT does not result in 'light userdata'!",
-	      strcmp(hs_type_to_string(HS_LIGHT), "light userdata") == 0);
-    return 0;
-}
-
-TEST(hs_nil_to_string)
-{
-    mu_assert("HS_NIL does not result in 'nil'!",
-	      strcmp(hs_type_to_string(HS_NIL), "nil") == 0);
-    return 0;
-}
-
-TEST(hs_any_to_string)
-{
-    mu_assert("HS_ANY does not result in 'any'!",
-	      strcmp(hs_type_to_string(HS_ANY), "any") == 0);
-    return 0;
-}
-
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * hs_parse_args typechecking tests
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-// typechecking macros
-#define PARSE_TYPECHECK_TEST(name, type, constant)		\
-    int name ## _testfunc(lua_State *L) {			\
-    type test; hs_parse_args(L, constant, &test, HS_END);	\
-    return 0;							\
-    }								\
-    TEST(name)
-
-#define CHECK_FAIL_BOOL(name)						\
-    lua_pushcfunction(L, name ## _testfunc); lua_pushboolean(L, true);	\
-    mu_assert("incorrectly succeeded in parsing boolean!",		\
-	      lua_pcall(L, 1, 0, 0) != 0);
-
-#define CHECK_FAIL_INT(name)						\
-    lua_pushcfunction(L, name ## _testfunc); lua_pushinteger(L, 5);	\
-    mu_assert("incorrectly succeeded in parsing integer!",		\
-	      lua_pcall(L, 1, 0, 0) != 0);
-
-#define CHECK_FAIL_NUM(name)						\
-    lua_pushcfunction(L, name ## _testfunc); lua_pushnumber(L, 42.0f);	\
-    mu_assert("incorrectly succeeded in parsing number!",		\
-	      lua_pcall(L, 1, 0, 0) != 0);
-
-#define CHECK_FAIL_STRING(name)						\
-    lua_pushcfunction(L, name ## _testfunc); lua_pushstring(L, "hello!"); \
-    mu_assert("incorrectly succeeded in parsing string!",		\
-	      lua_pcall(L, 1, 0, 0) != 0);
-
-#define CHECK_FAIL_TABLE(name)						\
-    lua_pushcfunction(L, name ## _testfunc); lua_getglobal(L, "debug");	\
-    mu_assert("incorrectly succeeded in parsing table!",		\
-	      lua_pcall(L, 1, 0, 0) != 0);
-
-#define CHECK_FAIL_FUNC(name)						\
-    lua_pushcfunction(L, name ## _testfunc); lua_getglobal(L, "test");	\
-    mu_assert("incorrectly succeeded in parsing function!",		\
-	      lua_pcall(L, 1, 0, 0) != 0);
-
-#define CHECK_FAIL_CFUNC(name)						\
-    lua_pushcfunction(L, name ## _testfunc); lua_pushvalue(L, -1);	\
-    mu_assert("incorrectly succeeded in parsing C function!",		\
-	      lua_pcall(L, 1, 0, 0) != 0);
-
-#define CHECK_FAIL_USER(name)						\
-    lua_pushcfunction(L, name ## _testfunc); lua_newuserdata(L, sizeof(char)); \
-    mu_assert("incorrectly succeeded in parsing userdata!",		\
-	      lua_pcall(L, 1, 0, 0) != 0);
-
-#define CHECK_FAIL_LIGHT(name)						\
-    int test_data = 5;							\
-    lua_pushcfunction(L, name ## _testfunc); lua_pushlightuserdata(L, &test_data); \
-    mu_assert("incorrectly succeeded in parsing light userdata!",	\
-	      lua_pcall(L, 1, 0, 0) != 0);
-
-#define CHECK_FAIL_NIL(name)					\
-    lua_pushcfunction(L, name ## _testfunc); lua_pushnil(L);	\
-    mu_assert("incorrectly succeeded in parsing nil!",		\
-	      lua_pcall(L, 1, 0, 0) != 0);
-
-
-PARSE_TYPECHECK_TEST(parse_bool_typecheck, bool, HS_BOOL)
-{
-    lua_pushcfunction(L, parse_bool_typecheck_testfunc);
-    lua_pushboolean(L, true);
-    mu_assert("typecheck for bool failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    CHECK_FAIL_INT(parse_bool_typecheck);
-    CHECK_FAIL_NUM(parse_bool_typecheck);
-    CHECK_FAIL_STRING(parse_bool_typecheck);
-    CHECK_FAIL_TABLE(parse_bool_typecheck);
-    CHECK_FAIL_FUNC(parse_bool_typecheck);
-    CHECK_FAIL_CFUNC(parse_bool_typecheck);
-    CHECK_FAIL_USER(parse_bool_typecheck);
-    CHECK_FAIL_LIGHT(parse_bool_typecheck);
-    CHECK_FAIL_NIL(parse_bool_typecheck);
-    return 0;
-}
-
-PARSE_TYPECHECK_TEST(parse_int_typecheck, int, HS_INT)
-{
-    CHECK_FAIL_BOOL(parse_int_typecheck);
-
-    lua_pushcfunction(L, parse_int_typecheck_testfunc);
-    lua_pushinteger(L, 5);
-    mu_assert("typecheck for int failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    CHECK_FAIL_NUM(parse_int_typecheck);
-    CHECK_FAIL_STRING(parse_int_typecheck);
-    CHECK_FAIL_TABLE(parse_int_typecheck);
-    CHECK_FAIL_FUNC(parse_int_typecheck);
-    CHECK_FAIL_CFUNC(parse_int_typecheck);
-    CHECK_FAIL_USER(parse_int_typecheck);
-    CHECK_FAIL_LIGHT(parse_int_typecheck);
-    CHECK_FAIL_NIL(parse_int_typecheck);
-    return 0;
-}
-
-PARSE_TYPECHECK_TEST(parse_num_typecheck, lua_Number, HS_NUM)
-{
-    CHECK_FAIL_BOOL(parse_num_typecheck);
-    CHECK_FAIL_INT(parse_num_typecheck);
-
-    lua_pushcfunction(L, parse_int_typecheck_testfunc);
-    lua_pushnumber(L, 42.0f);
-    mu_assert("typecheck for number failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    CHECK_FAIL_STRING(parse_num_typecheck);
-    CHECK_FAIL_TABLE(parse_num_typecheck);
-    CHECK_FAIL_FUNC(parse_num_typecheck);
-    CHECK_FAIL_CFUNC(parse_num_typecheck);
-    CHECK_FAIL_USER(parse_num_typecheck);
-    CHECK_FAIL_LIGHT(parse_num_typecheck);
-    CHECK_FAIL_NIL(parse_num_typecheck);
-    return 0;
-}
-
-PARSE_TYPECHECK_TEST(parse_string_typecheck, char *, HS_STR)
-{
-    CHECK_FAIL_BOOL(parse_string_typecheck);
-    CHECK_FAIL_INT(parse_string_typecheck);
-    CHECK_FAIL_NUM(parse_string_typecheck);
-
-    lua_pushcfunction(L, parse_string_typecheck_testfunc);
-    lua_pushstring(L, "hello!");
-    mu_assert("typecheck for string failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    CHECK_FAIL_TABLE(parse_string_typecheck);
-    CHECK_FAIL_FUNC(parse_string_typecheck);
-    CHECK_FAIL_CFUNC(parse_string_typecheck);
-    CHECK_FAIL_USER(parse_string_typecheck);
-    CHECK_FAIL_LIGHT(parse_string_typecheck);
-    CHECK_FAIL_NIL(parse_string_typecheck);
-    return 0;
-}
-
-PARSE_TYPECHECK_TEST(parse_table_typecheck, int, HS_TBL)
-{
-    CHECK_FAIL_BOOL(parse_table_typecheck);
-    CHECK_FAIL_INT(parse_table_typecheck);
-    CHECK_FAIL_NUM(parse_table_typecheck);
-    CHECK_FAIL_STRING(parse_table_typecheck);
-
-    lua_pushcfunction(L, parse_table_typecheck_testfunc);
-    lua_getglobal(L, "debug");
-    mu_assert("typecheck for table failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    CHECK_FAIL_FUNC(parse_table_typecheck);
-    CHECK_FAIL_CFUNC(parse_table_typecheck);
-    CHECK_FAIL_USER(parse_table_typecheck);
-    CHECK_FAIL_LIGHT(parse_table_typecheck);
-    CHECK_FAIL_NIL(parse_table_typecheck);
-    return 0;
-}
-
-PARSE_TYPECHECK_TEST(parse_func_typecheck, int, HS_FUNC)
-{
-    CHECK_FAIL_BOOL(parse_func_typecheck);
-    CHECK_FAIL_INT(parse_func_typecheck);
-    CHECK_FAIL_NUM(parse_func_typecheck);
-    CHECK_FAIL_STRING(parse_func_typecheck);
-    CHECK_FAIL_TABLE(parse_func_typecheck);
-
-    lua_pushcfunction(L, parse_func_typecheck_testfunc);
-    lua_getglobal(L, "test");
-    mu_assert("typecheck for function failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    CHECK_FAIL_CFUNC(parse_func_typecheck);
-    CHECK_FAIL_USER(parse_func_typecheck);
-    CHECK_FAIL_LIGHT(parse_func_typecheck);
-    CHECK_FAIL_NIL(parse_func_typecheck);
-    return 0;
-}
-
-PARSE_TYPECHECK_TEST(parse_cfunc_typecheck, lua_CFunction, HS_CFUNC)
-{
-    CHECK_FAIL_BOOL(parse_cfunc_typecheck);
-    CHECK_FAIL_INT(parse_cfunc_typecheck);
-    CHECK_FAIL_NUM(parse_cfunc_typecheck);
-    CHECK_FAIL_STRING(parse_cfunc_typecheck);
-    CHECK_FAIL_TABLE(parse_cfunc_typecheck);
-    CHECK_FAIL_FUNC(parse_cfunc_typecheck);
-
-    lua_pushcfunction(L, parse_cfunc_typecheck_testfunc);
-    lua_pushvalue(L, -1);
-    mu_assert("typecheck for C function failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    CHECK_FAIL_USER(parse_cfunc_typecheck);
-    CHECK_FAIL_LIGHT(parse_cfunc_typecheck);
-    CHECK_FAIL_NIL(parse_cfunc_typecheck);
-    return 0;
-}
-
-PARSE_TYPECHECK_TEST(parse_user_typecheck, void *, HS_USER)
-{
-    CHECK_FAIL_BOOL(parse_user_typecheck);
-    CHECK_FAIL_INT(parse_user_typecheck);
-    CHECK_FAIL_NUM(parse_user_typecheck);
-    CHECK_FAIL_STRING(parse_user_typecheck);
-    CHECK_FAIL_TABLE(parse_user_typecheck);
-    CHECK_FAIL_FUNC(parse_user_typecheck);
-    CHECK_FAIL_CFUNC(parse_user_typecheck);
-
-    lua_pushcfunction(L, parse_user_typecheck_testfunc);
-    lua_newuserdata(L, sizeof(char));
-    mu_assert("typecheck for userdata failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    lua_pushcfunction(L, parse_user_typecheck_testfunc);
-    int testdata = 5; lua_pushlightuserdata(L, &testdata);
-    mu_assert("typecheck for light userdata failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    CHECK_FAIL_NIL(parse_user_typecheck);
-    return 0;
-}
-
-PARSE_TYPECHECK_TEST(parse_light_typecheck, void *, HS_LIGHT)
-{
-    CHECK_FAIL_BOOL(parse_light_typecheck);
-    CHECK_FAIL_INT(parse_light_typecheck);
-    CHECK_FAIL_NUM(parse_light_typecheck);
-    CHECK_FAIL_STRING(parse_light_typecheck);
-    CHECK_FAIL_TABLE(parse_light_typecheck);
-    CHECK_FAIL_FUNC(parse_light_typecheck);
-    CHECK_FAIL_CFUNC(parse_light_typecheck);
-    CHECK_FAIL_USER(parse_light_typecheck);
-
-    lua_pushcfunction(L, parse_light_typecheck_testfunc);
-    int testdata = 5; lua_pushlightuserdata(L, &testdata);
-    mu_assert("typecheck for light userdata failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    CHECK_FAIL_NIL(parse_light_typecheck);
-    return 0;
-}
-
-PARSE_TYPECHECK_TEST(parse_nil_typecheck, int, HS_NIL)
-{
-    CHECK_FAIL_BOOL(parse_nil_typecheck);
-    CHECK_FAIL_INT(parse_nil_typecheck);
-    CHECK_FAIL_NUM(parse_nil_typecheck);
-    CHECK_FAIL_STRING(parse_nil_typecheck);
-    CHECK_FAIL_TABLE(parse_nil_typecheck);
-    CHECK_FAIL_FUNC(parse_nil_typecheck);
-    CHECK_FAIL_CFUNC(parse_nil_typecheck);
-    CHECK_FAIL_USER(parse_nil_typecheck);
-    CHECK_FAIL_LIGHT(parse_nil_typecheck);
-
-    lua_pushcfunction(L, parse_nil_typecheck_testfunc);
-    lua_pushnil(L);
-    mu_assert("typecheck for nil failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    return 0;
-}
-
-PARSE_TYPECHECK_TEST(parse_any_typecheck, int, HS_ANY)
-{
-    lua_pushcfunction(L, parse_bool_typecheck_testfunc);
-    lua_pushboolean(L, true);
-    mu_assert("typecheck for bool failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    lua_pushcfunction(L, parse_int_typecheck_testfunc);
-    lua_pushinteger(L, 5);
-    mu_assert("typecheck for int failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    lua_pushcfunction(L, parse_int_typecheck_testfunc);
-    lua_pushnumber(L, 42.0f);
-    mu_assert("typecheck for number failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    lua_pushcfunction(L, parse_string_typecheck_testfunc);
-    lua_pushstring(L, "hello!");
-    mu_assert("typecheck for string failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    lua_pushcfunction(L, parse_table_typecheck_testfunc);
-    lua_getglobal(L, "debug");
-    mu_assert("typecheck for table failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    lua_pushcfunction(L, parse_func_typecheck_testfunc);
-    lua_getglobal(L, "test");
-    mu_assert("typecheck for function failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    lua_pushcfunction(L, parse_cfunc_typecheck_testfunc);
-    lua_pushvalue(L, -1);
-    mu_assert("typecheck for C function failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    lua_pushcfunction(L, parse_user_typecheck_testfunc);
-    lua_newuserdata(L, sizeof(char));
-    mu_assert("typecheck for userdata failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    lua_pushcfunction(L, parse_user_typecheck_testfunc);
-    int testdata = 5; lua_pushlightuserdata(L, &testdata);
-    mu_assert("typecheck for light userdata failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    lua_pushcfunction(L, parse_nil_typecheck_testfunc);
-    lua_pushnil(L);
-    mu_assert("typecheck for nil failed!",
-	      lua_pcall(L, 1, 0, 0) == 0);
-
-    return 0;
-}
-
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * hs_parse_args parsing tests
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-TEST(parse_bool)
-{
-    lua_pushboolean(L, true);
-    bool b = false;
-    hs_parse_args(L, HS_BOOL, &b, HS_END);
-    mu_assert("failed to properly parse boolean!", b);
-    return 0;
-}
-
-TEST(parse_int)
-{
-    lua_pushinteger(L, 420);
-    int i = 0;
-    hs_parse_args(L, HS_INT, &i, HS_END);
-    mu_assert("failed to properly parse integer!", i == 420);
-    return 0;
-}
-
-TEST(parse_num)
-{
-    lua_pushnumber(L, 40.5f);
-    lua_Number n = 0;
-    hs_parse_args(L, HS_NUM, &n, HS_END);
-    mu_assert("failed to properly parse number!", n == 40.5f);
-    return 0;
-}
-
-TEST(parse_str)
-{
-    lua_pushstring(L, "hello, world!");
-    char *s = "";
-    hs_parse_args(L, HS_STR, &s, HS_END);
-    mu_assert("failed to properly parse string!",
-	      strcmp(s, "hello, world!") == 0);
-    return 0;
-}
-
-TEST(parse_tbl)
-{
-    lua_getglobal(L, "debug");
-    int correct_index = lua_gettop(L);
-    int tbl_index;
-    hs_parse_args(L, HS_TBL, &tbl_index, HS_END);
-    mu_assert("failed to properly parse table!", tbl_index == correct_index);
-    return 0;
-}
-
-TEST(parse_func)
-{
-    lua_getglobal(L, "type");
-    int correct_index = lua_gettop(L);
-    int index = 0;
-    hs_parse_args(L, HS_FUNC, &index, HS_END);
-    mu_assert("failed to properly parse function!", index == correct_index);
-    return 0;
-}
-
-int testfunc(lua_State *L) { return 0; }
-
-TEST(parse_cfunc)
-{
-    lua_pushcfunction(L, testfunc);
-    lua_CFunction f;
-    hs_parse_args(L, HS_CFUNC, &f, HS_END);
-    mu_assert("failed to properly parse C function!", f == testfunc);
-    return 0;
-}
-
-int should_fail(lua_State *L)
-{
-    lua_CFunction f;
-    hs_parse_args(L, HS_CFUNC, &f, HS_END);
-    return 0;
-}
-
-TEST(fail_parse_noncfunc)
-{
-    lua_pushcfunction(L, should_fail);
-    lua_getglobal(L, "type");
-    mu_assert("incorrectly parsed non-C function!",
-	      lua_pcall(L, 1, 0, 0) != 0);
-    return 0;
-}
-
-TEST(parse_userdata)
-{
-    void *userdata = lua_newuserdata(L, sizeof(char));
-    void *parsed = NULL;
-    hs_parse_args(L, HS_USER, &parsed, HS_END);
-    mu_assert("failed to properly parse userdata!",
-	      parsed == userdata);
-    return 0;
-}
-
-TEST(parse_lightuserdata)
-{
-    int five = 5;
-    lua_pushlightuserdata(L, &five);
-
-    void *data;
-    hs_parse_args(L, HS_LIGHT, &data, HS_END);
-    mu_assert("failed to properly parse light userdata!",
-	      data == &five);
-    return 0;
-}
-
-TEST(parse_nil)
-{
-    lua_pushnil(L);
-    int correct_index = lua_gettop(L);
-    int index = 0;
-    hs_parse_args(L, HS_NIL, &index, HS_END);
-    mu_assert("failed to properly parse nil!",
-	      index == correct_index);
-    return 0;
-}
-
-TEST(parse_any)
-{
-    lua_pushnil(L);
-    int correct_index = lua_gettop(L);
-    int index = 0;
-    hs_parse_args(L, HS_ANY, &index, HS_END);
-    mu_assert("failed to properly parse [any]!",
-	      index == correct_index);
-    return 0;
-}
-
-TEST(parse_all)
-{
-    lua_pushboolean(L, true);
-    lua_pushinteger(L, 420);
-    lua_pushnumber(L, 40.5f);
-    lua_pushstring(L, "hello, world!");
-    lua_getglobal(L, "debug");
-    int tbl_index = lua_gettop(L);
-    lua_getglobal(L, "type");
-    int func_index = lua_gettop(L);
-    lua_pushcfunction(L, testfunc);
-    void *userdata = lua_newuserdata(L, sizeof(char));
-    int five = 5;
-    lua_pushlightuserdata(L, &five);
-    lua_pushnil(L);
-    int nil_index = lua_gettop(L);
-    lua_pushnil(L);
-    int any_index = lua_gettop(L);
-
-    bool b;
-    int i;
-    float f;
-    char *str;
-    int i_tbl;
-    int i_func;
-    lua_CFunction fn;
-    void *user;
-    void *light;
-    int i_nil;
-    int i_any;
-    hs_parse_args
-	(L,
-	 HS_BOOL, &b,
-	 HS_INT, &i,
-	 HS_NUM, &f,
-	 HS_STR, &str,
-	 HS_TBL, &i_tbl,
-	 HS_FUNC, &i_func,
-	 HS_CFUNC, &fn,
-	 HS_USER, &user,
-	 HS_LIGHT, &light,
-	 HS_NIL, &i_nil,
-	 HS_ANY, &i_any,
-	 HS_END);
-    mu_assert("failed to properly parse boolean!", b);
-    mu_assert("failed to properly parse integer!", i == 420);
-    mu_assert("failed to properly parse number!", f == 40.5f);
-    mu_assert("failed to properly parse string!",
-	      strcmp(str, "hello, world!") == 0);
-    mu_assert("failed to properly parse table!", i_tbl == tbl_index);
-    mu_assert("failed to properly parse function!", func_index == i_func);
-    mu_assert("failed to properly parse C function!", fn == testfunc);
-    mu_assert("failed to properly parse userdata!", user == userdata);
-    mu_assert("failed to properly parse light userdata!", light == &five);
-    mu_assert("failed to properly parse nil!", nil_index == i_nil);
-    mu_assert("failed to properly parse [any]!", any_index == i_any);
-    return 0;
-}
-
-TEST(parse_readme_example)
-{
-    lua_pushboolean(L, true);
-    lua_pushinteger(L, 7);
-    lua_getglobal(L, "debug");
-    int expected = lua_gettop(L);
-    lua_pushnumber(L, 3.1415f);
-    lua_pushstring(L, "c: c: c:");
-    void *userdata = lua_newuserdata(L, sizeof(char));
-
-    bool b; int i; int table_index; float f; char *str; void *user;
-    hs_parse_args
-	(L, HS_BOOL, &b, HS_INT, &i, HS_TBL, &table_index,
-	 HS_NUM, &f, HS_STR, &str, HS_USER, &user, HS_END);
-
-    mu_assert("failed to properly parse boolean!", b);
-    mu_assert("failed to properly parse integer!", i == 7);
-    mu_assert("failed to properly parse table!", table_index == expected);
-    mu_assert("failed to properly parse number!", f == 3.1415f);
-    mu_assert("failed to properly parse string!", strcmp(str, "c: c: c:") == 0);
-    mu_assert("failed to properly parse userdata!", user == userdata);
-    return 0;
-}
-
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * tests for hs_parse_overloaded
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-#define PARSE_OVERLOADED						\
-    bool b; int i, ti, fi, ni; float f; char *str;			\
-    lua_CFunction fn; void *user, *light;				\
-    int choice = hs_parse_overloaded					\
-	(L,								\
-	 HS_BOOL, &b, HS_END, HS_INT, &i, HS_END, HS_NUM, &f, HS_END,	\
-	 HS_STR, &str, HS_END, HS_TBL, &ti, HS_END, HS_FUNC, &fi,	\
-	 HS_END, HS_CFUNC, &fn, HS_END, HS_USER, &user, HS_END,		\
-	 HS_LIGHT, &light, HS_END, HS_NIL, &ni, HS_END, HS_END);
-
-TEST(parse_bool_overloaded)
-{
-    lua_pushboolean(L, true);
-    PARSE_OVERLOADED;
-    mu_assert("boolean option was not chosen!", choice == 0);
-    mu_assert("failed to properly parse boolean!", b);
-    return 0;
-}
-
-TEST(parse_integer_overloaded)
-{
-    lua_pushinteger(L, 5);
-    PARSE_OVERLOADED;
-    mu_assert("integer option was not chosen!", choice == 1);
-    mu_assert("failed to properly parse integer!", i == 5);
-    return 0;
-}
-
-TEST(parse_number_overloaded)
-{
-    lua_pushnumber(L, 42.0f);
-    PARSE_OVERLOADED;
-    mu_assert("number option was not chosen!", choice == 2);
-    mu_assert("failed to properly parse boolean!", f == 42.0f);
-    return 0;
-}
-
-TEST(parse_string_overloaded)
-{
-    lua_pushstring(L, "hello, world!");
-    PARSE_OVERLOADED;
-    mu_assert("string option was not chosen!", choice == 3);
-    mu_assert("failed to properly parse string!",
-	      strcmp(str, "hello, world!") == 0);
-    return 0;
-}
-
-TEST(parse_table_overloaded)
-{
-    lua_getglobal(L, "debug");
-    int expected = lua_gettop(L);
-    PARSE_OVERLOADED;
-    mu_assert("table option was not chosen!", choice == 4);
-    mu_assert("failed to properly parse table!", ti == expected);
-    return 0;
-}
-
-TEST(parse_function_overloaded)
-{
-    lua_getglobal(L, "type");
-    int expected = lua_gettop(L);
-    PARSE_OVERLOADED;
-    mu_assert("function option was not chosen!", choice == 5);
-    mu_assert("failed to properly parse function!", fi == expected);
-    return 0;
-}
-
-TEST(parse_cfunction_overloaded)
-{
-    lua_pushcfunction(L, testfunc);
-    PARSE_OVERLOADED;
-    mu_assert("C function option was not chosen!", choice == 6);
-    mu_assert("failed to properly parse C function!", fn == testfunc);
-    return 0;
-}
-
-TEST(parse_userdata_overloaded)
-{
-    void *userdata = lua_newuserdata(L, sizeof(char));
-    PARSE_OVERLOADED;
-    mu_assert("userdata option was not chosen!", choice == 7);
-    mu_assert("failed to properly parse userdata!", user == userdata);
-    return 0;
-}
-
-TEST(parse_lightuserdata_overloaded)
-{
-    int five = 5;
-    lua_pushlightuserdata(L, &five);
-    PARSE_OVERLOADED;
-    mu_assert("light userdata option was not chosen!", choice == 8);
-    mu_assert("failed to properly parse light userdata!", light == &five);
-    return 0;
-}
-
-TEST(parse_nil_overloaded)
-{
-    lua_pushnil(L);
-    int expected = lua_gettop(L);
-    PARSE_OVERLOADED;
-    mu_assert("nil option was not chosen!", choice == 9);
-    mu_assert("failed to properly parse nil!", ni == expected);
-    return 0;
-}
-
-TEST(parse_2_3_overload_0)
-{
-    lua_pushinteger(L, 69);
-    lua_pushstring(L, "foo");
-    int i; char *str; void *data;
-    int choice = hs_parse_overloaded
-	(L, HS_INT, &i, HS_STR, &str, HS_END,
-	 HS_INT, &i, HS_STR, &str, HS_USER, &data, HS_END,
-	 HS_END);
-
-    mu_assert("incorrectly selected option other than 0!", choice == 0);
-    mu_assert("failed to properly parse integer!", i == 69);
-    mu_assert("failed to properly parse string!", strcmp(str, "foo") == 0);
-    return 0;
-}
-
-TEST(parse_2_3_overload_1)
-{
-    lua_pushinteger(L, 69);
-    lua_pushstring(L, "foo");
-    void *userdata = lua_newuserdata(L, sizeof(char));
-    int i; char *str; void *data;
-    int choice = hs_parse_overloaded
-	(L, HS_INT, &i, HS_STR, &str, HS_END,
-	 HS_INT, &i, HS_STR, &str, HS_USER, &data, HS_END,
-	 HS_END);
-
-    mu_assert("incorrectly selected option other than 1!", choice == 1);
-    mu_assert("failed to properly parse integer!", i == 69);
-    mu_assert("failed to properly parse string!", strcmp(str, "foo") == 0);
-    mu_assert("failed to properly parse userdata!", userdata == data);
-    return 0;
-}
-
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * tests for hs_create_table
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-TEST(table_correct_index)
-{
-    int index = hs_create_table(L, HS_END);
-    mu_assert("returned incorrect index!", index == lua_gettop(L));
-    return 0;
-}
-
-
-#define check_table_element(field, is_type, typestring, type, conversion, comparison) \
-    do {								\
-    lua_getfield(L, -1, field);						\
-    if (!is_type(L, -1)) { lua_pop(L, 1); return "field '" field "' is not type " typestring "!"; } \
-    type value = conversion(L, -1);					\
-    lua_pop(L, 1);							\
-    mu_assert("field '" field "' does not match the expected value!", comparison); \
-    } while(0)
-
-#define check_bool(field, expected) check_table_element(field, lua_isboolean, "boolean", bool, lua_toboolean, value == expected)
-#define check_int(field, expected) check_table_element(field, lua_isnumber, "integer", int, lua_tointeger, value == expected)
-#define check_num(field, expected) check_table_element(field, lua_isnumber, "number", float, lua_tonumber, value == expected)
-#define check_string(field, expected) check_table_element(field, lua_isstring, "string", char*, lua_tostring, strcmp(value, expected))
-#define check_cfunc(field, expected) check_table_element(field, lua_iscfunction, "C function", lua_CFunction, lua_tocfunction, value == expected)
-#define check_user(field, expected) check_table_element(field, lua_isuserdata, "userdata", void*, lua_touserdata, value == expected)
-#define check_light(field, expected) check_table_element(field, lua_islightuserdata, "light userdata", void*, lua_touserdata, value == expected)
-
-TEST(table_create_basic_types)
-{
-    void *userdata = lua_newuserdata(L, sizeof(char));
-    int user_index = lua_gettop(L);
-    char lightuserdata = 'F';
-    
-    hs_create_table
-	(L,
-	 "boolValue", HS_BOOL, false,
-	 "intValue", HS_INT, 15,
-	 "numValue", HS_NUM, 33.66,
-	 "stringValue", HS_STR, "goober",
-	 "cfuncValue", HS_CFUNC, testfunc,
-	 "userValue", HS_USER, user_index,
-	 "lightValue", HS_LIGHT, &lightuserdata,
-	 HS_END);
-
-    check_bool("boolValue", false);
-    check_int("intValue", 15);
-    check_num("numValue", 33.66);
-    check_string("stringValue", "goober");
-    check_cfunc("cfuncValue", testfunc);
-    check_user("userValue", userdata);
-    check_light("lightValue", &lightuserdata);
-    return 0;
-}
-
-    
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * tests for hs_pushstring
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-TEST(push_noformat)
-{
-    hs_pushstring(L, "a string");
-    mu_assert("no string at top of stack!", lua_isstring(L, -1));
-    const char *string = lua_tostring(L, -1);
-    mu_assert("string != 'a string'", strcmp(string, "a string") == 0);
-    return 0;
-}
-
-TEST(push_formatint)
-{
-    hs_pushstring(L, "%d is 5", 5);
-    mu_assert("no string at top of stack!", lua_isstring(L, -1));
-    const char *string = lua_tostring(L, -1);
-    mu_assert("string != '5 is 5'", strcmp(string, "5 is 5") == 0);
-    return 0;
-}
-
-TEST(push_formatstring)
-{
-    hs_pushstring(L, "%s is 'hello'", "hello");
-    mu_assert("no string at top of stack!", lua_isstring(L, -1));
-    const char *string = lua_tostring(L, -1);
-    mu_assert("string != 'hello is 'hello''",
-	      strcmp(string, "hello is 'hello'") == 0);
-    return 0;
-}
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * RUN TESTS
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-int main()
-{
-    printf("================ start tests ================\n\n");
-
-    printf("running hs_type_to_string() tests...\n");
-    mu_run_test("bool to string", hs_bool_to_string);
-    mu_run_test("int to string", hs_int_to_string);
-    mu_run_test("num to string", hs_num_to_string);
-    mu_run_test("str to string", hs_str_to_string);
-    mu_run_test("tbl to string", hs_tbl_to_string);
-    mu_run_test("func to string", hs_func_to_string);
-    mu_run_test("cfunc to string", hs_cfunc_to_string);
-    mu_run_test("user to string", hs_user_to_string);
-    mu_run_test("light to string", hs_light_to_string);
-    mu_run_test("nil to string", hs_nil_to_string);
-    mu_run_test("any to string", hs_any_to_string);
-
-    printf("running hs_parse_args() typechecking tests...\n");
-    mu_run_test("parse bool typecheck", parse_bool_typecheck);
-    mu_run_test("parse int typecheck", parse_int_typecheck);
-    mu_run_test("parse num typecheck", parse_num_typecheck);
-    mu_run_test("parse string typecheck", parse_string_typecheck);
-    mu_run_test("parse table typecheck", parse_table_typecheck);
-    mu_run_test("parse func typecheck", parse_func_typecheck);
-    mu_run_test("parse cfunc typecheck", parse_cfunc_typecheck);
-    mu_run_test("parse user typecheck", parse_user_typecheck);
-    mu_run_test("parse light typecheck", parse_light_typecheck);
-    mu_run_test("parse nil typecheck", parse_nil_typecheck);
-    mu_run_test("parse any typecheck", parse_any_typecheck);
-
-    printf("running hs_parse_args() parsing tests...\n");
-    mu_run_test("parse bool", parse_bool);
-    mu_run_test("parse int", parse_int);
-    mu_run_test("parse num", parse_num);
-    mu_run_test("parse str", parse_str);
-    mu_run_test("parse tbl", parse_tbl);
-    mu_run_test("parse func", parse_func);
-    mu_run_test("parse cfunc", parse_cfunc);
-    mu_run_test("fail parse noncfunc", fail_parse_noncfunc);
-    mu_run_test("parse userdata", parse_userdata);
-    mu_run_test("parse lightuserdata", parse_lightuserdata);
-    mu_run_test("parse nil", parse_nil);
-    mu_run_test("parse any", parse_any);
-    mu_run_test("parse all", parse_all);
-    mu_run_test("parse readme example", parse_readme_example);
-
-    printf("running hs_parse_overloaded() parsing tests...\n");
-    mu_run_test("parse bool overloaded", parse_bool_overloaded);
-    mu_run_test("parse integer overloaded", parse_integer_overloaded);
-    mu_run_test("parse number overloaded", parse_number_overloaded);
-    mu_run_test("parse string overloaded", parse_string_overloaded);
-    mu_run_test("parse table overloaded", parse_table_overloaded);
-    mu_run_test("parse function overloaded", parse_function_overloaded);
-    mu_run_test("parse cfunction overloaded", parse_cfunction_overloaded);
-    mu_run_test("parse userdata overloaded", parse_userdata_overloaded);
-    mu_run_test("parse lightuserdata overloaded", parse_lightuserdata_overloaded);
-    mu_run_test("parse nil overloaded", parse_nil_overloaded);
-    mu_run_test("parse 2/3 overload 0", parse_2_3_overload_0);
-    mu_run_test("parse 2/3 overload 1", parse_2_3_overload_1);
-
-    printf("running hs_create_table() tests...\n");
-    mu_run_test("return correct stack index", table_correct_index);
-    mu_run_test("check creation of basic types", table_create_basic_types);
-
-    printf("running hs_pushstring() tests...\n");
-    mu_run_test("hs_pushstring (no printf formatting)", push_noformat);
-    mu_run_test("hs_pushstring (integer formatting)", push_formatint);
-    mu_run_test("hs_pushstring (string formatting)", push_formatstring);
-
-    printf("\n=============== tests finished ===============\n\n");
-
-    const char *color = tests_failed == 0 ? GREEN : RED;
-    printf("%sran %d tests, %d failed\n" RESET, color, tests_run, tests_failed);
-    return 0;
-}