diff options
Diffstat (limited to 'libs/honeysuckle')
25 files changed, 0 insertions, 5177 deletions
diff --git a/libs/honeysuckle/.gitignore b/libs/honeysuckle/.gitignore deleted file mode 100644 index 588f95f..0000000 --- a/libs/honeysuckle/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -*~ -build -src/va_nargs.c diff --git a/libs/honeysuckle/CMakeLists.txt b/libs/honeysuckle/CMakeLists.txt deleted file mode 100644 index 1e16f40..0000000 --- a/libs/honeysuckle/CMakeLists.txt +++ /dev/null @@ -1,86 +0,0 @@ -cmake_minimum_required(VERSION 3.2) -project(honeysuckle - VERSION 0.1.0 - DESCRIPTION "A C library to make writing lua bindings simple") - -# build and link the library -set(HS_ROOT ${honeysuckle_SOURCE_DIR}/src) -set(HONEYSUCKLE_SOURCES - ${HS_ROOT}/hs_type_to_string.c - ${HS_ROOT}/hs_pushstring.c - ${HS_ROOT}/hs_throw_error.c - ${HS_ROOT}/hs_parse_args.c - ${HS_ROOT}/hs_create_table.c - ${HS_ROOT}/hs_process_table.c - ${HS_ROOT}/hs_traceback.c - ) -add_library(honeysuckle ${HONEYSUCKLE_SOURCES}) -set_target_properties(honeysuckle PROPERTIES - C_STANDARD 99 - CMAKE_C_FLAGS "-Wall -Wextra -Werror -Wfatal-errors -Wpedantic") -target_link_libraries(honeysuckle ${LUA_LIBRARIES}) -set_target_properties(honeysuckle PROPERTIES - VERSION ${PROJECT_VERSION} - PUBLIC_HEADER src/honeysuckle.h) - - -# optionally build the tests -set(TEST_ROOT ${honeysuckle_SOURCE_DIR}/src/tests) -set(TEST_SOURCES - ${TEST_ROOT}/tests_main.c - ${TEST_ROOT}/hs_type_to_string_tests.c - ${TEST_ROOT}/hs_parse_args_tests.c - ${TEST_ROOT}/hs_parse_overloaded_tests.c - ${TEST_ROOT}/hs_create_table_tests.c - ${TEST_ROOT}/hs_process_table_tests.c - ${TEST_ROOT}/hs_throw_error_tests.c - # ${TEST_ROOT}/hs_traceback_tests.c - # ${TEST_ROOT}/hs_call_tests.c - # ${TEST_ROOT}/hs_call_args_tests.c - ${TEST_ROOT}/hs_pushstring_tests.c - # ${TEST_ROOT}/hs_rxx_tests.c - ) -add_executable(hs-test EXCLUDE_FROM_ALL ${TEST_SOURCES}) -set_target_properties(hs-test PROPERTIES - C_STANDARD 99 - CMAKE_C_FLAGS "-Wall -Wextra -Werror -Wfatal-errors -Wpedantic") -target_link_libraries(hs-test ${LUA_LIBRARIES} honeysuckle) - - -# optionally build the examples -set(EX_ROOT ${honeysuckle_SOURCE_DIR}/examples) - -add_executable(example_table_creation EXCLUDE_FROM_ALL - ${EX_ROOT}/table_creation/table_creation.c) -set_target_properties(example_table_creation PROPERTIES - C_STANDARD 99 - CMAKE_C_FLAGS "-Wall -Wextra -Werror -Wfatal-errors -Wpedantic") -target_link_libraries(example_table_creation ${LUA_LIBRARIES} honeysuckle) - -add_executable(example_argument_parsing EXCLUDE_FROM_ALL - ${EX_ROOT}/argument_parsing/argument_parsing.c) -set_target_properties(example_argument_parsing PROPERTIES - C_STANDARD 99 - CMAKE_C_FLAGS "-Wall -Wextra -Werror -Wfatal-errors -Wpedantic") -target_link_libraries(example_argument_parsing ${LUA_LIBRARIES} honeysuckle) - -add_executable(example_table_processing EXCLUDE_FROM_ALL - ${EX_ROOT}/table_processing/table_processing.c) -set_target_properties(example_table_processing PROPERTIES - C_STANDARD 99 - CMAKE_C_FLAGS "-Wall -Wextra -Werror -Wfatal-errors -Wpedantic") -target_link_libraries(example_table_processing ${LUA_LIBRARIES} honeysuckle) - - -add_custom_target(examples) -add_dependencies(examples - example_table_creation - example_argument_parsing - example_table_processing) - - -include(GNUInstallDirs) - -install(TARGETS honeysuckle - LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} - PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) diff --git a/libs/honeysuckle/LICENSE b/libs/honeysuckle/LICENSE deleted file mode 100644 index a3b67bc..0000000 --- a/libs/honeysuckle/LICENSE +++ /dev/null @@ -1,37 +0,0 @@ -ANTI-CAPITALIST SOFTWARE LICENSE (v 1.4) - -Copyright © 2020-2021 Kate Swanson - -This is anti-capitalist software, released for free use by -individuals and organizations that do not operate by capitalist -principles. - -Permission is hereby granted, free of charge, to any person or -organization (the "User") obtaining a copy of this software and -associated documentation files (the "Software"), to use, copy, -modify, merge, distribute, and/or sell copies of the Software, -subject to the following conditions: - -1. The above copyright notice and this permission notice shall be -included in all copies or modified versions of the Software. - -2. The User is one of the following: -a. An individual person, laboring for themselves -b. A non-profit organization -c. An educational institution -d. An organization that seeks shared profit for all of its members, -and allows non-members to set the cost of their labor - -3. If the User is an organization with owners, then all owners are -workers and all workers are owners with equal equity and/or equal vote. - -4. If the User is an organization, then the User is not law -enforcement or military, or working for or under either. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT EXPRESS OR IMPLIED -WARRANTY OF ANY KIND, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY -CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file diff --git a/libs/honeysuckle/README.md b/libs/honeysuckle/README.md deleted file mode 100644 index 6919f58..0000000 --- a/libs/honeysuckle/README.md +++ /dev/null @@ -1,78 +0,0 @@ ---- -layout: base -title: honeysuckle README ---- - -honeysuckle -=========== - -A pure C library to make writing Lua bindings simple. honeysuckle provides -functions to make argument parsing, table operations, error creation and -handling, string wrangling, and registry operations easy and straightforward -from within your C code. - -Table of contents ------------------ - -- [Installation](#installation) -- [Documentation](#documentation) -- [Development](#development) -- [License](#license) -- [Footer](#footer) - -Installation ------------- - -[(Back to top)](#table-of-contents) - -honeysuckle requires CMake and the Lua 5.1 development files. - -First, [download a honeysuckle release](/projects/honeysuckle/releases), -and then do - -```bash -mkdir build -cd build -cmake .. -make -sudo make install -``` - -You should now be able to include `<honeysuckle.h>` into your C -files for use. - -To make the tests as well, do the above and then do `make test`. -To make the examples, do `make examples`. - - -Documentation ------ - -You can view the honeysuckle documentation [on the honey wiki](https://honey3d.org/wiki/doku.php?id=honeysuckle). - -Development ------------ -[(Back to top)](#table-of-contents) - -honeysuckle is still very early in development. As the specifics of -the build process and testing become clearer I'll update this -section. - -If you're interested in helping out, send me an email! The to-dos at -the time of writing are: - -* Write initial tests for errors, tracebacks, and function calling -* Implement everything -* Expand the test cases. - -License -------- - -[(Back to top)](#table-of-contents) - - -honeysuckle is licensed under the [Anti-Capitalist Software License]. -Basically: if you're a single person, a co-op, or a nonprofit, feel free to -use this. Otherwise, send me an email. c: - -[Anti-Capitalist Software License]: https://anticapitalist.software diff --git a/libs/honeysuckle/examples/argument_parsing/argument_parsing.c b/libs/honeysuckle/examples/argument_parsing/argument_parsing.c deleted file mode 100644 index 11a48f4..0000000 --- a/libs/honeysuckle/examples/argument_parsing/argument_parsing.c +++ /dev/null @@ -1,23 +0,0 @@ -#include <honeysuckle.h> - -int demo(lua_State *L) -{ - lua_Integer i; - lua_Number n; - char *string; - hs_parse_args(L, hs_int(i), hs_num(n), hs_str(string)); - printf("received %ld, %f, and %s\n", i, n, string); - return 0; -} - -int main() -{ - lua_State *L = luaL_newstate(); - luaL_openlibs(L); - - lua_pushcfunction(L, demo); - lua_setglobal(L, "demo"); - - luaL_dostring(L, "demo(12, 34.4, 'hi there!')"); - return 0; -} diff --git a/libs/honeysuckle/examples/table_creation/table_creation.c b/libs/honeysuckle/examples/table_creation/table_creation.c deleted file mode 100644 index 42088c6..0000000 --- a/libs/honeysuckle/examples/table_creation/table_creation.c +++ /dev/null @@ -1,28 +0,0 @@ -#include <honeysuckle.h> - -int main() -{ - lua_State *L = luaL_newstate(); - luaL_openlibs(L); - - /* create the table - * { "one"=1, "two"=2, "half"=0.5, "runme"=[some function] } - */ - luaL_dostring(L, - "return function(self) \n" \ - "print(self.one)\n" \ - "print(self.two)\n" \ - "print(self.half)\n" \ - "end"); - int func_index = lua_gettop(L); - - hs_create_table(L, - hs_str_int("one", 1), - hs_str_int("two", 2), - hs_str_num("half", 0.5f), - hs_str_func("runme", func_index)); - lua_setglobal(L, "runnable"); - - luaL_dostring(L, "runnable:runme()"); - return 0; -} diff --git a/libs/honeysuckle/examples/table_processing/table_processing.c b/libs/honeysuckle/examples/table_processing/table_processing.c deleted file mode 100644 index 64c1f01..0000000 --- a/libs/honeysuckle/examples/table_processing/table_processing.c +++ /dev/null @@ -1,60 +0,0 @@ -#include <string.h> -#include <stdlib.h> -#include <honeysuckle.h> - -struct settings -{ - bool debug; - int debug_level; - char *logfile; -} global_settings; - -void set_logfile(const char* filename, void *s) -{ - struct settings *settings = (struct settings *) s; - settings->logfile = malloc(sizeof(char) * strlen(filename)); - strcpy(settings->logfile, filename); -} - -int process(lua_State *L) -{ - int table_index; - hs_parse_args(L, hs_tbl(table_index)); - hs_process_table(L, table_index, - hs_process_bool("debug", - hs_pt_set_boolean, - &(global_settings.debug)), - hs_process_int("level", - hs_pt_set_integer, - &(global_settings.debug_level)), - hs_process_str("logfile", - set_logfile, - &global_settings)); - return 0; -} - -int main() -{ - lua_State *L = luaL_newstate(); - luaL_openlibs(L); - - lua_pushcfunction(L, process); - lua_setglobal(L, "configure"); - - global_settings.debug = false; - global_settings.debug_level = 0; - global_settings.logfile = "nil"; - - printf("settings: [ %d, %d, '%s' ]\n", - global_settings.debug, - global_settings.debug_level, - global_settings.logfile); - - luaL_dostring(L, "configure{debug=true, level=6, logfile='output.log'}"); - - printf("settings: [ %d, %d, '%s' ]\n", - global_settings.debug, - global_settings.debug_level, - global_settings.logfile); - return 0; -} diff --git a/libs/honeysuckle/src/honeysuckle.h b/libs/honeysuckle/src/honeysuckle.h deleted file mode 100644 index 96243ba..0000000 --- a/libs/honeysuckle/src/honeysuckle.h +++ /dev/null @@ -1,523 +0,0 @@ -#ifndef HONEYSUCKLE_H -#define HONEYSUCKLE_H - -#include <stdbool.h> - -#include <lua.h> -#include <lualib.h> -#include <lauxlib.h> - -/* variadic macro argument counting */ -#ifndef VA_NARGS - -#define VA_NARGS(...) VA_NARGS_SHIFT_COUNT(__VA_ARGS__, VA_NARGS_COUNTS) - -#define VA_NARGS_COUNTS \ - 255, 254, 253, 252, 251, 250, 249, 248, \ - 247, 246, 245, 244, 243, 242, 241, 240, \ - 239, 238, 237, 236, 235, 234, 233, 232, \ - 231, 230, 229, 228, 227, 226, 225, 224, \ - 223, 222, 221, 220, 219, 218, 217, 216, \ - 215, 214, 213, 212, 211, 210, 209, 208, \ - 207, 206, 205, 204, 203, 202, 201, 200, \ - 199, 198, 197, 196, 195, 194, 193, 192, \ - 191, 190, 189, 188, 187, 186, 185, 184, \ - 183, 182, 181, 180, 179, 178, 177, 176, \ - 175, 174, 173, 172, 171, 170, 169, 168, \ - 167, 166, 165, 164, 163, 162, 161, 160, \ - 159, 158, 157, 156, 155, 154, 153, 152, \ - 151, 150, 149, 148, 147, 146, 145, 144, \ - 143, 142, 141, 140, 139, 138, 137, 136, \ - 135, 134, 133, 132, 131, 130, 129, 128, \ - 127, 126, 125, 124, 123, 122, 121, 120, \ - 119, 118, 117, 116, 115, 114, 113, 112, \ - 111, 110, 109, 108, 107, 106, 105, 104, \ - 103, 102, 101, 100, 99, 98, 97, 96, \ - 95, 94, 93, 92, 91, 90, 89, 88, \ - 87, 86, 85, 84, 83, 82, 81, 80, \ - 79, 78, 77, 76, 75, 74, 73, 72, \ - 71, 70, 69, 68, 67, 66, 65, 64, \ - 63, 62, 61, 60, 59, 58, 57, 56, \ - 55, 54, 53, 52, 51, 50, 49, 48, \ - 47, 46, 45, 44, 43, 42, 41, 40, \ - 39, 38, 37, 36, 35, 34, 33, 32, \ - 31, 30, 29, 28, 27, 26, 25, 24, \ - 23, 22, 21, 20, 19, 18, 17, 16, \ - 15, 14, 13, 12, 11, 10, 9, 8, \ - 7, 6, 5, 4, 3, 2, 1, 0 - -#define VA_NARGS_GET_COUNT( \ - _255, _254, _253, _252, _251, _250, _249, _248, \ - _247, _246, _245, _244, _243, _242, _241, _240, \ - _239, _238, _237, _236, _235, _234, _233, _232, \ - _231, _230, _229, _228, _227, _226, _225, _224, \ - _223, _222, _221, _220, _219, _218, _217, _216, \ - _215, _214, _213, _212, _211, _210, _209, _208, \ - _207, _206, _205, _204, _203, _202, _201, _200, \ - _199, _198, _197, _196, _195, _194, _193, _192, \ - _191, _190, _189, _188, _187, _186, _185, _184, \ - _183, _182, _181, _180, _179, _178, _177, _176, \ - _175, _174, _173, _172, _171, _170, _169, _168, \ - _167, _166, _165, _164, _163, _162, _161, _160, \ - _159, _158, _157, _156, _155, _154, _153, _152, \ - _151, _150, _149, _148, _147, _146, _145, _144, \ - _143, _142, _141, _140, _139, _138, _137, _136, \ - _135, _134, _133, _132, _131, _130, _129, _128, \ - _127, _126, _125, _124, _123, _122, _121, _120, \ - _119, _118, _117, _116, _115, _114, _113, _112, \ - _111, _110, _109, _108, _107, _106, _105, _104, \ - _103, _102, _101, _100, _99, _98, _97, _96, \ - _95, _94, _93, _92, _91, _90, _89, _88, \ - _87, _86, _85, _84, _83, _82, _81, _80, \ - _79, _78, _77, _76, _75, _74, _73, _72, \ - _71, _70, _69, _68, _67, _66, _65, _64, \ - _63, _62, _61, _60, _59, _58, _57, _56, \ - _55, _54, _53, _52, _51, _50, _49, _48, \ - _47, _46, _45, _44, _43, _42, _41, _40, \ - _39, _38, _37, _36, _35, _34, _33, _32, \ - _31, _30, _29, _28, _27, _26, _25, _24, \ - _23, _22, _21, _20, _19, _18, _17, _16, \ - _15, _14, _13, _12, _11, _10, _9, _8, \ - _7, _6, _5, _4, _3, _2, _1, N, ...) N - -#define VA_NARGS_SHIFT_COUNT(...) VA_NARGS_GET_COUNT(__VA_ARGS__) - -#endif - - -/* type constants */ -typedef enum - { HS_BOOL, - HS_INT, - HS_NUM, - HS_STR, - HS_TBL, - HS_FUNC, - HS_CFUNC, - HS_USER, - HS_LIGHT, - HS_NIL, - HS_ANY, - } hs_type; - -const char* hs_type_to_string(hs_type type); - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * hs_parse_args and hs_parse_overloaded - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -struct hs_arg { - hs_type type; - union { - bool *boolean; - lua_Integer *integer; - lua_Number *number; - char **string; - int *stack_index; - lua_CFunction *function; - void **userdata; - } ptr; -}; - -#define hs_bool(x) { .type=HS_BOOL, .ptr.boolean = &(x) } -#define hs_int(x) { .type=HS_INT, .ptr.integer = &(x) } -#define hs_num(x) { .type=HS_NUM, .ptr.number = &(x) } -#define hs_str(x) { .type=HS_STR, .ptr.string = &(x) } -#define hs_tbl(x) { .type=HS_TBL, .ptr.stack_index = &(x) } -#define hs_func(x) { .type=HS_FUNC, .ptr.stack_index = &(x) } -#define hs_cfunc(x) { .type=HS_CFUNC, .ptr.function = &(x) } -#define hs_user(x) { .type=HS_USER, .ptr.userdata = &(x) } -#define hs_light(x) { .type=HS_LIGHT, .ptr.userdata = &(x) } -#define hs_nil(x) { .type=HS_NIL, .ptr.stack_index = &(x) } -#define hs_any(x) { .type=HS_ANY, .ptr.stack_index = &(x) } - -void hs_parse_args_(lua_State *L, int n_args, struct hs_arg *arguments); - -#define hs_parse_args(L, ...) \ - hs_parse_args_(L, \ - VA_NARGS(__VA_ARGS__)/2, \ - (struct hs_arg[]) { __VA_ARGS__ }) - - -#define hs_overload(...) VA_NARGS(__VA_ARGS__)/2, (struct hs_arg[]) { __VA_ARGS__ } - -int hs_parse_overloaded_(lua_State *L, ...); - -#define hs_parse_overloaded(L, ...) \ - hs_parse_overloaded_(L, __VA_ARGS__, -1) - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * hs_create_table - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -typedef union { - bool boolean; - lua_Integer integer; - lua_Number number; - char *string; - int stack_index; - lua_CFunction function; - void *userdata; -} hs_value; - -struct hs_tbl_entry { - hs_type key_type; - hs_value key; - hs_type value_type; - hs_value value; -}; - -#define hs_bool_bool(k, v) \ - { .key_type=HS_BOOL, .key.boolean=k, \ - .value_type=HS_BOOL, .value.boolean=v } -#define hs_bool_int(k, v) \ - { .key_type=HS_BOOL, .key.boolean=k, \ - .value_type=HS_INT, .value.integer=v } -#define hs_bool_num(k, v) \ - { .key_type=HS_BOOL, .key.boolean=k, \ - .value_type=HS_NUM, .value.number=v } -#define hs_bool_str(k, v) \ - { .key_type=HS_BOOL, .key.boolean=k, \ - .value_type=HS_STR, .value.string=v } -#define hs_bool_tbl(k, v) \ - { .key_type=HS_BOOL, .key.boolean=k, \ - .value_type=HS_TBL, .value.stack_index=v } -#define hs_bool_func(k, v) \ - { .key_type=HS_BOOL, .key.boolean=k, \ - .value_type=HS_FUNC, .value.stack_index=v } -#define hs_bool_cfunc(k, v) \ - { .key_type=HS_BOOL, .key.boolean=k, \ - .value_type=HS_CFUNC, .value.function=v } -#define hs_bool_user(k, v) \ - { .key_type=HS_BOOL, .key.boolean=k, \ - .value_type=HS_USER, .value.stack_index=v } -#define hs_bool_light(k, v) \ - { .key_type=HS_BOOL, .key.boolean=k, \ - .value_type=HS_LIGHT, .value.userdata=v } - -#define hs_int_bool(k, v) \ - { .key_type=HS_INT, .key.integer=k, \ - .value_type=HS_BOOL, .value.boolean=v } -#define hs_int_int(k, v) \ - { .key_type=HS_INT, .key.integer=k, \ - .value_type=HS_INT, .value.integer=v } -#define hs_int_num(k, v) \ - { .key_type=HS_INT, .key.integer=k, \ - .value_type=HS_NUM, .value.number=v } -#define hs_int_str(k, v) \ - { .key_type=HS_INT, .key.integer=k, \ - .value_type=HS_STR, .value.string=v } -#define hs_int_tbl(k, v) \ - { .key_type=HS_INT, .key.integer=k, \ - .value_type=HS_TBL, .value.stack_index=v } -#define hs_int_func(k, v) \ - { .key_type=HS_INT, .key.integer=k, \ - .value_type=HS_FUNC, .value.stack_index=v } -#define hs_int_cfunc(k, v) \ - { .key_type=HS_INT, .key.integer=k, \ - .value_type=HS_CFUNC, .value.function=v } -#define hs_int_user(k, v) \ - { .key_type=HS_INT, .key.integer=k, \ - .value_type=HS_USER, .value.stack_index=v } -#define hs_int_light(k, v) \ - { .key_type=HS_INT, .key.integer=k, \ - .value_type=HS_LIGHT, .value.userdata=v } - -#define hs_num_bool(k, v) \ - { .key_type=HS_NUM, .key.number=k, \ - .value_type=HS_BOOL, .value.boolean=v } -#define hs_num_int(k, v) \ - { .key_type=HS_NUM, .key.number=k, \ - .value_type=HS_INT, .value.integer=v } -#define hs_num_num(k, v) \ - { .key_type=HS_NUM, .key.number=k, \ - .value_type=HS_NUM, .value.number=v } -#define hs_num_str(k, v) \ - { .key_type=HS_NUM, .key.number=k, \ - .value_type=HS_STR, .value.string=v } -#define hs_num_tbl(k, v) \ - { .key_type=HS_NUM, .key.number=k, \ - .value_type=HS_TBL, .value.stack_index=v } -#define hs_num_func(k, v) \ - { .key_type=HS_NUM, .key.number=k, \ - .value_type=HS_FUNC, .value.stack_index=v } -#define hs_num_cfunc(k, v) \ - { .key_type=HS_NUM, .key.number=k, \ - .value_type=HS_CFUNC, .value.function=v } -#define hs_num_user(k, v) \ - { .key_type=HS_NUM, .key.number=k, \ - .value_type=HS_USER, .value.stack_index=v } -#define hs_num_light(k, v) \ - { .key_type=HS_NUM, .key.number=k, \ - .value_type=HS_LIGHT, .value.userdata=v } - -#define hs_str_bool(k, v) \ - { .key_type=HS_STR, .key.string=k, \ - .value_type=HS_BOOL, .value.boolean=v } -#define hs_str_int(k, v) \ - { .key_type=HS_STR, .key.string=k, \ - .value_type=HS_INT, .value.integer=v } -#define hs_str_num(k, v) \ - { .key_type=HS_STR, .key.string=k, \ - .value_type=HS_NUM, .value.number=v } -#define hs_str_str(k, v) \ - { .key_type=HS_STR, .key.string=k, \ - .value_type=HS_STR, .value.string=v } -#define hs_str_tbl(k, v) \ - { .key_type=HS_STR, .key.string=k, \ - .value_type=HS_TBL, .value.stack_index=v } -#define hs_str_func(k, v) \ - { .key_type=HS_STR, .key.string=k, \ - .value_type=HS_FUNC, .value.stack_index=v } -#define hs_str_cfunc(k, v) \ - { .key_type=HS_STR, .key.string=k, \ - .value_type=HS_CFUNC, .value.function=v } -#define hs_str_user(k, v) \ - { .key_type=HS_STR, .key.string=k, \ - .value_type=HS_USER, .value.stack_index=v } -#define hs_str_light(k, v) \ - { .key_type=HS_STR, .key.string=k, \ - .value_type=HS_LIGHT, .value.userdata=v } - - -#define hs_tbl_bool(k, v) \ - { .key_type=HS_TBL, .key.stack_index=k, \ - .value_type=HS_BOOL, .value.boolean=v } -#define hs_tbl_int(k, v) \ - { .key_type=HS_TBL, .key.stack_index=k, \ - .value_type=HS_INT, .value.integer=v } -#define hs_tbl_num(k, v) \ - { .key_type=HS_TBL, .key.stack_index=k, \ - .value_type=HS_NUM, .value.number=v } -#define hs_tbl_str(k, v) \ - { .key_type=HS_TBL, .key.stack_index=k, \ - .value_type=HS_STR, .value.string=v } -#define hs_tbl_tbl(k, v) \ - { .key_type=HS_TBL, .key.stack_index=k, \ - .value_type=HS_TBL, .value.stack_index=v } -#define hs_tbl_func(k, v) \ - { .key_type=HS_TBL, .key.stack_index=k, \ - .value_type=HS_FUNC, .value.stack_index=v } -#define hs_tbl_cfunc(k, v) \ - { .key_type=HS_TBL, .key.stack_index=k, \ - .value_type=HS_CFUNC, .value.function=v } -#define hs_tbl_user(k, v) \ - { .key_type=HS_TBL, .key.stack_index=k, \ - .value_type=HS_USER, .value.stack_index=v } -#define hs_tbl_light(k, v) \ - { .key_type=HS_TBL, .key.stack_index=k, \ - .value_type=HS_LIGHT, .value.userdata=v } - -#define hs_func_bool(k, v) \ - { .key_type=HS_FUNC, .key.stack_index=k, \ - .value_type=HS_BOOL, .value.boolean=v } -#define hs_func_int(k, v) \ - { .key_type=HS_FUNC, .key.stack_index=k, \ - .value_type=HS_INT, .value.integer=v } -#define hs_func_num(k, v) \ - { .key_type=HS_FUNC, .key.stack_index=k, \ - .value_type=HS_NUM, .value.number=v } -#define hs_func_str(k, v) \ - { .key_type=HS_FUNC, .key.stack_index=k, \ - .value_type=HS_STR, .value.string=v } -#define hs_func_tbl(k, v) \ - { .key_type=HS_FUNC, .key.stack_index=k, \ - .value_type=HS_TBL, .value.stack_index=v } -#define hs_func_func(k, v) \ - { .key_type=HS_FUNC, .key.stack_index=k, \ - .value_type=HS_FUNC, .value.stack_index=v } -#define hs_func_cfunc(k, v) \ - { .key_type=HS_FUNC, .key.stack_index=k, \ - .value_type=HS_CFUNC, .value.function=v } -#define hs_func_user(k, v) \ - { .key_type=HS_FUNC, .key.stack_index=k, \ - .value_type=HS_USER, .value.stack_index=v } -#define hs_func_light(k, v) \ - { .key_type=HS_FUNC, .key.stack_index=k, \ - .value_type=HS_LIGHT, .value.userdata=v } - -#define hs_cfunc_bool(k, v) \ - { .key_type=HS_CFUNC, .key.function=k, \ - .value_type=HS_BOOL, .value.boolean=v } -#define hs_cfunc_int(k, v) \ - { .key_type=HS_CFUNC, .key.function=k, \ - .value_type=HS_INT, .value.integer=v } -#define hs_cfunc_num(k, v) \ - { .key_type=HS_CFUNC, .key.function=k, \ - .value_type=HS_NUM, .value.number=v } -#define hs_cfunc_str(k, v) \ - { .key_type=HS_CFUNC, .key.function=k, \ - .value_type=HS_STR, .value.string=v } -#define hs_cfunc_tbl(k, v) \ - { .key_type=HS_CFUNC, .key.function=k, \ - .value_type=HS_TBL, .value.stack_index=v } -#define hs_cfunc_func(k, v) \ - { .key_type=HS_CFUNC, .key.function=k, \ - .value_type=HS_FUNC, .value.stack_index=v } -#define hs_cfunc_cfunc(k, v) \ - { .key_type=HS_CFUNC, .key.function=k, \ - .value_type=HS_CFUNC, .value.function=v } -#define hs_cfunc_user(k, v) \ - { .key_type=HS_CFUNC, .key.function=k, \ - .value_type=HS_USER, .value.stack_index=v } -#define hs_cfunc_light(k, v) \ - { .key_type=HS_CFUNC, .key.function=k, \ - .value_type=HS_LIGHT, .value.userdata=v } - -#define hs_user_bool(k, v) \ - { .key_type=HS_USER, .key.stack_index=k, \ - .value_type=HS_BOOL, .value.boolean=v } -#define hs_user_int(k, v) \ - { .key_type=HS_USER, .key.stack_index=k, \ - .value_type=HS_INT, .value.integer=v } -#define hs_user_num(k, v) \ - { .key_type=HS_USER, .key.stack_index=k, \ - .value_type=HS_NUM, .value.number=v } -#define hs_user_str(k, v) \ - { .key_type=HS_USER, .key.stack_index=k, \ - .value_type=HS_STR, .value.string=v } -#define hs_user_tbl(k, v) \ - { .key_type=HS_USER, .key.stack_index=k, \ - .value_type=HS_TBL, .value.stack_index=v } -#define hs_user_func(k, v) \ - { .key_type=HS_USER, .key.stack_index=k, \ - .value_type=HS_FUNC, .value.stack_index=v } -#define hs_user_cfunc(k, v) \ - { .key_type=HS_USER, .key.stack_index=k, \ - .value_type=HS_CFUNC, .value.function=v } -#define hs_user_user(k, v) \ - { .key_type=HS_USER, .key.stack_index=k, \ - .value_type=HS_USER, .value.stack_index=v } -#define hs_user_light(k, v) \ - { .key_type=HS_USER, .key.stack_index=k, \ - .value_type=HS_LIGHT, .value.userdata=v } - -#define hs_light_bool(k, v) \ - { .key_type=HS_LIGHT, .key.userdata=k, \ - .value_type=HS_BOOL, .value.boolean=v } -#define hs_light_int(k, v) \ - { .key_type=HS_LIGHT, .key.userdata=k, \ - .value_type=HS_INT, .value.integer=v } -#define hs_light_num(k, v) \ - { .key_type=HS_LIGHT, .key.userdata=k, \ - .value_type=HS_NUM, .value.number=v } -#define hs_light_str(k, v) \ - { .key_type=HS_LIGHT, .key.userdata=k, \ - .value_type=HS_STR, .value.string=v } -#define hs_light_tbl(k, v) \ - { .key_type=HS_LIGHT, .key.userdata=k, \ - .value_type=HS_TBL, .value.stack_index=v } -#define hs_light_func(k, v) \ - { .key_type=HS_LIGHT, .key.userdata=k, \ - .value_type=HS_FUNC, .value.stack_index=v } -#define hs_light_cfunc(k, v) \ - { .key_type=HS_LIGHT, .key.userdata=k, \ - .value_type=HS_CFUNC, .value.function=v } -#define hs_light_user(k, v) \ - { .key_type=HS_LIGHT, .key.userdata=k, \ - .value_type=HS_USER, .value.stack_index=v } -#define hs_light_light(k, v) \ - { .key_type=HS_LIGHT, .key.userdata=k, \ - .value_type=HS_LIGHT, .value.userdata=v } - -int hs_create_table_(lua_State *L, int n_elements, struct hs_tbl_entry *elements); - -#define hs_create_table(L, ...) \ - hs_create_table_(L, \ - VA_NARGS(__VA_ARGS__)/4, \ - (struct hs_tbl_entry[]) { __VA_ARGS__ }) - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * hs_process_table - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -typedef void (*hs_pt_bool_callback)(bool, void *); -typedef void (*hs_pt_int_callback)(lua_Integer, void *); -typedef void (*hs_pt_num_callback)(lua_Number, void *); -typedef void (*hs_pt_str_callback)(const char *, void *); - - -// default processors -void hs_pt_set_boolean(bool value, void *data); -void hs_pt_set_integer(lua_Integer value, void *data); -void hs_pt_set_number(lua_Number value, void *data); -void hs_pt_set_string(const char *value, void *data); - - -struct hs_table_processor { - const char *key; - hs_type type; - union { - hs_pt_bool_callback boolean; - hs_pt_int_callback integer; - hs_pt_num_callback number; - hs_pt_str_callback string; - } func; - void *data; -}; - -#define hs_process_bool(str, f, d) \ - { .key=(str), .type=HS_BOOL, .func.boolean=(f), .data=(d) } -#define hs_process_int(str, f, d) \ - { .key=(str), .type=HS_INT, .func.integer=(f), .data=(d) } -#define hs_process_num(str, f, d) \ - { .key=(str), .type=HS_NUM, .func.number=(f), .data=(d) } -#define hs_process_str(str, f, d) \ - { .key=(str), .type=HS_STR, .func.string=(f), .data=(d) } - -void hs_process_table_(lua_State *L, - int table_index, - int n_processors, - struct hs_table_processor *processors); - -#define hs_process_table(L, table_index, ...) \ - hs_process_table_(L, table_index, \ - VA_NARGS(__VA_ARGS__)/4, \ - (struct hs_table_processor[]) {__VA_ARGS__}) - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * hs_pushstring - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -void hs_vpushstring(lua_State *L, const char *format_string, va_list args); -void hs_pushstring(lua_State *L, const char *format_string, ...); - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * error creation and handling - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -void hs_throw_error(lua_State *L, const char *format_string, ...); -int hs_traceback(lua_State *L); -int hs_call(lua_State *L, int nargs, int nret); - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * registry operations - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -#define hs_rstore(L) luaL_ref(L, LUA_REGISTRYINDEX); -#define hs_rload(L, ref) lua_rawgeti(L, LUA_REGISTRYINDEX, ref) -#define hs_rdel(L, ref) luaL_unref(L, LUA_REGISTRYINDEX, ref) - -#endif diff --git a/libs/honeysuckle/src/hs_create_table.c b/libs/honeysuckle/src/hs_create_table.c deleted file mode 100644 index 422a480..0000000 --- a/libs/honeysuckle/src/hs_create_table.c +++ /dev/null @@ -1,123 +0,0 @@ -#include <stdlib.h> - -#include "honeysuckle.h" - -static void push_value(lua_State *L, hs_type type, hs_value value) -{ - switch (type) { - case HS_BOOL: - lua_pushboolean(L, value.boolean); - break; - - case HS_INT: - lua_pushinteger(L, value.integer); - break; - - case HS_NUM: - lua_pushnumber(L, value.number); - break; - - case HS_STR: - lua_pushstring(L, value.string); - break; - - case HS_TBL: - lua_pushvalue(L, value.stack_index); - break; - - case HS_FUNC: - lua_pushvalue(L, value.stack_index); - break; - - case HS_CFUNC: - lua_pushcfunction(L, value.function); - break; - - case HS_USER: - lua_pushvalue(L, value.stack_index); - break; - - case HS_LIGHT: - lua_pushlightuserdata(L, value.userdata); - break; - - default: - hs_throw_error(L, "attempted to push data of invalid type %d", type); - break; - } -} - - -static inline bool poppable(hs_type type) -{ - if (type == HS_TBL || - type == HS_FUNC || - type == HS_USER) { - return true; - } - return false; -} - - -static void print_stack(lua_State *L) -{ - printf("stack: %d [", lua_gettop(L)); - for (int i=0; i<lua_gettop(L); i++) { - printf(" %s, ", lua_typename(L, lua_type(L, i+1))); - } - printf("]\n"); -} - - -int descending(const void *a, const void *b) -{ - return (*(int*)b - *(int*)a); -} - -int hs_create_table_(lua_State *L, - int n_elements, - struct hs_tbl_entry *elements) -{ - // printf("start\n"); - - // print_stack(L); - lua_createtable(L, 0, n_elements); - int index = lua_gettop(L); - // print_stack(L); - - for (int i=0; i<n_elements; i++) { - // printf("pushing element %d...\n", i); - struct hs_tbl_entry *e = elements + i; - push_value(L, e->key_type, e->key); - // print_stack(L); - push_value(L, e->value_type, e->value); - // print_stack(L); - lua_rawset(L, index); - // print_stack(L); - } - - int n_poppable = 0; - int pop_indices[n_elements]; - - for (int i=0; i<n_elements; i++) { - struct hs_tbl_entry *e = elements + i; - if (poppable(e->key_type)) - pop_indices[n_poppable++] = e->key.stack_index; - if (poppable(e->value_type)) - pop_indices[n_poppable++] = e->value.stack_index; - } - - // printf("cleaning up\n"); - - qsort(pop_indices, n_poppable, sizeof(int), descending); - for (int i=0; i<n_poppable; i++) { - lua_remove(L, pop_indices[i]); - index -= 1; - // print_stack(L); - } - - - // printf("exit\n"); - - return index; -} diff --git a/libs/honeysuckle/src/hs_parse_args.c b/libs/honeysuckle/src/hs_parse_args.c deleted file mode 100644 index d6d3b3c..0000000 --- a/libs/honeysuckle/src/hs_parse_args.c +++ /dev/null @@ -1,149 +0,0 @@ -#include <stdio.h> - -#include "honeysuckle.h" - -static bool check_parse(lua_State *L, int index, struct hs_arg *expected) -{ - switch(expected->type) { - case HS_BOOL: - if (!lua_isboolean(L, index)) - return false; - *(expected->ptr.boolean) = lua_toboolean(L, index); - return true; - - case HS_INT: - if (!lua_isnumber(L, index)) - return false; - *(expected->ptr.integer) = lua_tointeger(L, index); - return true; - - case HS_NUM: - if (!lua_isnumber(L, index)) - return false; - *(expected->ptr.number) = lua_tonumber(L, index); - return true; - - case HS_STR: - if (!lua_isstring(L, index) || lua_isnumber(L, index)) - return false; - *(expected->ptr.string) = (char *) lua_tostring(L, index); - return true; - - case HS_TBL: - if (!lua_istable(L, index)) - return false; - *(expected->ptr.stack_index) = index; - return true; - - case HS_FUNC: - if (!lua_isfunction(L, index)) - return false; - *(expected->ptr.stack_index) = index; - return true; - - case HS_CFUNC: - if (!lua_iscfunction(L, index)) - return false; - *(expected->ptr.function) = lua_tocfunction(L, index); - return true; - - case HS_USER: - if (!lua_isuserdata(L, index)) - return false; - *(expected->ptr.userdata) = lua_touserdata(L, index); - return true; - - case HS_LIGHT: - if (!lua_islightuserdata(L, index)) - return false; - *(expected->ptr.userdata) = lua_touserdata(L, index); - return true; - - case HS_NIL: - if (!lua_isnil(L, index)) - return false; - *(expected->ptr.stack_index) = index; - - case HS_ANY: - *(expected->ptr.stack_index) = index; - return true; - - default: - return false; - } -} - - -static bool try_parse_args(lua_State *L, int n_args, struct hs_arg *arguments) -{ - int args_provided = lua_gettop(L); - if (args_provided != n_args) - return false; - - for (int i=0; i<n_args; i++) { - bool success = check_parse(L, i+1, arguments + i); - if (!success) - return false; - } - return true; -} - - -void hs_parse_args_(lua_State *L, int n_args, struct hs_arg *arguments) -{ - bool success = try_parse_args(L, n_args, arguments); - if (!success) { - lua_pushstring(L, "expected arguments of the form ("); - for (int i=0; i<n_args; i++) { - lua_pushstring(L, hs_type_to_string(arguments[i].type)); - lua_pushstring(L, ", "); - } - lua_pop(L, 1); - lua_pushstring(L, "); received ("); - const int n_provided = lua_gettop(L); - for (int i=0; i<n_provided; i++) { - lua_pushstring(L, lua_typename(L, lua_type(L, i+1))); - lua_pushstring(L, ", "); - } - lua_pop(L, 1); - lua_pushstring(L, ") instead"); - lua_concat(L, 1 + (2*n_args) + (2*n_provided)); - lua_error(L); - } -} - - -// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -static void hs_overloaded_error(lua_State *L, va_list args) -{ - lua_pushstring(L, "hs_overloaded failed"); - lua_error(L); -} - - -int hs_parse_overloaded_(lua_State *L, ...) -{ - va_list args, args_error; - va_start(args, L); - va_copy(args_error, args); - - int choice = 0; - - while(true) { - int n_args = va_arg(args, int); - if (n_args == -1) - break; - else { - struct hs_arg *arguments = va_arg(args, struct hs_arg *); - if (try_parse_args(L, n_args, arguments)) - return choice; - } - choice++; - } - - hs_overloaded_error(L, args_error); - - va_end(args); - va_end(args_error); -} diff --git a/libs/honeysuckle/src/hs_process_table.c b/libs/honeysuckle/src/hs_process_table.c deleted file mode 100644 index d07d815..0000000 --- a/libs/honeysuckle/src/hs_process_table.c +++ /dev/null @@ -1,86 +0,0 @@ -#include "honeysuckle.h" - -void hs_pt_set_boolean(bool value, void *data) -{ - *(bool *) data = value; -} - -void hs_pt_set_integer(lua_Integer value, void *data) -{ - *(lua_Integer *) data = value; -} - -void hs_pt_set_number(lua_Number value, void *data) -{ - *(lua_Number *) data = value; -} - -void hs_pt_set_string(const char *value, void *data) -{ - *(const char **) data = value; -} - - -static bool process_key(lua_State *L, struct hs_table_processor *p) -{ - switch (p->type) { - case HS_BOOL: - if (!lua_isboolean(L, -1)) - hs_throw_error(L, - "expected key '%s' to be of type boolean, "\ - "but got type %s instead", - p->key, - lua_typename(L, lua_type(L, -1))); - p->func.boolean(lua_toboolean(L, -1), p->data); - break; - - case HS_INT: - if (!lua_isnumber(L, -1)) - hs_throw_error(L, - "expected key '%s' to be of type integer, "\ - "but got type %s instead", - p->key, - lua_typename(L, lua_type(L, -1))); - p->func.integer(lua_tointeger(L, -1), p->data); - break; - - case HS_NUM: - if (!lua_isnumber(L, -1)) - hs_throw_error(L, - "expected key '%s' to be of type number, "\ - "but got type %s instead", - p->key, - lua_typename(L, lua_type(L, -1))); - p->func.number(lua_tonumber(L, -1), p->data); - break; - - case HS_STR: - if (!lua_isstring(L, -1)) - hs_throw_error(L, - "expected key '%s' to be of type string, "\ - "but got type %s instead", - p->key, - lua_typename(L, lua_type(L, -1))); - p->func.string(lua_tostring(L, -1), p->data); - break; - - default: - // bad type value, throw error - hs_throw_error(L, "bad expected type '%d' for key '%s'", - p->type, p->key); - break; - } -} - -void hs_process_table_(lua_State *L, - int table_index, - int n_processors, - struct hs_table_processor *processors) -{ - for (int i=0; i<n_processors; i++) { - lua_getfield(L, table_index, processors[i].key); - if (!lua_isnil(L, -1)) - process_key(L, processors+i); - lua_pop(L, 1); - } -} diff --git a/libs/honeysuckle/src/hs_pushstring.c b/libs/honeysuckle/src/hs_pushstring.c deleted file mode 100644 index f7da0d0..0000000 --- a/libs/honeysuckle/src/hs_pushstring.c +++ /dev/null @@ -1,31 +0,0 @@ -#include <stdlib.h> - -#include "honeysuckle.h" - -void hs_vpushstring(lua_State *L, const char *format_string, va_list args) -{ - va_list args_; - va_copy(args_, args); - - int string_size = vsnprintf(NULL, 0, format_string, args_); - va_end(args_); - - char *string = malloc((string_size+1) * sizeof(char)); - if (string == NULL) { - lua_pushstring(L, "there was an error allocating memory for a string"); - lua_error(L); - } - - vsnprintf(string, string_size+1, format_string, args); - lua_pushstring(L, string); - free(string); -} - - -void hs_pushstring(lua_State *L, const char *format_string, ...) -{ - va_list args; - va_start(args, format_string); - hs_vpushstring(L, format_string, args); - va_end(args); -} diff --git a/libs/honeysuckle/src/hs_throw_error.c b/libs/honeysuckle/src/hs_throw_error.c deleted file mode 100644 index 20a4c6d..0000000 --- a/libs/honeysuckle/src/hs_throw_error.c +++ /dev/null @@ -1,12 +0,0 @@ -#include <stdlib.h> - -#include "honeysuckle.h" - -void hs_throw_error(lua_State *L, const char *format_string, ...) -{ - va_list args; - va_start(args, format_string); - hs_vpushstring(L, format_string, args); - va_end(args); - lua_error(L); -} diff --git a/libs/honeysuckle/src/hs_traceback.c b/libs/honeysuckle/src/hs_traceback.c deleted file mode 100644 index 1830721..0000000 --- a/libs/honeysuckle/src/hs_traceback.c +++ /dev/null @@ -1,37 +0,0 @@ -#include "honeysuckle.h" - -int hs_traceback(lua_State *L) -{ - if (!lua_isstring(L, 1)) - /* 'message' is not a string, keep intact */ - return 1; - - lua_getglobal(L, "debug"); - if (!lua_istable(L, -1)) { - lua_pop(L, 1); - return 1; - } - - lua_getfield(L, -1, "traceback"); - if (!lua_isfunction(L, -1)) { - lua_pop(L, 2); - return 1; - } - - lua_pushvalue(L, 1); - lua_pushinteger(L, 2); - lua_call(L, 2, 1); - return 1; -} - - -int hs_call(lua_State *L, int nargs, int nret) -{ - int traceback_pos = lua_gettop(L) - nargs; - lua_pushcfunction(L, hs_traceback); - lua_insert(L, traceback_pos); - - int result = lua_pcall(L, nargs, nret, traceback_pos); - lua_remove(L, traceback_pos); - return result; -} diff --git a/libs/honeysuckle/src/hs_type_to_string.c b/libs/honeysuckle/src/hs_type_to_string.c deleted file mode 100644 index d0a580c..0000000 --- a/libs/honeysuckle/src/hs_type_to_string.c +++ /dev/null @@ -1,31 +0,0 @@ -#include "honeysuckle.h" - -const char * hs_type_to_string(hs_type type) -{ - switch(type) { - case HS_BOOL: - return "boolean"; - case HS_INT: - return "integer"; - case HS_NUM: - return "number"; - case HS_STR: - return "string"; - case HS_TBL: - return "table"; - case HS_FUNC: - return "function"; - case HS_CFUNC: - return "C function"; - case HS_USER: - return "userdata"; - case HS_LIGHT: - return "light userdata"; - case HS_NIL: - return "nil"; - case HS_ANY: - return "any"; - default: - return "(unknown)"; - } -} diff --git a/libs/honeysuckle/src/tests/colors.h b/libs/honeysuckle/src/tests/colors.h deleted file mode 100644 index 21451de..0000000 --- a/libs/honeysuckle/src/tests/colors.h +++ /dev/null @@ -1,22 +0,0 @@ -#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/libs/honeysuckle/src/tests/hs_create_table_tests.c b/libs/honeysuckle/src/tests/hs_create_table_tests.c deleted file mode 100644 index 1adc947..0000000 --- a/libs/honeysuckle/src/tests/hs_create_table_tests.c +++ /dev/null @@ -1,2239 +0,0 @@ -#include "hs_tests.h" - -static int testfunc1(lua_State *L) { return 0; } -static int testfunc2(lua_State *L) { return 0; } - -static void print_stack(lua_State *L) -{ - printf("stack: %d [", lua_gettop(L)); - for (int i=0; i<lua_gettop(L); i++) { - printf(" %s, ", lua_typename(L, lua_type(L, i+1))); - } - printf("]\n"); -} - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * tests for hs_create_table - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -TEST(table_correct_index) -{ - int top_old = lua_gettop(L); - int index = hs_create_table(L); - mu_assert("the stack is unchanged!", lua_gettop(L) != top_old); - mu_assert("returned incorrect index!", index == lua_gettop(L)); - return 0; -} - -#define load_key(index, value, pushf) do { \ - pushf(L, value); lua_gettable(L, index); \ - mu_assert("value at key '" #value "' is nil!", \ - !lua_isnil(L, -1)); \ - } while(0) - -#define loadkey_bool(index, value) \ - load_key(index, value, lua_pushboolean) -#define loadkey_int(index, value) \ - load_key(index, value, lua_pushinteger) -#define loadkey_num(index, value) \ - load_key(index, value, lua_pushnumber) -#define loadkey_str(index, value) \ - lua_getfield(L, index, value) -#define loadkey_tbl(index, value) do { \ - lua_pushvalue(L, value); lua_gettable(L, index); \ - mu_assert("value at table (index '" #value "') is nil!", \ - !lua_isnil(L, -1)); \ - } while(0) -#define loadkey_func(index, value) do { \ - lua_pushvalue(L, value); lua_gettable(L, index); \ - mu_assert("value at function (index '" #value "') is nil!", \ - !lua_isnil(L, -1)); \ - } while(0) -#define loadkey_cfunc(index, value) \ - load_key(index, value, lua_pushcfunction) -#define loadkey_user(index, value) do { \ - lua_pushvalue(L, value); lua_gettable(L, index); \ - mu_assert("value at userdata (index '" #value "') is nil!", \ - !lua_isnil(L, -1)); \ - } while(0) -#define loadkey_light(index, value) \ - load_key(index, value, lua_pushlightuserdata) - -#define check_value(is_type, typestring, type, conversion, comparison) \ - do { \ - mu_assert("value is not of type " typestring, is_type(L, -1)); \ - type value = conversion(L, -1); lua_pop(L, 1); \ - mu_assert("test " #comparison " failed!", (comparison)); \ - } while(0) - -#define checkval_bool(expected) \ - check_value(lua_isboolean, "boolean", bool, lua_toboolean, value==expected) -#define checkval_int(expected) \ - check_value(lua_isnumber, "integer", lua_Integer, lua_tointeger, value==expected) -#define checkval_num(expected) \ - check_value(lua_isnumber, "number", lua_Number, lua_tonumber, value==expected) -#define checkval_str(expected) \ - check_value(lua_isstring, "string", const char *, lua_tostring, strcmp(value, expected)==0) -#define checkval_tbl(expected) \ - check_value(lua_istable, "table", const void *, lua_topointer, value==lua_topointer(L, expected)) -#define checkval_func(expected) \ - check_value(lua_isfunction, "function", const void *, lua_topointer, value==lua_topointer(L, expected)) -#define checkval_cfunc(expected) \ - check_value(lua_iscfunction, "C function", lua_CFunction, lua_tocfunction, value==expected) -#define checkval_user(expected) \ - check_value(lua_isuserdata, "userdata", void *, lua_touserdata, value==lua_topointer(L, expected)) -#define checkval_light(expected) \ - check_value(lua_islightuserdata, "light userdata", void *, lua_touserdata, value==expected) - -#define store(name) \ - lua_pushvalue(L, -1); \ - int name ## _ref = luaL_ref(L, LUA_REGISTRYINDEX); \ - int name = lua_gettop(L); - -#define load(name) \ - lua_rawgeti(L, LUA_REGISTRYINDEX, name ## _ref); \ - name = lua_gettop(L); - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * boolean keys - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -TEST(create_table_bool_bool) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_bool_bool(true, true), hs_bool_bool(false, true)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_bool(index, true); - checkval_bool(true); - loadkey_bool(index, false); - checkval_bool(true); - return 0; -} - -TEST(create_table_bool_int) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_bool_int(true, 15), hs_bool_int(false, 25)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_bool(index, true); - checkval_int(15); - loadkey_bool(index, false); - checkval_int(25); - return 0; -} - -TEST(create_table_bool_num) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_bool_num(true, 2.718), hs_bool_num(false, 1.618)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_bool(index, true); - checkval_num(2.718); - loadkey_bool(index, false); - checkval_num(1.618); - return 0; -} - -TEST(create_table_bool_str) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_bool_str(true, "hello"), hs_bool_str(false, "world")); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_bool(index, true); - checkval_str("hello"); - loadkey_bool(index, false); - checkval_str("world"); - return 0; -} - -TEST(create_table_bool_tbl) -{ - int oldtop = lua_gettop(L); - - lua_newtable(L); - store(value1); - lua_newtable(L); - store(value2); - - int index = hs_create_table - (L, hs_bool_tbl(true, value1), hs_bool_tbl(false, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(value1); - load(value2); - - loadkey_bool(index, true); - checkval_tbl(value1); - loadkey_bool(index, false); - checkval_tbl(value2); - return 0; -} - -TEST(create_table_bool_func) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('hello')"); - store(value1); - luaL_loadstring(L, "print('hello')"); - store(value2); - - int index = hs_create_table - (L, hs_bool_func(true, value1), hs_bool_func(false, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(value1); - load(value2); - - loadkey_bool(index, true); - checkval_func(value1); - loadkey_bool(index, false); - checkval_func(value2); - return 0; -} - -TEST(create_table_bool_cfunc) -{ - - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_bool_cfunc(true, testfunc1), hs_bool_cfunc(false, testfunc2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_bool(index, true); - checkval_cfunc(testfunc1); - loadkey_bool(index, false); - checkval_cfunc(testfunc2); - return 0; -} - - -TEST(create_table_bool_user) -{ - int oldtop = lua_gettop(L); - - lua_newuserdata(L, sizeof(char)); - store(user1); - lua_newuserdata(L, sizeof(char)); - store(user2); - - int index = hs_create_table - (L, hs_bool_user(true, user1), hs_bool_user(false, user2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(user1); - load(user2); - - loadkey_bool(index, true); - checkval_user(user1); - loadkey_bool(index, false); - checkval_user(user2); - return 0; -} - -TEST(create_table_bool_light) -{ - int a1 = 5; - void *light1 = (void *) &a1; - int a2 = 6; - void *light2 = (void *) &a2; - - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_bool_light(true, light1), hs_bool_light(false, light2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_bool(index, true); - checkval_light(light1); - loadkey_bool(index, false); - checkval_light(light2); - return 0; -} - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * integer keys - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -TEST(create_table_int_bool) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_int_bool(15, true), hs_int_bool(25, true)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_int(index, 15); - checkval_bool(true); - loadkey_int(index, 25); - checkval_bool(true); - return 0; -} - -TEST(create_table_int_int) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_int_int(15, 15), hs_int_int(25, 25)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_int(index, 15); - checkval_int(15); - loadkey_int(index, 25); - checkval_int(25); - return 0; -} - -TEST(create_table_int_num) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_int_num(15, 2.718), hs_int_num(25, 1.618)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_int(index, 15); - checkval_num(2.718); - loadkey_int(index, 25); - checkval_num(1.618); - return 0; -} - -TEST(create_table_int_str) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_int_str(15, "hello"), hs_int_str(25, "world")); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_int(index, 15); - checkval_str("hello"); - loadkey_int(index, 25); - checkval_str("world"); - return 0; -} - -TEST(create_table_int_tbl) -{ - int oldtop = lua_gettop(L); - - lua_newtable(L); - store(value1); - lua_newtable(L); - store(value2); - - int index = hs_create_table - (L, hs_int_tbl(15, value1), hs_int_tbl(25, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(value1); - load(value2); - - loadkey_int(index, 15); - checkval_tbl(value1); - loadkey_int(index, 25); - checkval_tbl(value2); - return 0; -} - -TEST(create_table_int_func) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('hello')"); - store(value1); - luaL_loadstring(L, "print('hello')"); - store(value2); - - int index = hs_create_table - (L, hs_int_func(15, value1), hs_int_func(25, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(value1); - load(value2); - - loadkey_int(index, 15); - checkval_func(value1); - loadkey_int(index, 25); - checkval_func(value2); - return 0; -} - -TEST(create_table_int_cfunc) -{ - - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_int_cfunc(15, testfunc1), hs_int_cfunc(25, testfunc2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_int(index, 15); - checkval_cfunc(testfunc1); - loadkey_int(index, 25); - checkval_cfunc(testfunc2); - return 0; -} - - -TEST(create_table_int_user) -{ - int oldtop = lua_gettop(L); - - lua_newuserdata(L, sizeof(char)); - store(user1); - lua_newuserdata(L, sizeof(char)); - store(user2); - - int index = hs_create_table - (L, hs_int_user(15, user1), hs_int_user(25, user2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(user1); - load(user2); - - loadkey_int(index, 15); - checkval_user(user1); - loadkey_int(index, 25); - checkval_user(user2); - return 0; -} - -TEST(create_table_int_light) -{ - int a1 = 5; - void *light1 = (void *) &a1; - int a2 = 6; - void *light2 = (void *) &a2; - - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_int_light(15, light1), hs_int_light(25, light2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_int(index, 15); - checkval_light(light1); - loadkey_int(index, 25); - checkval_light(light2); - return 0; -} - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * number keys - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -TEST(create_table_num_bool) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_num_bool(43.3f, true), hs_num_bool(23.56f, false)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_num(index, 43.3f); - checkval_bool(true); - loadkey_num(index, 23.56f); - checkval_bool(false); - return 0; -} - -TEST(create_table_num_int) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_num_int(43.3f, 15), hs_num_int(23.56f, 25)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_num(index, 43.3f); - checkval_int(15); - loadkey_num(index, 23.56f); - checkval_int(25); - return 0; -} - -TEST(create_table_num_num) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_num_num(43.3f, 2.718), hs_num_num(23.56f, 1.618)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_num(index, 43.3f); - checkval_num(2.718); - loadkey_num(index, 23.56f); - checkval_num(1.618); - return 0; -} - -TEST(create_table_num_str) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_num_str(43.3f, "hello"), hs_num_str(23.56f, "world")); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_num(index, 43.3f); - checkval_str("hello"); - loadkey_num(index, 23.56f); - checkval_str("world"); - return 0; -} - -TEST(create_table_num_tbl) -{ - int oldtop = lua_gettop(L); - - lua_newtable(L); - store(value1); - lua_newtable(L); - store(value2); - - int index = hs_create_table - (L, hs_num_tbl(43.3f, value1), hs_num_tbl(23.56f, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(value1); - load(value2); - - loadkey_num(index, 43.3f); - checkval_tbl(value1); - loadkey_num(index, 23.56f); - checkval_tbl(value2); - return 0; -} - -TEST(create_table_num_func) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('hello')"); - store(value1); - luaL_loadstring(L, "print('hello')"); - store(value2); - - int index = hs_create_table - (L, hs_num_func(43.3f, value1), hs_num_func(23.56f, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(value1); - load(value2); - - loadkey_num(index, 43.3f); - checkval_func(value1); - loadkey_num(index, 23.56f); - checkval_func(value2); - return 0; -} - -TEST(create_table_num_cfunc) -{ - - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_num_cfunc(43.3f, testfunc1), hs_num_cfunc(23.56f, testfunc2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_num(index, 43.3f); - checkval_cfunc(testfunc1); - loadkey_num(index, 23.56f); - checkval_cfunc(testfunc2); - return 0; -} - - -TEST(create_table_num_user) -{ - int oldtop = lua_gettop(L); - - lua_newuserdata(L, sizeof(char)); - store(user1); - lua_newuserdata(L, sizeof(char)); - store(user2); - - int index = hs_create_table - (L, hs_num_user(43.3f, user1), hs_num_user(23.56f, user2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(user1); - load(user2); - - loadkey_num(index, 43.3f); - checkval_user(user1); - loadkey_num(index, 23.56f); - checkval_user(user2); - return 0; -} - -TEST(create_table_num_light) -{ - int a1 = 5; - void *light1 = (void *) &a1; - int a2 = 6; - void *light2 = (void *) &a2; - - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_num_light(43.3f, light1), hs_num_light(23.56f, light2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_num(index, 43.3f); - checkval_light(light1); - loadkey_num(index, 23.56f); - checkval_light(light2); - return 0; -} - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * string keys - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -TEST(create_table_str_bool) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_str_bool("c:", true), hs_str_bool(":)", true)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_str(index, "c:"); - checkval_bool(true); - loadkey_str(index, ":)"); - checkval_bool(true); - return 0; -} - -TEST(create_table_str_int) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_str_int("c:", 15), hs_str_int(":)", 25)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_str(index, "c:"); - checkval_int(15); - loadkey_str(index, ":)"); - checkval_int(25); - return 0; -} - -TEST(create_table_str_num) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_str_num("c:", 2.718), hs_str_num(":)", 1.618)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_str(index, "c:"); - checkval_num(2.718); - loadkey_str(index, ":)"); - checkval_num(1.618); - return 0; -} - -TEST(create_table_str_str) -{ - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_str_str("c:", "hello"), hs_str_str(":)", "world")); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_str(index, "c:"); - checkval_str("hello"); - loadkey_str(index, ":)"); - checkval_str("world"); - return 0; -} - -TEST(create_table_str_tbl) -{ - int oldtop = lua_gettop(L); - - lua_newtable(L); - store(value1); - lua_newtable(L); - store(value2); - - int index = hs_create_table - (L, hs_str_tbl("c:", value1), hs_str_tbl(":)", value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(value1); - load(value2); - - loadkey_str(index, "c:"); - checkval_tbl(value1); - loadkey_str(index, ":)"); - checkval_tbl(value2); - return 0; -} - -TEST(create_table_str_func) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('hello')"); - store(value1); - luaL_loadstring(L, "print('hello')"); - store(value2); - - int index = hs_create_table - (L, hs_str_func("c:", value1), hs_str_func(":)", value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(value1); - load(value2); - - loadkey_str(index, "c:"); - checkval_func(value1); - loadkey_str(index, ":)"); - checkval_func(value2); - return 0; -} - -TEST(create_table_str_cfunc) -{ - - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_str_cfunc("c:", testfunc1), hs_str_cfunc(":)", testfunc2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_str(index, "c:"); - checkval_cfunc(testfunc1); - loadkey_str(index, ":)"); - checkval_cfunc(testfunc2); - return 0; -} - - -TEST(create_table_str_user) -{ - int oldtop = lua_gettop(L); - - lua_newuserdata(L, sizeof(char)); - store(user1); - lua_newuserdata(L, sizeof(char)); - store(user2); - - int index = hs_create_table - (L, hs_str_user("c:", user1), hs_str_user(":)", user2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(user1); - load(user2); - - loadkey_str(index, "c:"); - checkval_user(user1); - loadkey_str(index, ":)"); - checkval_user(user2); - return 0; -} - -TEST(create_table_str_light) -{ - int a1 = 5; - void *light1 = (void *) &a1; - int a2 = 6; - void *light2 = (void *) &a2; - - int oldtop = lua_gettop(L); - int index = hs_create_table - (L, hs_str_light("c:", light1), hs_str_light(":)", light2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_str(index, "c:"); - checkval_light(light1); - loadkey_str(index, ":)"); - checkval_light(light2); - return 0; -} - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * table keys - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -TEST(create_table_tbl_bool) -{ - int oldtop = lua_gettop(L); - - lua_newtable(L); - store(tbl1); - lua_newtable(L); - store(tbl2); - - int index = hs_create_table - (L, hs_tbl_bool(tbl1, true), hs_tbl_bool(tbl2, false)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(tbl1); - load(tbl2); - - loadkey_tbl(index, tbl1); - checkval_bool(true); - loadkey_tbl(index, tbl2); - checkval_bool(false); - return 0; -} - -TEST(create_table_tbl_int) -{ - int oldtop = lua_gettop(L); - - lua_newtable(L); - store(tbl1); - lua_newtable(L); - store(tbl2); - - int index = hs_create_table - (L, hs_tbl_int(tbl1, 15), hs_tbl_int(tbl2, 25)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(tbl1); - load(tbl2); - - loadkey_tbl(index, tbl1); - checkval_int(15); - loadkey_tbl(index, tbl2); - checkval_int(25); - return 0; -} - -TEST(create_table_tbl_num) -{ - int oldtop = lua_gettop(L); - - lua_newtable(L); - store(tbl1); - lua_newtable(L); - store(tbl2); - - int index = hs_create_table - (L, hs_tbl_num(tbl1, 2.718), hs_tbl_num(tbl2, 1.618)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(tbl1); - load(tbl2); - - loadkey_tbl(index, tbl1); - checkval_num(2.718); - loadkey_tbl(index, tbl2); - checkval_num(1.618); - return 0; -} - -TEST(create_table_tbl_str) -{ - int oldtop = lua_gettop(L); - - lua_newtable(L); - store(tbl1); - lua_newtable(L); - store(tbl2); - - int index = hs_create_table - (L, hs_tbl_str(tbl1, "hello"), hs_tbl_str(tbl2, "world")); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(tbl1); - load(tbl2); - - loadkey_tbl(index, tbl1); - checkval_str("hello"); - loadkey_tbl(index, tbl2); - checkval_str("world"); - return 0; -} - -TEST(create_table_tbl_tbl) -{ - int oldtop = lua_gettop(L); - - lua_newtable(L); - store(tbl1); - lua_newtable(L); - store(tbl2); - - - lua_newtable(L); - store(value1); - lua_newtable(L); - store(value2); - - int index = hs_create_table - (L, hs_tbl_tbl(tbl1, value1), hs_tbl_tbl(tbl2, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(tbl1); - load(tbl2); - - load(value1); - load(value2); - - loadkey_tbl(index, tbl1); - checkval_tbl(value1); - loadkey_tbl(index, tbl2); - checkval_tbl(value2); - return 0; -} - -TEST(create_table_tbl_func) -{ - int oldtop = lua_gettop(L); - - lua_newtable(L); - store(tbl1); - lua_newtable(L); - store(tbl2); - - - luaL_loadstring(L, "print('hello')"); - store(value1); - luaL_loadstring(L, "print('hello')"); - store(value2); - - int index = hs_create_table - (L, hs_tbl_func(tbl1, value1), hs_tbl_func(tbl2, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(tbl1); - load(tbl2); - - load(value1); - load(value2); - - loadkey_tbl(index, tbl1); - checkval_func(value1); - loadkey_tbl(index, tbl2); - checkval_func(value2); - return 0; -} - -TEST(create_table_tbl_cfunc) -{ - - int oldtop = lua_gettop(L); - - lua_newtable(L); - store(tbl1); - lua_newtable(L); - store(tbl2); - - int index = hs_create_table - (L, hs_tbl_cfunc(tbl1, testfunc1), hs_tbl_cfunc(tbl2, testfunc2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(tbl1); - load(tbl2); - - loadkey_tbl(index, tbl1); - checkval_cfunc(testfunc1); - loadkey_tbl(index, tbl2); - checkval_cfunc(testfunc2); - return 0; -} - - -TEST(create_table_tbl_user) -{ - int oldtop = lua_gettop(L); - - lua_newtable(L); - store(tbl1); - lua_newtable(L); - store(tbl2); - - - lua_newuserdata(L, sizeof(char)); - store(user1); - lua_newuserdata(L, sizeof(char)); - store(user2); - - int index = hs_create_table - (L, hs_tbl_user(tbl1, user1), hs_tbl_user(tbl2, user2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(tbl1); - load(tbl2); - - load(user1); - load(user2); - - loadkey_tbl(index, tbl1); - checkval_user(user1); - loadkey_tbl(index, tbl2); - checkval_user(user2); - return 0; -} - -TEST(create_table_tbl_light) -{ - int a1 = 5; - void *light1 = (void *) &a1; - int a2 = 6; - void *light2 = (void *) &a2; - - int oldtop = lua_gettop(L); - - lua_newtable(L); - store(tbl1); - lua_newtable(L); - store(tbl2); - - int index = hs_create_table - (L, hs_tbl_light(tbl1, light1), hs_tbl_light(tbl2, light2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(tbl1); - load(tbl2); - - loadkey_tbl(index, tbl1); - checkval_light(light1); - loadkey_tbl(index, tbl2); - checkval_light(light2); - return 0; -} - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * function keys - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -TEST(create_table_func_bool) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(func1); - luaL_loadstring(L, "print('')"); - store(func2); - - int index = hs_create_table - (L, hs_func_bool(func1, true), hs_func_bool(func2, false)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(func1); - load(func2); - - loadkey_func(index, func1); - checkval_bool(true); - loadkey_func(index, func2); - checkval_bool(false); - return 0; -} - -TEST(create_table_func_int) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(func1); - luaL_loadstring(L, "print('')"); - store(func2); - - int index = hs_create_table - (L, hs_func_int(func1, 15), hs_func_int(func2, 25)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(func1); - load(func2); - - loadkey_func(index, func1); - checkval_int(15); - loadkey_func(index, func2); - checkval_int(25); - return 0; -} - -TEST(create_table_func_num) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(func1); - luaL_loadstring(L, "print('')"); - store(func2); - - int index = hs_create_table - (L, hs_func_num(func1, 2.718), hs_func_num(func2, 1.618)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(func1); - load(func2); - - loadkey_func(index, func1); - checkval_num(2.718); - loadkey_func(index, func2); - checkval_num(1.618); - return 0; -} - -TEST(create_table_func_str) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(func1); - luaL_loadstring(L, "print('')"); - store(func2); - - int index = hs_create_table - (L, hs_func_str(func1, "hello"), hs_func_str(func2, "world")); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(func1); - load(func2); - - loadkey_func(index, func1); - checkval_str("hello"); - loadkey_func(index, func2); - checkval_str("world"); - return 0; -} - -TEST(create_table_func_tbl) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(func1); - luaL_loadstring(L, "print('')"); - store(func2); - - - lua_newtable(L); - store(value1); - lua_newtable(L); - store(value2); - - int index = hs_create_table - (L, hs_func_tbl(func1, value1), hs_func_tbl(func2, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(func1); - load(func2); - - load(value1); - load(value2); - - loadkey_func(index, func1); - checkval_tbl(value1); - loadkey_func(index, func2); - checkval_tbl(value2); - return 0; -} - -TEST(create_table_func_func) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(func1); - luaL_loadstring(L, "print('')"); - store(func2); - - - luaL_loadstring(L, "print('hello')"); - store(value1); - luaL_loadstring(L, "print('hello')"); - store(value2); - - int index = hs_create_table - (L, hs_func_func(func1, value1), hs_func_func(func2, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(func1); - load(func2); - - load(value1); - load(value2); - - loadkey_func(index, func1); - checkval_func(value1); - loadkey_func(index, func2); - checkval_func(value2); - return 0; -} - -TEST(create_table_func_cfunc) -{ - - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(func1); - luaL_loadstring(L, "print('')"); - store(func2); - - int index = hs_create_table - (L, hs_func_cfunc(func1, testfunc1), hs_func_cfunc(func2, testfunc2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(func1); - load(func2); - - loadkey_func(index, func1); - checkval_cfunc(testfunc1); - loadkey_func(index, func2); - checkval_cfunc(testfunc2); - return 0; -} - - -TEST(create_table_func_user) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(func1); - luaL_loadstring(L, "print('')"); - store(func2); - - - lua_newuserdata(L, sizeof(char)); - store(user1); - lua_newuserdata(L, sizeof(char)); - store(user2); - - int index = hs_create_table - (L, hs_func_user(func1, user1), hs_func_user(func2, user2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(func1); - load(func2); - - load(user1); - load(user2); - - loadkey_func(index, func1); - checkval_user(user1); - loadkey_func(index, func2); - checkval_user(user2); - return 0; -} - -TEST(create_table_func_light) -{ - int a1 = 5; - void *light1 = (void *) &a1; - int a2 = 6; - void *light2 = (void *) &a2; - - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(func1); - luaL_loadstring(L, "print('')"); - store(func2); - - int index = hs_create_table - (L, hs_func_light(func1, light1), hs_func_light(func2, light2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(func1); - load(func2); - - loadkey_func(index, func1); - checkval_light(light1); - loadkey_func(index, func2); - checkval_light(light2); - return 0; -} - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * C function keys - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -/* todo */ - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * userdata keys - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -TEST(create_table_user_bool) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(user1); - luaL_loadstring(L, "print('')"); - store(user2); - - int index = hs_create_table - (L, hs_user_bool(user1, true), hs_user_bool(user2, false)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(user1); - load(user2); - - loadkey_user(index, user1); - checkval_bool(true); - loadkey_user(index, user2); - checkval_bool(false); - return 0; -} - -TEST(create_table_user_int) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(user1); - luaL_loadstring(L, "print('')"); - store(user2); - - int index = hs_create_table - (L, hs_user_int(user1, 15), hs_user_int(user2, 25)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(user1); - load(user2); - - loadkey_user(index, user1); - checkval_int(15); - loadkey_user(index, user2); - checkval_int(25); - return 0; -} - -TEST(create_table_user_num) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(user1); - luaL_loadstring(L, "print('')"); - store(user2); - - int index = hs_create_table - (L, hs_user_num(user1, 2.718), hs_user_num(user2, 1.618)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(user1); - load(user2); - - loadkey_user(index, user1); - checkval_num(2.718); - loadkey_user(index, user2); - checkval_num(1.618); - return 0; -} - -TEST(create_table_user_str) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(user1); - luaL_loadstring(L, "print('')"); - store(user2); - - int index = hs_create_table - (L, hs_user_str(user1, "hello"), hs_user_str(user2, "world")); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(user1); - load(user2); - - loadkey_user(index, user1); - checkval_str("hello"); - loadkey_user(index, user2); - checkval_str("world"); - return 0; -} - -TEST(create_table_user_tbl) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(user1); - luaL_loadstring(L, "print('')"); - store(user2); - - - lua_newtable(L); - store(value1); - lua_newtable(L); - store(value2); - - int index = hs_create_table - (L, hs_user_tbl(user1, value1), hs_user_tbl(user2, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(user1); - load(user2); - - load(value1); - load(value2); - - loadkey_user(index, user1); - checkval_tbl(value1); - loadkey_user(index, user2); - checkval_tbl(value2); - return 0; -} - -TEST(create_table_user_func) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(user1); - luaL_loadstring(L, "print('')"); - store(user2); - - - luaL_loadstring(L, "print('hello')"); - store(value1); - luaL_loadstring(L, "print('hello')"); - store(value2); - - int index = hs_create_table - (L, hs_user_func(user1, value1), hs_user_func(user2, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(user1); - load(user2); - - load(value1); - load(value2); - - loadkey_user(index, user1); - checkval_func(value1); - loadkey_user(index, user2); - checkval_func(value2); - return 0; -} - -TEST(create_table_user_cfunc) -{ - - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(user1); - luaL_loadstring(L, "print('')"); - store(user2); - - int index = hs_create_table - (L, hs_user_cfunc(user1, testfunc1), hs_user_cfunc(user2, testfunc2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(user1); - load(user2); - - loadkey_user(index, user1); - checkval_cfunc(testfunc1); - loadkey_user(index, user2); - checkval_cfunc(testfunc2); - return 0; -} - - -TEST(create_table_user_user) -{ - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(user1); - luaL_loadstring(L, "print('')"); - store(user2); - - - lua_newuserdata(L, sizeof(char)); - store(value1); - lua_newuserdata(L, sizeof(char)); - store(value2); - - int index = hs_create_table - (L, hs_user_user(user1, value1), hs_user_user(user2, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(user1); - load(user2); - - load(value1); - load(value2); - - loadkey_user(index, user1); - checkval_user(value1); - loadkey_user(index, user2); - checkval_user(value2); - return 0; -} - -TEST(create_table_user_light) -{ - int a1 = 5; - void *light1 = (void *) &a1; - int a2 = 6; - void *light2 = (void *) &a2; - - int oldtop = lua_gettop(L); - - luaL_loadstring(L, "print('')"); - store(user1); - luaL_loadstring(L, "print('')"); - store(user2); - - int index = hs_create_table - (L, hs_user_light(user1, light1), hs_user_light(user2, light2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(user1); - load(user2); - - loadkey_user(index, user1); - checkval_light(light1); - loadkey_user(index, user2); - checkval_light(light2); - return 0; -} - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * light userdata keys - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -TEST(create_table_light_bool) -{ - int oldtop = lua_gettop(L); - - int l1 = 5; - int l2 = 6; - void *light1 = (void *) &l1; - void *light2 = (void *) &l2; - - int index = hs_create_table - (L, hs_light_bool(light1, true), hs_light_bool(light2, true)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_light(index, light1); - checkval_bool(true); - loadkey_light(index, light2); - checkval_bool(true); - return 0; -} - -TEST(create_table_light_int) -{ - int oldtop = lua_gettop(L); - - int l1 = 5; - int l2 = 6; - void *light1 = (void *) &l1; - void *light2 = (void *) &l2; - - int index = hs_create_table - (L, hs_light_int(light1, 15), hs_light_int(light2, 25)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_light(index, light1); - checkval_int(15); - loadkey_light(index, light2); - checkval_int(25); - return 0; -} - -TEST(create_table_light_num) -{ - int oldtop = lua_gettop(L); - - int l1 = 5; - int l2 = 6; - void *light1 = (void *) &l1; - void *light2 = (void *) &l2; - - int index = hs_create_table - (L, hs_light_num(light1, 2.718), hs_light_num(light2, 1.618)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_light(index, light1); - checkval_num(2.718); - loadkey_light(index, light2); - checkval_num(1.618); - return 0; -} - -TEST(create_table_light_str) -{ - int oldtop = lua_gettop(L); - - int l1 = 5; - int l2 = 6; - void *light1 = (void *) &l1; - void *light2 = (void *) &l2; - - int index = hs_create_table - (L, hs_light_str(light1, "hello"), hs_light_str(light2, "world")); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_light(index, light1); - checkval_str("hello"); - loadkey_light(index, light2); - checkval_str("world"); - return 0; -} - -TEST(create_table_light_tbl) -{ - int oldtop = lua_gettop(L); - - int l1 = 5; - int l2 = 6; - void *light1 = (void *) &l1; - void *light2 = (void *) &l2; - - lua_newtable(L); - store(value1); - lua_newtable(L); - store(value2); - - int index = hs_create_table - (L, hs_light_tbl(light1, value1), hs_light_tbl(light2, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(value1); - load(value2); - - loadkey_light(index, light1); - checkval_tbl(value1); - loadkey_light(index, light2); - checkval_tbl(value2); - return 0; -} - -TEST(create_table_light_func) -{ - int oldtop = lua_gettop(L); - - int l1 = 5; - int l2 = 6; - void *light1 = (void *) &l1; - void *light2 = (void *) &l2; - - luaL_loadstring(L, "print('hello')"); - store(value1); - luaL_loadstring(L, "print('hello')"); - store(value2); - - int index = hs_create_table - (L, hs_light_func(light1, value1), hs_light_func(light2, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(value1); - load(value2); - - loadkey_light(index, light1); - checkval_func(value1); - loadkey_light(index, light2); - checkval_func(value2); - return 0; -} - -TEST(create_table_light_cfunc) -{ - - int oldtop = lua_gettop(L); - - int l1 = 5; - int l2 = 6; - void *light1 = (void *) &l1; - void *light2 = (void *) &l2; - - int index = hs_create_table - (L, hs_light_cfunc(light1, testfunc1), hs_light_cfunc(light2, testfunc2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_light(index, light1); - checkval_cfunc(testfunc1); - loadkey_light(index, light2); - checkval_cfunc(testfunc2); - return 0; -} - - -TEST(create_table_light_user) -{ - int oldtop = lua_gettop(L); - - int l1 = 5; - int l2 = 6; - void *light1 = (void *) &l1; - void *light2 = (void *) &l2; - - lua_newuserdata(L, sizeof(char)); - store(user1); - lua_newuserdata(L, sizeof(char)); - store(user2); - - int index = hs_create_table - (L, hs_light_user(light1, user1), hs_light_user(light2, user2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - load(user1); - load(user2); - - loadkey_light(index, light1); - checkval_user(user1); - loadkey_light(index, light2); - checkval_user(user2); - return 0; -} - -TEST(create_table_light_light) -{ - int oldtop = lua_gettop(L); - - int l1 = 5; - int l2 = 6; - void *light1 = (void *) &l1; - void *light2 = (void *) &l2; - - int a1 = 5; - void *value1 = (void *) &a1; - int a2 = 6; - void *value2 = (void *) &a2; - - int index = hs_create_table - (L, hs_light_light(light1, value1), hs_light_light(light2, value2)); - mu_assert_equal(oldtop + 1, lua_gettop(L)); - mu_assert_equal(index, lua_gettop(L)); - mu_assert_equal(lua_type(L, index), LUA_TTABLE); - - loadkey_light(index, light1); - checkval_light(value1); - loadkey_light(index, light2); - checkval_light(value2); - return 0; -} - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * nested tables - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -TEST(create_nested_table) -{ - int index = hs_create_table - (L, - hs_str_tbl("sub1", hs_create_table(L, hs_str_int("five", 5))), - hs_str_tbl("sub2", hs_create_table(L, hs_str_int("six", 6))) - ); - - mu_assert_equal(lua_gettop(L), 1); - - - lua_getfield(L, index, "sub1"); - mu_assert("'sub1' is not a table!", lua_istable(L, -1)); - lua_getfield(L, -1, "five"); - mu_assert("'sub1.five' is not a number!", lua_isnumber(L, -1)); - mu_assert_equal(lua_tointeger(L, -1), 5); - - lua_pop(L, 2); - - lua_getfield(L, index, "sub2"); - mu_assert("'sub2' is not a table!", lua_istable(L, -1)); - lua_getfield(L, -1, "six"); - mu_assert("'sub2.six' is not a number!", lua_isnumber(L, -1)); - mu_assert_equal(lua_tointeger(L, -1), 6); - - return 0; -} - -TEST(create_tree) -{ - /* - * { 0={ 0={ 0=0, 1=1}, - * 1={ 0=0, 1=1}, - * }, - * 1={ 0={ 0=0, 1=1}, - * 1={ 0=0, 1=1}, - * }, - * } - */ - int index = hs_create_table - (L, - hs_int_tbl(0, - hs_create_table - (L, - hs_int_tbl(0, - hs_create_table - (L, - hs_int_int(0, 0), - hs_int_int(1, 1) - )), - hs_int_tbl(1, - hs_create_table - (L, - hs_int_int(0, 0), - hs_int_int(1, 1) - )), - )), - hs_int_tbl(1, - hs_create_table - (L, - hs_int_tbl(0, - hs_create_table - (L, - hs_int_int(0, 0), - hs_int_int(1, 1) - )), - hs_int_tbl(1, - hs_create_table - (L, - hs_int_int(0, 0), - hs_int_int(1, 1) - )), - )) - ); - - mu_assert_equal(lua_gettop(L), 1); - - lua_rawgeti(L, index, 0); - mu_assert("tbl[0] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 0); - mu_assert("tbl[0][0] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 0); - mu_assert("tbl[0][0][0] is not a number!", lua_isnumber(L, -1)); - lua_pop(L, 3); - - lua_rawgeti(L, index, 0); - mu_assert("tbl[0] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 0); - mu_assert("tbl[0][0] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 1); - mu_assert("tbl[0][0][1] is not a number!", lua_isnumber(L, -1)); - lua_pop(L, 3); - - lua_rawgeti(L, index, 0); - mu_assert("tbl[0] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 1); - mu_assert("tbl[0][1] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 0); - mu_assert("tbl[0][1][0] is not a number!", lua_isnumber(L, -1)); - lua_pop(L, 3); - - lua_rawgeti(L, index, 0); - mu_assert("tbl[0] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 1); - mu_assert("tbl[0][1] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 1); - mu_assert("tbl[0][1][1] is not a number!", lua_isnumber(L, -1)); - lua_pop(L, 3); - - lua_rawgeti(L, index, 1); - mu_assert("tbl[1] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 0); - mu_assert("tbl[1][0] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 0); - mu_assert("tbl[1][0][0] is not a number!", lua_isnumber(L, -1)); - lua_pop(L, 3); - - lua_rawgeti(L, index, 1); - mu_assert("tbl[1] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 0); - mu_assert("tbl[1][0] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 1); - mu_assert("tbl[1][0][1] is not a number!", lua_isnumber(L, -1)); - lua_pop(L, 3); - - lua_rawgeti(L, index, 1); - mu_assert("tbl[1] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 1); - mu_assert("tbl[1][1] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 0); - mu_assert("tbl[1][1][0] is not a number!", lua_isnumber(L, -1)); - lua_pop(L, 3); - - lua_rawgeti(L, index, 1); - mu_assert("tbl[1] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 1); - mu_assert("tbl[1][1] is not a table!", lua_istable(L, -1)); - lua_rawgeti(L, -1, 1); - mu_assert("tbl[1][1][1] is not a number!", lua_isnumber(L, -1)); - lua_pop(L, 3); - - 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); - - /* boolean keys */ - mu_run_test("create table with boolean keys and boolean values", - create_table_bool_bool); - mu_run_test("create table with boolean keys and integer values", \ - create_table_bool_int); - mu_run_test("create table with boolean keys and number values", \ - create_table_bool_num); - mu_run_test("create table with boolean keys and string values", \ - create_table_bool_str); - mu_run_test("create table with boolean keys and table values", \ - create_table_bool_tbl); - mu_run_test("create table with boolean keys and function values", \ - create_table_bool_func); - mu_run_test("create table with boolean keys and C function values", \ - create_table_bool_cfunc); - mu_run_test("create table with boolean keys and userdata values", \ - create_table_bool_user); - mu_run_test("create table with boolean keys and light userdata values", \ - create_table_bool_light); - - /* integer keys */ - mu_run_test("create table with integer keys and boolean values", - create_table_int_bool); - mu_run_test("create table with integer keys and integer values", \ - create_table_int_int); - mu_run_test("create table with integer keys and number values", \ - create_table_int_num); - mu_run_test("create table with integer keys and string values", \ - create_table_int_str); - mu_run_test("create table with integer keys and table values", \ - create_table_int_tbl); - mu_run_test("create table with integer keys and function values", \ - create_table_int_func); - mu_run_test("create table with integer keys and C function values", \ - create_table_int_cfunc); - mu_run_test("create table with integer keys and userdata values", \ - create_table_int_user); - mu_run_test("create table with integer keys and light userdata values", \ - create_table_int_light); - - /* number keys */ - mu_run_test("create table with number keys and boolean values", - create_table_num_bool); - mu_run_test("create table with number keys and integer values", \ - create_table_num_int); - mu_run_test("create table with number keys and number values", \ - create_table_num_num); - mu_run_test("create table with number keys and string values", \ - create_table_num_str); - mu_run_test("create table with number keys and table values", \ - create_table_num_tbl); - mu_run_test("create table with number keys and function values", \ - create_table_num_func); - mu_run_test("create table with number keys and C function values", \ - create_table_num_cfunc); - mu_run_test("create table with number keys and userdata values", \ - create_table_num_user); - mu_run_test("create table with number keys and light userdata values", \ - create_table_num_light); - - /* string keys */ - mu_run_test("create table with string keys and boolean values", - create_table_str_bool); - mu_run_test("create table with string keys and integer values", \ - create_table_str_int); - mu_run_test("create table with string keys and number values", \ - create_table_str_num); - mu_run_test("create table with string keys and string values", \ - create_table_str_str); - mu_run_test("create table with string keys and table values", \ - create_table_str_tbl); - mu_run_test("create table with string keys and function values", \ - create_table_str_func); - mu_run_test("create table with string keys and C function values", \ - create_table_str_cfunc); - mu_run_test("create table with string keys and userdata values", \ - create_table_str_user); - mu_run_test("create table with string keys and light userdata values", \ - create_table_str_light); - - /* table keys */ - mu_run_test("create table with table keys and boolean values", - create_table_tbl_bool); - mu_run_test("create table with table keys and integer values", \ - create_table_tbl_int); - mu_run_test("create table with table keys and number values", \ - create_table_tbl_num); - mu_run_test("create table with table keys and string values", \ - create_table_tbl_str); - mu_run_test("create table with table keys and table values", \ - create_table_tbl_tbl); - mu_run_test("create table with table keys and function values", \ - create_table_tbl_func); - mu_run_test("create table with table keys and C function values", \ - create_table_tbl_cfunc); - mu_run_test("create table with table keys and userdata values", \ - create_table_tbl_user); - mu_run_test("create table with table keys and light userdata values", \ - create_table_tbl_light); - - /* function keys */ - mu_run_test("create table with function keys and boolean values", - create_table_func_bool); - mu_run_test("create table with function keys and integer values", \ - create_table_func_int); - mu_run_test("create table with function keys and number values", \ - create_table_func_num); - mu_run_test("create table with function keys and string values", \ - create_table_func_str); - mu_run_test("create table with function keys and table values", \ - create_table_func_tbl); - mu_run_test("create table with function keys and function values", \ - create_table_func_func); - mu_run_test("create table with function keys and C function values", \ - create_table_func_cfunc); - mu_run_test("create table with function keys and userdata values", \ - create_table_func_user); - mu_run_test("create table with function keys and light userdata values", \ - create_table_func_light); - - /* C function keys / - mu_run_test("create table with C function keys and boolean values", - create_table_cfunc_bool); - mu_run_test("create table with C function keys and integer values", \ - create_table_cfunc_int); - mu_run_test("create table with C function keys and number values", \ - create_table_cfunc_num); - mu_run_test("create table with C function keys and string values", \ - create_table_cfunc_str); - mu_run_test("create table with C function keys and table values", \ - create_table_cfunc_tbl); - mu_run_test("create table with C function keys and function values", \ - create_table_cfunc_func); - mu_run_test("create table with C function keys and C function values", \ - create_table_cfunc_cfunc); - mu_run_test("create table with C function keys and userdata values", \ - create_table_cfunc_user); - mu_run_test("create table with C function keys and light userdata values", \ - create_table_cfunc_light); - - /* userdata keys */ - mu_run_test("create table with userdata keys and boolean values", - create_table_user_bool); - mu_run_test("create table with userdata keys and integer values", \ - create_table_user_int); - mu_run_test("create table with userdata keys and number values", \ - create_table_user_num); - mu_run_test("create table with userdata keys and string values", \ - create_table_user_str); - mu_run_test("create table with userdata keys and table values", \ - create_table_user_tbl); - mu_run_test("create table with userdata keys and function values", \ - create_table_user_func); - mu_run_test("create table with userdata keys and C function values", \ - create_table_user_cfunc); - mu_run_test("create table with userdata keys and userdata values", \ - create_table_user_user); - mu_run_test("create table with userdata keys and light userdata values", \ - create_table_user_light); - - /* light userdata keys */ - mu_run_test("create table with light userdata keys and boolean values", - create_table_light_bool); - mu_run_test("create table with light userdata keys and integer values", \ - create_table_light_int); - mu_run_test("create table with light userdata keys and number values", \ - create_table_light_num); - mu_run_test("create table with light userdata keys and string values", \ - create_table_light_str); - mu_run_test("create table with light userdata keys and table values", \ - create_table_light_tbl); - mu_run_test("create table with light userdata keys and function values", \ - create_table_light_func); - mu_run_test("create table with light userdata keys and C function values", \ - create_table_light_cfunc); - mu_run_test("create table with light userdata keys and userdata values", \ - create_table_light_user); - mu_run_test("create table with light userdata keys and light userdata values", \ - create_table_light_light); - - mu_run_test("create nested tables", create_nested_table); - mu_run_test("create tree of nested tables", create_tree); -} diff --git a/libs/honeysuckle/src/tests/hs_parse_args_tests.c b/libs/honeysuckle/src/tests/hs_parse_args_tests.c deleted file mode 100644 index 83178f3..0000000 --- a/libs/honeysuckle/src/tests/hs_parse_args_tests.c +++ /dev/null @@ -1,603 +0,0 @@ -#include "hs_tests.h" - -static int testfunc(lua_State *L) { return 0; } - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * hs_parse_args typechecking tests - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -// typechecking macros -#define PARSE_TYPECHECK_TEST(name, type, macro) \ - int name ## _testfunc(lua_State *L) { \ - type test; hs_parse_args(L, macro(test)); \ - 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); \ - lua_pop(L, 1); - -#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); \ - lua_pop(L, 1); - -#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); \ - lua_pop(L, 1); - -#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); \ - lua_pop(L, 1); - -#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); \ - lua_pop(L, 1); - -#define CHECK_FAIL_FUNC(name) \ - lua_pushcfunction(L, name ## _testfunc); \ - luaL_loadstring(L, "print('hello, world!')"); \ - mu_assert("incorrectly succeeded in parsing function!", \ - lua_pcall(L, 1, 0, 0) != 0); \ - lua_pop(L, 1); - -#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); \ - lua_pop(L, 1); - -#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); \ - lua_pop(L, 1); - -#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); \ - lua_pop(L, 1); - -#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); \ - lua_pop(L, 1); - - -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, lua_Integer, 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); - - // we would check for num, but in lua 5.1 there - // isn't a separate integer type, so it would - // still work - 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); - // we would check for int, but in lua 5.1 there - // isn't a separate integer type, so it would - // still work - - 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); - luaL_loadstring(L, "print('hello, world!')"); - mu_assert("typecheck for function failed!", - lua_pcall(L, 1, 0, 0) == 0); - - lua_pushcfunction(L, parse_func_typecheck_testfunc); - lua_pushvalue(L, -1); - mu_assert("typecheck for C function failed!", - lua_pcall(L, 1, 0, 0) == 0); - - 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); - luaL_loadstring(L, "print('hello, world!')"); - 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)); - mu_assert("failed to properly parse boolean!", b); - return 0; -} - -TEST(parse_int) -{ - lua_pushinteger(L, 420); - lua_Integer i = 0; - hs_parse_args(L, hs_int(i)); - 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)); - 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)); - 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)); - 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)); - mu_assert("failed to properly parse function!", index == correct_index); - return 0; -} - -TEST(parse_cfunc) -{ - lua_pushcfunction(L, testfunc); - lua_CFunction f; - hs_parse_args(L, hs_cfunc(f)); - 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)); - return 0; -} - -TEST(fail_parse_noncfunc) -{ - lua_pushcfunction(L, should_fail); - luaL_loadstring(L, "print('hello, world!')"); - 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)); - 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)); - 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)); - 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)); - 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; - lua_Integer i; - lua_Number 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)); - - 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; lua_Integer i; int table_index; - lua_Number 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)); - - 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() 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); - - 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/libs/honeysuckle/src/tests/hs_parse_overloaded_tests.c b/libs/honeysuckle/src/tests/hs_parse_overloaded_tests.c deleted file mode 100644 index 0680253..0000000 --- a/libs/honeysuckle/src/tests/hs_parse_overloaded_tests.c +++ /dev/null @@ -1,188 +0,0 @@ -#include "hs_tests.h" - -static int testfunc(lua_State *L) { return 0; } - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * tests for hs_parse_overloaded - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -#define PARSE_OVERLOADED \ - bool b; lua_Integer i; int ti, fi, ni; lua_Number f; \ - char *str; lua_CFunction fn; void *user, *light; \ - int choice = hs_parse_overloaded \ - (L, \ - hs_overload(hs_bool(b)), \ - hs_overload(hs_int(i)), \ - hs_overload(hs_num(f)), \ - hs_overload(hs_str(str)), \ - hs_overload(hs_tbl(ti)), \ - hs_overload(hs_func(fi)), \ - hs_overload(hs_cfunc(fn)), \ - hs_overload(hs_user(user)), \ - hs_overload(hs_light(light)), \ - hs_overload(hs_nil(ni))); - -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) -{ - luaL_loadstring(L, "print('hello, world!')"); - 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"); - lua_Integer i; char *str; void *data; - int choice = hs_parse_overloaded - (L, - hs_overload(hs_int(i), hs_str(str)), - hs_overload(hs_int(i), hs_str(str), hs_user(data))); - - 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)); - lua_Integer i; char *str; void *data; - int choice = hs_parse_overloaded - (L, - hs_overload(hs_int(i), hs_str(str)), - hs_overload(hs_int(i), hs_str(str), hs_user(data))); - - 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() -{ - /* the commented tests below require more work to ensure that - * they function correctly. Due to type ambiguities that are - * useful in other contexts, overloads differing only in a - * number/integer, function/cfunction, or userdata/lightuserdata - * in the same position are not readily distinguishable from one - * another. - */ - - 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/libs/honeysuckle/src/tests/hs_process_table_tests.c b/libs/honeysuckle/src/tests/hs_process_table_tests.c deleted file mode 100644 index e8e8c4b..0000000 --- a/libs/honeysuckle/src/tests/hs_process_table_tests.c +++ /dev/null @@ -1,511 +0,0 @@ -#include "hs_tests.h" - -#define process() \ - bool boolean = false; \ - lua_Integer integer = 0; \ - lua_Number number = 0; \ - const char *string = ""; \ - hs_process_table(L, -1, \ - hs_process_bool("boolean", hs_pt_set_boolean, &boolean), \ - hs_process_int("integer", hs_pt_set_integer, &integer), \ - hs_process_num("number", hs_pt_set_number, &number), \ - hs_process_str("string", hs_pt_set_string, &string)); - -#define test_set_boolean() do { mu_assert("failed to set boolean!", boolean == true); } while(0); -#define test_noset_boolean() do { mu_assert("incorrectly set boolean!", boolean == false); } while(0); -#define test_set_integer() do { mu_assert("failed to set integer!", integer == 14); } while(0); -#define test_noset_integer() do { mu_assert("incorrectly set integer!", integer == 0); } while(0); -#define test_set_number() do { mu_assert("failed to set number!", number == 44.66); } while(0); -#define test_noset_number() do { mu_assert("incorrectly set number!", number == 0); } while(0); -#define test_set_string() \ - do { mu_assert("failed to set string!", strcmp(string, "c: c: c:") == 0); } while(0); -#define test_noset_string() \ - do { mu_assert("incorrectly set string!", strcmp(string, "") == 0); } while(0); - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * tests for all 16 possible combinations of one table containing one - * boolean, integer, number, and string key each. - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - - -TEST(process_none) -{ - lua_createtable(L, 0, 0); - - process(); - - test_noset_boolean(); - test_noset_integer(); - test_noset_number(); - test_noset_string(); - - return 0; -} -TEST(process_bool) -{ - lua_createtable(L, 0, 0); - lua_pushboolean(L, true); - lua_setfield(L, -2, "boolean"); - - process(); - - test_set_boolean(); - test_noset_integer(); - test_noset_number(); - test_noset_string(); - - return 0; -} -TEST(process_int) -{ - lua_createtable(L, 0, 0); - - lua_pushinteger(L, 14); - lua_setfield(L, -2, "integer"); - - process(); - - test_noset_boolean(); - test_set_integer(); - test_noset_number(); - test_noset_string(); - - return 0; -} -TEST(process_bool_int) -{ - lua_createtable(L, 0, 0); - lua_pushboolean(L, true); - lua_setfield(L, -2, "boolean"); - - lua_pushinteger(L, 14); - lua_setfield(L, -2, "integer"); - - process(); - - test_set_boolean(); - test_set_integer(); - test_noset_number(); - test_noset_string(); - - return 0; -} -TEST(process_number) -{ - lua_createtable(L, 0, 0); - lua_pushnumber(L, 44.66); - lua_setfield(L, -2, "number"); - - process(); - - test_noset_boolean(); - test_noset_integer(); - test_set_number(); - test_noset_string(); - - return 0; -} -TEST(process_bool_number) -{ - lua_createtable(L, 0, 0); - lua_pushboolean(L, true); - lua_setfield(L, -2, "boolean"); - - lua_pushnumber(L, 44.66); - lua_setfield(L, -2, "number"); - - process(); - - test_set_boolean(); - test_noset_integer(); - test_set_number(); - test_noset_string(); - - return 0; -} -TEST(process_int_number) -{ - lua_createtable(L, 0, 0); - - lua_pushinteger(L, 14); - lua_setfield(L, -2, "integer"); - - lua_pushnumber(L, 44.66); - lua_setfield(L, -2, "number"); - - process(); - - test_noset_boolean(); - test_set_integer(); - test_set_number(); - test_noset_string(); - - return 0; -} -TEST(process_bool_int_number) -{ - lua_createtable(L, 0, 0); - lua_pushboolean(L, true); - lua_setfield(L, -2, "boolean"); - - lua_pushinteger(L, 14); - lua_setfield(L, -2, "integer"); - - lua_pushnumber(L, 44.66); - lua_setfield(L, -2, "number"); - - process(); - - test_set_boolean(); - test_set_integer(); - test_set_number(); - test_noset_string(); - - return 0; -} -TEST(process_string) -{ - lua_createtable(L, 0, 0); - - lua_pushstring(L, "c: c: c:"); - lua_setfield(L, -2, "string"); - - process(); - - test_noset_boolean(); - test_noset_integer(); - test_noset_number(); - test_set_string(); - - return 0; -} -TEST(process_bool_string) -{ - lua_createtable(L, 0, 0); - lua_pushboolean(L, true); - lua_setfield(L, -2, "boolean"); - - lua_pushstring(L, "c: c: c:"); - lua_setfield(L, -2, "string"); - - process(); - - test_set_boolean(); - test_noset_integer(); - test_noset_number(); - test_set_string(); - - return 0; -} -TEST(process_int_string) -{ - lua_createtable(L, 0, 0); - - lua_pushinteger(L, 14); - lua_setfield(L, -2, "integer"); - - lua_pushstring(L, "c: c: c:"); - lua_setfield(L, -2, "string"); - - process(); - - test_noset_boolean(); - test_set_integer(); - test_noset_number(); - test_set_string(); - - return 0; -} -TEST(process_bool_int_string) -{ - lua_createtable(L, 0, 0); - lua_pushboolean(L, true); - lua_setfield(L, -2, "boolean"); - - lua_pushinteger(L, 14); - lua_setfield(L, -2, "integer"); - - lua_pushstring(L, "c: c: c:"); - lua_setfield(L, -2, "string"); - - process(); - - test_set_boolean(); - test_set_integer(); - test_noset_number(); - test_set_string(); - - return 0; -} -TEST(process_number_string) -{ - lua_createtable(L, 0, 0); - lua_pushnumber(L, 44.66); - lua_setfield(L, -2, "number"); - - lua_pushstring(L, "c: c: c:"); - lua_setfield(L, -2, "string"); - - process(); - - test_noset_boolean(); - test_noset_integer(); - test_set_number(); - test_set_string(); - - return 0; -} -TEST(process_bool_number_string) -{ - lua_createtable(L, 0, 0); - lua_pushboolean(L, true); - lua_setfield(L, -2, "boolean"); - - lua_pushnumber(L, 44.66); - lua_setfield(L, -2, "number"); - - lua_pushstring(L, "c: c: c:"); - lua_setfield(L, -2, "string"); - - process(); - - test_set_boolean(); - test_noset_integer(); - test_set_number(); - test_set_string(); - - return 0; -} -TEST(process_int_number_string) -{ - lua_createtable(L, 0, 0); - - lua_pushinteger(L, 14); - lua_setfield(L, -2, "integer"); - - lua_pushnumber(L, 44.66); - lua_setfield(L, -2, "number"); - - lua_pushstring(L, "c: c: c:"); - lua_setfield(L, -2, "string"); - - process(); - - test_noset_boolean(); - test_set_integer(); - test_set_number(); - test_set_string(); - - return 0; -} -TEST(process_all) -{ - lua_createtable(L, 0, 0); - lua_pushboolean(L, true); - lua_setfield(L, -2, "boolean"); - - lua_pushinteger(L, 14); - lua_setfield(L, -2, "integer"); - - lua_pushnumber(L, 44.66); - lua_setfield(L, -2, "number"); - - lua_pushstring(L, "c: c: c:"); - lua_setfield(L, -2, "string"); - - process(); - - test_set_boolean(); - test_set_integer(); - test_set_number(); - test_set_string(); - - return 0; -} - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * tests for four keys of the same type - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -TEST(process_four_bools) -{ - lua_createtable(L, 0, 4); - - lua_pushboolean(L, true); - lua_setfield(L, -2, "b1"); - - lua_pushboolean(L, false); - lua_setfield(L, -2, "b2"); - - lua_pushboolean(L, false); - lua_setfield(L, -2, "b3"); - - lua_pushboolean(L, true); - lua_setfield(L, -2, "b4"); - - bool b1 = false; - bool b2 = true; - bool b3 = true; - bool b4 = false; - - hs_process_table(L, -1, - hs_process_bool("b1", hs_pt_set_boolean, &b1), - hs_process_bool("b2", hs_pt_set_boolean, &b2), - hs_process_bool("b3", hs_pt_set_boolean, &b3), - hs_process_bool("b4", hs_pt_set_boolean, &b4), - ); - - mu_assert("b1 was not correctly set!", b1 == true); - mu_assert("b2 was not correctly set!", b2 == false); - mu_assert("b3 was not correctly set!", b3 == false); - mu_assert("b4 was not correctly set!", b4 == true); - return 0; -} -TEST(process_four_ints) -{ - lua_createtable(L, 0, 4); - - lua_pushinteger(L, 2); - lua_setfield(L, -2, "j1"); - - lua_pushinteger(L, 1); - lua_setfield(L, -2, "j2"); - - lua_pushinteger(L, 3); - lua_setfield(L, -2, "j3"); - - lua_pushinteger(L, 4); - lua_setfield(L, -2, "j4"); - - lua_Integer j1 = 0; - lua_Integer j2 = 0; - lua_Integer j3 = 0; - lua_Integer j4 = 0; - - hs_process_table(L, -1, - hs_process_int("j1", hs_pt_set_integer, &j1), - hs_process_int("j2", hs_pt_set_integer, &j2), - hs_process_int("j3", hs_pt_set_integer, &j3), - hs_process_int("j4", hs_pt_set_integer, &j4)); - - mu_assert("j1 was not correctly set!", j1 == 2); - mu_assert("j2 was not correctly set!", j2 == 1); - mu_assert("j3 was not correctly set!", j3 == 3); - mu_assert("j4 was not correctly set!", j4 == 4); - return 0; -} -TEST(process_four_numbers) -{ - lua_createtable(L, 0, 4); - - lua_pushnumber(L, 3.141); - lua_setfield(L, -2, "n1"); - - lua_pushnumber(L, 2.718); - lua_setfield(L, -2, "n2"); - - lua_pushnumber(L, 1.618); - lua_setfield(L, -2, "n3"); - - lua_pushnumber(L, 4.669); - lua_setfield(L, -2, "n4"); - - lua_Number n1 = 0; - lua_Number n2 = 0; - lua_Number n3 = 0; - lua_Number n4 = 0; - - hs_process_table(L, -1, - hs_process_num("n1", hs_pt_set_number, &n1), - hs_process_num("n2", hs_pt_set_number, &n2), - hs_process_num("n3", hs_pt_set_number, &n3), - hs_process_num("n4", hs_pt_set_number, &n4)); - - mu_assert("n1 was not correctly set!", n1 == 3.141); - mu_assert("n2 was not correctly set!", n2 == 2.718); - mu_assert("n3 was not correctly set!", n3 == 1.618); - mu_assert("n4 was not correctly set!", n4 == 4.669); - return 0; -} -TEST(process_four_strings) -{ - lua_createtable(L, 0, 4); - - lua_pushstring(L, "When meditation is mastered, The mind is unwavering like the Flame of a lamp in a windless place." ); - lua_setfield(L, -2, "s1"); - - lua_pushstring(L, "In the still mind, In the depths of meditation, The Self reveals itself."); - lua_setfield(L, -2, "s2"); - - lua_pushstring(L, "Beholding the Self By means of the Self, An aspirant knows the Joy and peace of complete fulfillment."); - lua_setfield(L, -2, "s3"); - - lua_pushstring(L, "Having attained that Abiding joy beyond the senses, Revealed in the stilled mind, He never swerves from the eternal truth."); - lua_setfield(L, -2, "s4"); - - const char *s1 = ""; - const char *s2 = ""; - const char *s3 = ""; - const char *s4 = ""; - - hs_process_table(L, -1, - hs_process_str("s1", hs_pt_set_string, &s1), - hs_process_str("s2", hs_pt_set_string, &s2), - hs_process_str("s3", hs_pt_set_string, &s3), - hs_process_str("s4", hs_pt_set_string, &s4)); - - mu_assert("s1 was not correctly set!", - strcmp(s1, "When meditation is mastered, The mind is unwavering like the Flame of a lamp in a windless place.") == 0); - mu_assert("s2 was not correctly set!", - strcmp(s2, "In the still mind, In the depths of meditation, The Self reveals itself.") == 0); - mu_assert("s3 was not correctly set!", - strcmp(s3, "Beholding the Self By means of the Self, An aspirant knows the Joy and peace of complete fulfillment.") == 0); - mu_assert("s4 was not correctly set!", - strcmp(s4, "Having attained that Abiding joy beyond the senses, Revealed in the stilled mind, He never swerves from the eternal truth.") == 0); - return 0; -} - - - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * test suite - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -void hs_process_table_tests() -{ - printf("running hs_process_table() tests...\n"); - - mu_run_test("process empty table", process_none); - mu_run_test("process boolean only", process_bool); - mu_run_test("process integer only", process_int); - mu_run_test("process boolean and integer", process_bool_int); - mu_run_test("process number only", process_number); - mu_run_test("process boolean and number", process_bool_number); - mu_run_test("process integer and number", process_int_number); - mu_run_test("process boolean, integer, and number", process_bool_int_number); - - mu_run_test("process string only", process_string); - mu_run_test("process boolean and string", process_bool_string); - mu_run_test("process integer and string", process_int_string); - mu_run_test("process boolean, integer, and string", process_bool_int_string); - mu_run_test("process number and string", process_number_string); - mu_run_test("process boolean, number, and string", process_bool_number_string); - mu_run_test("process integer, number, and string", process_int_number_string); - mu_run_test("process basic types", process_all); - - mu_run_test("process four booleans", process_four_bools); - mu_run_test("process four integers", process_four_ints); - mu_run_test("process four numbers", process_four_numbers); - mu_run_test("process four strings", process_four_strings); -} diff --git a/libs/honeysuckle/src/tests/hs_pushstring_tests.c b/libs/honeysuckle/src/tests/hs_pushstring_tests.c deleted file mode 100644 index e7fa1b4..0000000 --- a/libs/honeysuckle/src/tests/hs_pushstring_tests.c +++ /dev/null @@ -1,52 +0,0 @@ -#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/libs/honeysuckle/src/tests/hs_tests.h b/libs/honeysuckle/src/tests/hs_tests.h deleted file mode 100644 index 15f2cb6..0000000 --- a/libs/honeysuckle/src/tests/hs_tests.h +++ /dev/null @@ -1,63 +0,0 @@ -#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" - -#define STR_IMPL(x) #x -#define STR(x) STR_IMPL(x) - -#define mu_indent " " - -/* minunit testing macros modified from those at - www.jera.com/techinfo/jtns/jtn002.html */ -#define mu_assert(message, test) do { \ - if (!(test)) return message \ - "\n" mu_indent MAGENTA " [" __FILE__ ":" STR(__LINE__) "]" RESET; \ - } while (0) -#define mu_assert_equal(a, b) mu_assert("'" #a "' is not equal to '" #b "'", (a) == (b)) -#define mu_assert_not_equal(a, b) mu_assert("'" #a "' is equal to '" #b "'", (a) != (b)) -#define mu_assert_str_equal(a, b) \ - mu_assert("'" #a "' is not equal to '" #b "'", strcmp((a), (b)) == 0) -#define mu_assert_str_not_equal(a, b) \ - mu_assert("'" #a "' is equal to '" #b "'", strcmp((a), (b)) != 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 mu_indent "test '%s' failed:" RESET " %s\n", name, message); \ - tests_failed++; \ - } \ - } while (0) -#define TEST(name) static const char* name(lua_State *L) -#define mu_run_suite(suite) do { \ - tests_run_old = tests_run; \ - suite(); \ - printf(mu_indent "ran %d tests\n", tests_run - tests_run_old); \ - } while (0) - -extern int tests_run, tests_run_old, 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(); diff --git a/libs/honeysuckle/src/tests/hs_throw_error_tests.c b/libs/honeysuckle/src/tests/hs_throw_error_tests.c deleted file mode 100644 index 7ae683c..0000000 --- a/libs/honeysuckle/src/tests/hs_throw_error_tests.c +++ /dev/null @@ -1,57 +0,0 @@ -#include "hs_tests.h" - -char err_string[32] = ""; - -int set_err_string(lua_State *L) -{ - if (lua_isstring(L, -1)) - strcpy(err_string, lua_tostring(L, -1)); - return 0; -} - - -#define HS_ERROR_TEST(name, error_body, expectation) \ - int name ## _errfunc(lua_State *L) error_body; \ - TEST(name) { \ - lua_pushcfunction(L, set_err_string); \ - int pos = lua_gettop(L); \ - lua_pushcfunction(L, name ## _errfunc); \ - int result = lua_pcall(L, 0, 0, pos); \ - mu_assert_equal(result, LUA_ERRRUN); \ - mu_assert_str_not_equal(err_string, ""); \ - mu_assert_str_equal(err_string, expectation); \ - return 0; \ - } - - -HS_ERROR_TEST(hs_throw_error_constant, { - hs_throw_error(L, "a constant error"); - return 0; - }, "a constant error"); - - -HS_ERROR_TEST(hs_throw_error_format, { - hs_throw_error(L, "%s number %d", "error", 10); - return 0; - }, "error number 10"); - - -HS_ERROR_TEST(hs_throw_error_long, { - hs_throw_error(L, "%s is a %s is a %s", - "a very, very, very long string", - "a very, very, very long string", - "a very, very, very long string"); - return 0; - }, "a very, very, very long string is a a very, very, very long string is a a very, very, very long string"); - - -// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -void hs_throw_error_tests() -{ - printf("running hs_throw_error() tests...\n"); - - mu_run_test("throw constant error string", hs_throw_error_constant); - mu_run_test("throw error with format string", hs_throw_error_format); - mu_run_test("throw error with very long string", hs_throw_error_long); -} diff --git a/libs/honeysuckle/src/tests/hs_type_to_string_tests.c b/libs/honeysuckle/src/tests/hs_type_to_string_tests.c deleted file mode 100644 index 3b158ab..0000000 --- a/libs/honeysuckle/src/tests/hs_type_to_string_tests.c +++ /dev/null @@ -1,102 +0,0 @@ -#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/libs/honeysuckle/src/tests/tests_main.c b/libs/honeysuckle/src/tests/tests_main.c deleted file mode 100644 index 26af7cc..0000000 --- a/libs/honeysuckle/src/tests/tests_main.c +++ /dev/null @@ -1,33 +0,0 @@ -#include "hs_tests.h" - -/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - * - * RUN TESTS - * - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - */ - -int tests_run = 0; -int tests_run_old = 0; -int tests_failed = 0; - -int main() -{ - printf("================ start tests ================\n\n"); - - mu_run_suite(hs_type_to_string_tests); - mu_run_suite(hs_parse_args_tests); - mu_run_suite(hs_parse_overloaded_tests); - mu_run_suite(hs_create_table_tests); - //mu_run_suite(hs_create_enum_tests); - mu_run_suite(hs_process_table_tests); - mu_run_suite(hs_throw_error_tests); - - mu_run_suite(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; -} |