diff options
Diffstat (limited to 'test/optional_scalars_test')
| -rw-r--r-- | test/optional_scalars_test/CMakeLists.txt | 19 | ||||
| -rw-r--r-- | test/optional_scalars_test/optional_scalars_test.c | 280 | ||||
| -rw-r--r-- | test/optional_scalars_test/optional_scalars_test.fbs | 71 |
3 files changed, 370 insertions, 0 deletions
diff --git a/test/optional_scalars_test/CMakeLists.txt b/test/optional_scalars_test/CMakeLists.txt new file mode 100644 index 0000000..b13c1b9 --- /dev/null +++ b/test/optional_scalars_test/CMakeLists.txt @@ -0,0 +1,19 @@ +include(CTest) + +set(INC_DIR "${PROJECT_SOURCE_DIR}/include") +set(GEN_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated") +set(FBS_DIR "${PROJECT_SOURCE_DIR}/test/optional_scalars_test") + +include_directories("${GEN_DIR}" "${INC_DIR}") + +add_custom_target(gen_optional_scalars_test ALL) +add_custom_command ( + TARGET gen_optional_scalars_test + COMMAND ${CMAKE_COMMAND} -E make_directory "${GEN_DIR}" + COMMAND flatcc_cli -a --json -o "${GEN_DIR}" "${FBS_DIR}/optional_scalars_test.fbs" +) +add_executable(optional_scalars_test optional_scalars_test.c) +add_dependencies(optional_scalars_test gen_optional_scalars_test) +target_link_libraries(optional_scalars_test flatccrt) + +add_test(optional_scalars_test optional_scalars_test${CMAKE_EXECUTABLE_SUFFIX}) diff --git a/test/optional_scalars_test/optional_scalars_test.c b/test/optional_scalars_test/optional_scalars_test.c new file mode 100644 index 0000000..7566c05 --- /dev/null +++ b/test/optional_scalars_test/optional_scalars_test.c @@ -0,0 +1,280 @@ +#include <assert.h> +#include <stdio.h> + +#include "optional_scalars_test_builder.h" +#include "optional_scalars_test_json_printer.h" +#include "optional_scalars_test_json_parser.h" + + +#undef ns +#define ns(x) FLATBUFFERS_WRAP_NAMESPACE(optional_scalars, x) + +// #define TEST_ASSERT + +#ifdef TEST_ASSERT +#define test_assert(x) do { if (!(x)) { assert(0); return -1; }} while(0) +#else +#define test_assert(x) do { if (!(x)) { return -1; }} while(0) +#endif + +int create_scalar_stuff(flatcc_builder_t *builder) +{ + ns(ScalarStuff_start_as_root(builder)); + + ns(ScalarStuff_just_i8_add(builder, 10)); + ns(ScalarStuff_maybe_i8_add(builder, 11)); + ns(ScalarStuff_default_i8_add(builder, 12)); + + ns(ScalarStuff_just_i16_add(builder, 42)); + ns(ScalarStuff_maybe_i16_add(builder, 42)); + ns(ScalarStuff_default_i16_add(builder, 42)); + + ns(ScalarStuff_just_u32_add(builder, 0)); + ns(ScalarStuff_maybe_u32_add(builder, 0)); + ns(ScalarStuff_default_u32_add(builder, 0)); + + ns(ScalarStuff_just_f32_add(builder, 42)); + ns(ScalarStuff_maybe_f32_add(builder, 42)); + ns(ScalarStuff_default_f32_add(builder, 42)); + + ns(ScalarStuff_just_bool_add(builder, 1)); + ns(ScalarStuff_maybe_bool_add(builder, 1)); + ns(ScalarStuff_default_bool_add(builder, 1)); + + ns(ScalarStuff_just_enum_add)(builder, ns(OptionalByte_One)); + ns(ScalarStuff_maybe_enum_add)(builder, ns(OptionalByte_One)); + ns(ScalarStuff_default_enum_add)(builder, ns(OptionalByte_One)); + + ns(ScalarStuff_just_xfactor_add)(builder, ns(OptionalFactor_Twice)); + ns(ScalarStuff_maybe_xfactor_add)(builder, ns(OptionalFactor_Twice)); + ns(ScalarStuff_default_xfactor_add)(builder, ns(OptionalFactor_Twice)); + + ns(ScalarStuff_end_as_root(builder)); + + return 0; +} + +int access_scalar_stuff(const void *buf) +{ + ns(ScalarStuff_table_t) t = ns(ScalarStuff_as_root(buf)); + flatbuffers_int8_option_t maybe_i8; + flatbuffers_int16_option_t maybe_i16; + flatbuffers_uint32_option_t maybe_u32; + flatbuffers_uint8_option_t maybe_u8; + flatbuffers_float_option_t maybe_f32; + flatbuffers_bool_option_t maybe_bool; + ns(OptionalByte_option_t) maybe_enum; + ns(OptionalFactor_option_t) maybe_xfactor; + ns(OptionalFactor_option_t) maybe_yfactor; + + test_assert(10 == ns(ScalarStuff_just_i8_get(t))); + test_assert(11 == ns(ScalarStuff_maybe_i8_get(t))); + test_assert(12 == ns(ScalarStuff_default_i8_get(t))); + maybe_i8 = ns(ScalarStuff_maybe_i8_option(t)); + test_assert(!maybe_i8.is_null); + test_assert(11 == maybe_i8.value); + test_assert(ns(ScalarStuff_just_i8_is_present(t))); + test_assert(ns(ScalarStuff_maybe_i8_is_present(t))); + test_assert(ns(ScalarStuff_default_i8_is_present(t))); + + test_assert(0 == ns(ScalarStuff_just_u8_get(t))); + test_assert(0 == ns(ScalarStuff_maybe_u8_get(t))); + test_assert(42 == ns(ScalarStuff_default_u8_get(t))); + maybe_u8 = ns(ScalarStuff_maybe_u8_option(t)); + test_assert(maybe_u8.is_null); + test_assert(0 == maybe_u8.value); + test_assert(!ns(ScalarStuff_just_u8_is_present(t))); + test_assert(!ns(ScalarStuff_maybe_u8_is_present(t))); + test_assert(!ns(ScalarStuff_default_u8_is_present(t))); + + test_assert(42 == ns(ScalarStuff_just_i16_get(t))); + test_assert(42 == ns(ScalarStuff_maybe_i16_get(t))); + test_assert(42 == ns(ScalarStuff_default_i16_get(t))); + maybe_i16 = ns(ScalarStuff_maybe_i16_option(t)); + test_assert(!maybe_i16.is_null); + test_assert(42 == maybe_i16.value); + test_assert(ns(ScalarStuff_just_i16_is_present(t))); + test_assert(ns(ScalarStuff_maybe_i16_is_present(t))); + test_assert(!ns(ScalarStuff_default_i16_is_present(t))); + + test_assert(0 == ns(ScalarStuff_just_u32_get(t))); + test_assert(0 == ns(ScalarStuff_maybe_u32_get(t))); + test_assert(0 == ns(ScalarStuff_default_u32_get(t))); + maybe_u32 = ns(ScalarStuff_maybe_u32_option(t)); + test_assert(!maybe_u32.is_null); + test_assert(0 == maybe_u32.value); + test_assert(!ns(ScalarStuff_just_u32_is_present(t))); + test_assert(ns(ScalarStuff_maybe_u32_is_present(t))); + test_assert(ns(ScalarStuff_default_u32_is_present(t))); + + test_assert(42 == ns(ScalarStuff_just_f32_get(t))); + test_assert(42 == ns(ScalarStuff_maybe_f32_get(t))); + test_assert(42 == ns(ScalarStuff_default_f32_get(t))); + maybe_f32 = ns(ScalarStuff_maybe_f32_option(t)); + test_assert(!maybe_f32.is_null); + test_assert(42 == maybe_f32.value); + test_assert(ns(ScalarStuff_just_f32_is_present(t))); + test_assert(ns(ScalarStuff_maybe_f32_is_present(t))); + test_assert(!ns(ScalarStuff_default_f32_is_present(t))); + + test_assert(1 == ns(ScalarStuff_just_bool_get(t))); + test_assert(1 == ns(ScalarStuff_maybe_bool_get(t))); + test_assert(1 == ns(ScalarStuff_default_bool_get(t))); + maybe_bool = ns(ScalarStuff_maybe_bool_option(t)); + test_assert(!maybe_bool.is_null); + test_assert(1 == maybe_bool.value); + test_assert(ns(ScalarStuff_just_bool_is_present(t))); + test_assert(ns(ScalarStuff_maybe_bool_is_present(t))); + test_assert(!ns(ScalarStuff_default_bool_is_present(t))); + + test_assert(1 == ns(ScalarStuff_just_enum_get(t))); + test_assert(1 == ns(ScalarStuff_maybe_enum_get(t))); + test_assert(1 == ns(ScalarStuff_default_enum_get(t))); + maybe_enum = ns(ScalarStuff_maybe_enum_option(t)); + test_assert(!maybe_enum.is_null); + test_assert(maybe_enum.value == 1); + test_assert(ns(ScalarStuff_just_enum_is_present(t))); + test_assert(ns(ScalarStuff_maybe_enum_is_present(t))); + test_assert(!ns(ScalarStuff_default_enum_is_present(t))); + + test_assert(2 == ns(ScalarStuff_just_xfactor_get(t))); + test_assert(2 == ns(ScalarStuff_maybe_xfactor_get(t))); + test_assert(2 == ns(ScalarStuff_default_xfactor_get(t))); + maybe_xfactor = ns(ScalarStuff_maybe_xfactor_option(t)); + test_assert(!maybe_xfactor.is_null); + test_assert(maybe_xfactor.value == 2); + test_assert(ns(ScalarStuff_just_xfactor_is_present(t))); + test_assert(ns(ScalarStuff_maybe_xfactor_is_present(t))); + test_assert(!ns(ScalarStuff_default_xfactor_is_present(t))); + + test_assert(1 == ns(ScalarStuff_just_yfactor_get(t))); + test_assert(0 == ns(ScalarStuff_maybe_yfactor_get(t))); + test_assert(2 == ns(ScalarStuff_default_yfactor_get(t))); + maybe_yfactor = ns(ScalarStuff_maybe_yfactor_option(t)); + test_assert(maybe_yfactor.is_null); + test_assert(maybe_yfactor.value == 0); + test_assert(!ns(ScalarStuff_just_yfactor_is_present(t))); + test_assert(!ns(ScalarStuff_maybe_yfactor_is_present(t))); + test_assert(!ns(ScalarStuff_default_yfactor_is_present(t))); + return 0; +} + +int test(void) +{ + flatcc_builder_t builder; + void *buf; + size_t size; + + flatcc_builder_init(&builder); + test_assert(0 == create_scalar_stuff(&builder)); + buf = flatcc_builder_finalize_aligned_buffer(&builder, &size); + test_assert(0 == access_scalar_stuff(buf)); + flatcc_builder_aligned_free(buf); + flatcc_builder_clear(&builder); + + return 0; +} + +const char *expected_json = +"{\"just_i8\":10,\"maybe_i8\":11,\"default_i8\":12,\"just_i16\":42,\"maybe_i16\":42,\"maybe_u32\":0,\"default_u32\":0,\"just_f32\":42,\"maybe_f32\":42,\"just_bool\":true,\"maybe_bool\":true,\"just_enum\":\"One\",\"maybe_enum\":\"One\",\"just_xfactor\":\"Twice\",\"maybe_xfactor\":\"Twice\"}"; + +#if 0 +int print_buffer(const void *buf, size_t size) +{ + flatcc_json_printer_t printer; + flatcc_json_printer_init(&printer, 0); + ns(ScalarStuff_print_json_as_root)(&printer, buf, size, NULL); + if (flatcc_json_printer_get_error(&printer)) { + printf("could not print buffer\n"); + return -1; + } + return 0; +} +#endif + +int test_json_printer(void) +{ + flatcc_builder_t builder; + void *buf; + size_t size; + flatcc_json_printer_t printer; + char *json_buf; + size_t json_size; + + flatcc_builder_init(&builder); + test_assert(0 == create_scalar_stuff(&builder)); + buf = flatcc_builder_finalize_aligned_buffer(&builder, &size); + test_assert(0 == access_scalar_stuff(buf)); + flatcc_builder_clear(&builder); + flatcc_json_printer_init_dynamic_buffer(&printer, 0); + test_assert(ns(ScalarStuff_print_json_as_root)(&printer, buf, size, NULL)); + flatcc_builder_aligned_free(buf); + json_buf = flatcc_json_printer_get_buffer(&printer, &json_size); + printf("%.*s\n", (int)json_size, json_buf); + test_assert(strlen(expected_json) == json_size); + test_assert(0 == memcmp(expected_json, json_buf, json_size)); + + + flatcc_json_printer_clear(&printer); + return 0; +} + +int test_json_parser(void) +{ + flatcc_builder_t builder; + void *buf; + size_t size; + flatcc_json_parser_t parser; + flatcc_json_printer_t printer; + char *json_buf; + size_t json_size; + int ret; + + flatcc_builder_init(&builder); + ret = optional_scalars_ScalarStuff_parse_json_as_root(&builder, + &parser, expected_json, strlen(expected_json), 0, 0); + test_assert(ret == 0); + + buf = flatcc_builder_finalize_aligned_buffer(&builder, &size); + + flatcc_json_printer_init_dynamic_buffer(&printer, 0); + ns(ScalarStuff_print_json_as_root)(&printer, buf, size, NULL); + if (flatcc_json_printer_get_error(&printer)) { + printf("could not print buffer\n"); + return -1; + } + test_assert(0 == access_scalar_stuff(buf)); + + json_buf = flatcc_json_printer_get_buffer(&printer, &json_size); + printf("%.*s\n", (int)json_size, json_buf); + test_assert(strlen(expected_json) == json_size); + test_assert(0 == memcmp(expected_json, json_buf, json_size)); + flatcc_json_printer_clear(&printer); + + flatcc_builder_aligned_free(buf); + flatcc_builder_clear(&builder); + return 0; +} + +int main(int argc, char *argv[]) +{ + /* Silence warnings. */ + (void)argc; + (void)argv; + + if (test()) { + printf("optional scalars test failed"); + return 1; + } + if (test_json_printer()) { + printf("optional scalars json printer test failed"); + return 1; + } + if (test_json_parser()) { + printf("optional scalars json parser test failed"); + return 1; + } + printf("optional scalars test passed"); + return 0; +} + diff --git a/test/optional_scalars_test/optional_scalars_test.fbs b/test/optional_scalars_test/optional_scalars_test.fbs new file mode 100644 index 0000000..ba4c9d4 --- /dev/null +++ b/test/optional_scalars_test/optional_scalars_test.fbs @@ -0,0 +1,71 @@ +namespace optional_scalars; + +enum OptionalByte: byte { + None = 0, + One = 1, +} + +// Enums without a 0 element normally requires an initializer +// which is a problem when = null is the default. In this case +// the default value is forced to 0 when a reader insists on +// getting a numerical value instead of null. +enum OptionalFactor: byte { + Once = 1, + Twice = 2, +} + +// This table tests optional scalars in tables. It should be integrated with +// the main monster test once most languages support optional scalars. +table ScalarStuff { + just_i8: int8; + maybe_i8: int8 = null; + default_i8: int8 = 42; + just_u8: uint8; + maybe_u8: uint8 = null; + default_u8: uint8 = 42; + + just_i16: int16; + maybe_i16: int16 = null; + default_i16: int16 = 42; + just_u16: uint16; + maybe_u16: uint16 = null; + default_u16: uint16 = 42; + + just_i32: int32; + maybe_i32: int32 = null; + default_i32: int32 = 42; + just_u32: uint32; + maybe_u32: uint32 = null; + default_u32: uint32 = 42; + + just_i64: int64; + maybe_i64: int64 = null; + default_i64: int64 = 42; + just_u64: uint64; + maybe_u64: uint64 = null; + default_u64: uint64 = 42; + + just_f32: float32; + maybe_f32: float32 = null; + default_f32: float32 = 42; + just_f64: float64; + maybe_f64: float64 = null; + default_f64: float64 = 42; + + just_bool: bool; + maybe_bool: bool = null; + default_bool: bool = true; + + just_enum: OptionalByte; + maybe_enum: OptionalByte = null; + default_enum: OptionalByte = One; + + just_xfactor: OptionalFactor = Once; + maybe_xfactor: OptionalFactor = null; + default_xfactor: OptionalFactor = Twice; + + just_yfactor: OptionalFactor = Once; + maybe_yfactor: OptionalFactor = null; + default_yfactor: OptionalFactor = Twice; + +} |