#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;
}


/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 * 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;
}


/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 * 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);

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

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