begin refactor of tests into individual source files

1 files changed, 584 insertions, 0 deletions

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);
+}