begin refactor of tests into individual source files

8 files changed, 1154 insertions, 0 deletions

diff --git a/src/tests/colors.h b/src/tests/colors.h
new file mode 100644
index 0000000..21451de
--- /dev/null
+++ b/src/tests/colors.h
@@ -0,0 +1,22 @@
+#ifndef COLORS_H
+#define COLORS_H
+
+#define RESET   "\033[0m"
+#define BLACK   "\033[30m"      /* Black */
+#define RED     "\033[31m"      /* Red */
+#define GREEN   "\033[32m"      /* Green */
+#define YELLOW  "\033[33m"      /* Yellow */
+#define BLUE    "\033[34m"      /* Blue */
+#define MAGENTA "\033[35m"      /* Magenta */
+#define CYAN    "\033[36m"      /* Cyan */
+#define WHITE   "\033[37m"      /* White */
+#define BOLDBLACK   "\033[1m\033[30m"      /* Bold Black */
+#define BOLDRED     "\033[1m\033[31m"      /* Bold Red */
+#define BOLDGREEN   "\033[1m\033[32m"      /* Bold Green */
+#define BOLDYELLOW  "\033[1m\033[33m"      /* Bold Yellow */
+#define BOLDBLUE    "\033[1m\033[34m"      /* Bold Blue */
+#define BOLDMAGENTA "\033[1m\033[35m"      /* Bold Magenta */
+#define BOLDCYAN    "\033[1m\033[36m"      /* Bold Cyan */
+#define BOLDWHITE   "\033[1m\033[37m"      /* Bold White */
+
+#endif
diff --git a/src/tests/hs_create_table_tests.c b/src/tests/hs_create_table_tests.c
new file mode 100644
index 0000000..feca8f5
--- /dev/null
+++ b/src/tests/hs_create_table_tests.c
@@ -0,0 +1,139 @@
+#include "hs_tests.h"
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * 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;
+}
+
+
+TEST(table_nesting)
+{
+    int top_init = lua_gettop(L);
+    
+    hs_create_table
+	(L,
+	 "subtable1", HS_TBL,
+	 hs_create_table(L,
+			 "subsubtable1", HS_TBL,
+			 hs_create_table(L,
+					 "fourteen", HS_INT, 14,
+					 "phi", HS_NUM, 1.61803f,
+					 HS_END),
+			 HS_END),
+	 "subtable2", HS_TBL,
+	 hs_create_table(L,
+			 "subsubtable2", HS_TBL,
+			 hs_create_table(L,
+					 "subsubsubtable", HS_TBL,
+					 hs_create_table(L, HS_END),
+					 HS_END),
+			 HS_END),
+	 HS_END);
+
+    lua_getfield(L, -1, "subtable1");
+    mu_assert("subtable1 is not a table!", lua_istable(L, -1));
+    lua_getfield(L, -1, "subsubtable1");
+    mu_assert("subsubtable1 is not a table!", lua_istable(L, -1));
+    check_int("fourteen", 14);
+    check_num("phi", 1.61803f);
+    lua_pop(L, 2);
+
+    lua_getfield(L, -1, "subtable2");
+    mu_assert("subtable2 is not a table!", lua_istable(L, -1));
+    lua_getfield(L, -1, "subsubtable2");
+    mu_assert("subsubtable2 is not a table!", lua_istable(L, -1));
+    lua_getfield(L, -1, "subsubsubtable");
+    mu_assert("subsubsubtable is not a table!", lua_istable(L, -1));
+    lua_pop(L, 4);
+
+    mu_assert("more than one new item on stack!",
+	      lua_gettop(L) == top_init + 1);
+    return 0;    
+}
+
+
+TEST(table_pop_indices)
+{
+    int top_init = lua_gettop(L);
+    int subtable1_index = hs_create_table(L, HS_END);
+    int subtable2_index = hs_create_table(L, HS_END);
+
+    hs_create_table(L,
+		    "sub1", HS_TBL, subtable1_index,
+		    "sub2", HS_TBL, subtable2_index,
+		    HS_END);
+
+    mu_assert("failed to remove subtables from the stack!",
+	      lua_gettop(L) == top_init + 1);
+    return 0;
+}
+
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * test suite
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+void hs_create_table_tests()
+{
+    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);
+    mu_run_test("check table nesting", table_nesting);
+}
diff --git a/src/tests/hs_parse_args_tests.c b/src/tests/hs_parse_args_tests.c
new file mode 100644
index 0000000..829c144
--- /dev/null
+++ b/src/tests/hs_parse_args_tests.c
@@ -0,0 +1,584 @@
+#include "hs_tests.h"
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * 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;
+}
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * test suite
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+void hs_parse_args_tests()
+{
+    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);
+}
diff --git a/src/tests/hs_parse_overloaded_tests.c b/src/tests/hs_parse_overloaded_tests.c
new file mode 100644
index 0000000..de364db
--- /dev/null
+++ b/src/tests/hs_parse_overloaded_tests.c
@@ -0,0 +1,172 @@
+#include "hs_tests.h"
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * 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;
+}
+
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * test suite
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+void hs_parse_overloaded_tests()
+{
+    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);
+}
diff --git a/src/tests/hs_pushstring_tests.c b/src/tests/hs_pushstring_tests.c
new file mode 100644
index 0000000..e7fa1b4
--- /dev/null
+++ b/src/tests/hs_pushstring_tests.c
@@ -0,0 +1,52 @@
+#include "hs_tests.h"
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * 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;
+}
+
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * test suite
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+void hs_pushstring_tests()
+{
+    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);
+}
diff --git a/src/tests/hs_tests.h b/src/tests/hs_tests.h
new file mode 100644
index 0000000..df73318
--- /dev/null
+++ b/src/tests/hs_tests.h
@@ -0,0 +1,55 @@
+#pragma once
+
+#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);                                       \
+	const 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 const char* name(lua_State *L)
+
+extern int tests_run, tests_failed;
+
+void hs_type_to_string_tests();
+void hs_parse_args_tests();
+void hs_parse_overloaded_tests();
+void hs_create_table_tests();
+void hs_create_enum_tests();
+void hs_process_table_tests();
+void hs_throw_error_tests();
+void hs_traceback_tests();
+void hs_call_tests();
+void hs_call_args_tests();
+void hs_pushstring_tests();
+void hs_rxx_tests();
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * tests for hs_create_enum
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+#define check_value(string, value) 
+
+
diff --git a/src/tests/hs_type_to_string_tests.c b/src/tests/hs_type_to_string_tests.c
new file mode 100644
index 0000000..3b158ab
--- /dev/null
+++ b/src/tests/hs_type_to_string_tests.c
@@ -0,0 +1,102 @@
+#include "hs_tests.h"
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * 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;
+}
+
+
+void hs_type_to_string_tests()
+{
+    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);
+}
diff --git a/src/tests/tests_main.c b/src/tests/tests_main.c
new file mode 100644
index 0000000..06c6940
--- /dev/null
+++ b/src/tests/tests_main.c
@@ -0,0 +1,28 @@
+#include "hs_tests.h"
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * RUN TESTS
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+int tests_run = 0;
+int tests_failed = 0;
+
+int main()
+{
+    printf("================ start tests ================\n\n");
+
+    hs_type_to_string_tests();
+    hs_parse_args_tests();
+    hs_parse_overloaded_tests();
+
+    hs_pushstring_tests();
+
+    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 tests_failed;
+}