diff options
| -rw-r--r-- | src/honeysuckle.c | 21 | ||||
| -rw-r--r-- | src/honeysuckle.h | 4 | ||||
| -rw-r--r-- | src/tests/hs_process_table_tests.c | 498 |
3 files changed, 501 insertions, 22 deletions
diff --git a/src/honeysuckle.c b/src/honeysuckle.c deleted file mode 100644 index 2689544..0000000 --- a/src/honeysuckle.c +++ /dev/null @@ -1,21 +0,0 @@ -#include "honeysuckle.h" - -int hs_create_enum(lua_State *L, ...) -{ - lua_createtable(L, 0, 0); - L = L; - return 0; -} - - -void hs_process_table(lua_State *L, int table_index, void *data, ...) -{ - L = L; - table_index = table_index; - data = data; -} - -void hs_pt_set_boolean(bool value, void *data) { value=value; data=data; } -void hs_pt_set_integer(lua_Integer value, void *data) { value=value; data=data; } -void hs_pt_set_number(lua_Number value, void *data) { value=value; data=data; } -void hs_pt_set_string(const char *value, void *data) { value=value; data=data; } diff --git a/src/honeysuckle.h b/src/honeysuckle.h index 871384c..233e3cd 100644 --- a/src/honeysuckle.h +++ b/src/honeysuckle.h @@ -405,7 +405,9 @@ void hs_process_table_(lua_State *L, struct hs_table_processor *processors); #define hs_process_table(L, table_index, ...) \ - hs_process_table(L, table_index, VA_NARGS(__VA_ARGS__)/4, {__VA_ARGS__}) + hs_process_table_(L, table_index, \ + VA_NARGS(__VA_ARGS__)/4, \ + (struct hs_table_processor[]) {__VA_ARGS__}) /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/src/tests/hs_process_table_tests.c b/src/tests/hs_process_table_tests.c index f2c6a31..c336b96 100644 --- a/src/tests/hs_process_table_tests.c +++ b/src/tests/hs_process_table_tests.c @@ -1,5 +1,480 @@ #include "hs_tests.h" +#define process() \ + bool boolean = false; \ + int integer = 0; \ + float 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 @@ -10,4 +485,27 @@ 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); } |