diff --git a/CMakeLists.txt b/CMakeLists.txt index 4bab3926..825c81a6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -19,18 +19,8 @@ set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS} -O0 -fsanitize=address" ) set(CMAKE_CXX_FLAGS_DEBUG - "${CMAKE_C_FLAGS} -O0 -fsanitize=address" + "-Wall -g -O0 -fsanitize=address" ) -#set(CMAKE_C_FLAGS_DEBUG - #"${CMAKE_C_FLAGS} -O0 -fsanitize=address \ - #-fsanitize-recover=address -fsanitize-address-use-after-scope \ - #-fno-stack-protector -fno-omit-frame-pointer -fno-var-tracking" -#) -#set(CMAKE_CXX_FLAGS_DEBUG - #"-g -O0 -fsanitize=address \ - #-fsanitize-recover=address -fsanitize-address-use-after-scope \ - #-fno-stack-protector -fno-omit-frame-pointer -fno-var-tracking" -#) if(NOT DEFINED CMAKE_SUPPRESS_DEVELOPER_WARNINGS) set(CMAKE_SUPPRESS_DEVELOPER_WARNINGS @@ -138,7 +128,6 @@ target_link_libraries(neuron ssl crypto ${CMAKE_THREAD_LIBS_INIT}) set(NEURON_BASE_SOURCES src/base/tag.c src/base/neu_plugin_common.c - #src/base/neu_data_expr.c src/base/tag_sort.c src/base/group.c src/connection/connection.c @@ -146,7 +135,6 @@ set(NEURON_BASE_SOURCES src/connection/mqtt_client_intf.c src/event/event_linux.c src/event/event_unix.c -# src/utils/atomic_data.c src/utils/json.c src/utils/neu_jwt.c src/utils/file.c @@ -187,11 +175,11 @@ add_subdirectory(plugins/ekuiper) # define for simulator add_subdirectory(simulator) -#if(NOT DISABLE_UT) - ## define for tests - #enable_testing() - #add_subdirectory(tests) -#endif() +if(NOT DISABLE_UT) + # define for tests + enable_testing() + add_subdirectory(tests) +endif() # Set sane defaults for multi-lib linux systems diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index f4d56f48..98214195 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -8,55 +8,6 @@ target_include_directories(json_test PRIVATE ) target_link_libraries(json_test neuron-base gtest_main gtest pthread jansson) -add_executable(json_rw_test json_rw_test.cc ${SRC_PARSER}) -target_include_directories(json_rw_test PRIVATE - ${CMAKE_SOURCE_DIR}/src - ${CMAKE_SOURCE_DIR}/include -) -target_link_libraries(json_rw_test neuron-base gtest_main gtest pthread jansson) - -add_executable(json_datatag_table_test json_datatag_table_test.cc ${SRC_PARSER}) -target_include_directories(json_datatag_table_test PRIVATE - ${CMAKE_SOURCE_DIR}/src - ${CMAKE_SOURCE_DIR}/include -) -target_link_libraries(json_datatag_table_test neuron-base gtest_main gtest pthread jansson) - -add_executable(json_nodes_test json_nodes_test.cc ${SRC_PARSER}) -target_include_directories(json_nodes_test PRIVATE - ${CMAKE_SOURCE_DIR}/src - ${CMAKE_SOURCE_DIR}/include -) -target_link_libraries(json_nodes_test neuron-base gtest_main gtest pthread jansson) - -add_executable(json_plugin_test json_plugin_test.cc ${SRC_PARSER}) -target_include_directories(json_plugin_test PRIVATE - ${CMAKE_SOURCE_DIR}/src - ${CMAKE_SOURCE_DIR}/include -) -target_link_libraries(json_plugin_test neuron-base gtest_main gtest pthread jansson) - -add_executable(json_group_config_test json_group_config_test.cc ${SRC_PARSER}) -target_include_directories(json_group_config_test PRIVATE - ${CMAKE_SOURCE_DIR}/src - ${CMAKE_SOURCE_DIR}/include -) -target_link_libraries(json_group_config_test neuron-base gtest_main gtest) - -add_executable(variable_test variable_test.cc) -target_include_directories(variable_test PRIVATE - ${CMAKE_SOURCE_DIR}/src - ${CMAKE_SOURCE_DIR}/include -) -target_link_libraries(variable_test neuron-base gtest_main gtest) - -add_executable(data_val_test data_val_test.cc ${SRC_PARSER}) -target_include_directories(data_val_test PRIVATE - ${CMAKE_SOURCE_DIR}/src - ${CMAKE_SOURCE_DIR}/include -) -target_link_libraries(data_val_test neuron-base gtest_main gtest pthread jansson) - add_executable(http_test http_test.cc ${CMAKE_SOURCE_DIR}/plugins/restful/http.c) @@ -67,22 +18,14 @@ target_include_directories(http_test PRIVATE target_link_libraries(http_test neuron-base gtest_main gtest jansson nng) #file(COPY ${CMAKE_SOURCE_DIR}/plugin_param_schema.json DESTINATION ${CMAKE_BINARY_DIR}/tests) -add_executable(mqtt_test mqtt_test.cc - ${CMAKE_SOURCE_DIR}/plugins/mqtt/util.c) -target_include_directories(mqtt_test PRIVATE - ${CMAKE_SOURCE_DIR}/src - ${CMAKE_SOURCE_DIR}/include - ${CMAKE_SOURCE_DIR}/src/schema - ${CMAKE_SOURCE_DIR}/plugins/mqtt) -target_link_libraries(mqtt_test neuron-base gtest_main gtest jansson ssl crypto) - -aux_source_directory(${CMAKE_SOURCE_DIR}/src/persist/json SRC_PERSIST_JSON) -add_executable(json_persistence_test json_persistence_test.cc ${SRC_PERSIST_JSON}) -target_include_directories(json_persistence_test PRIVATE - ${CMAKE_SOURCE_DIR}/src - ${CMAKE_SOURCE_DIR}/include -) -target_link_libraries(json_persistence_test neuron-base gtest_main gtest) +#add_executable(mqtt_test mqtt_test.cc + #${CMAKE_SOURCE_DIR}/plugins/mqtt/util.c) +#target_include_directories(mqtt_test PRIVATE + #${CMAKE_SOURCE_DIR}/src + #${CMAKE_SOURCE_DIR}/include + #${CMAKE_SOURCE_DIR}/src/schema + #${CMAKE_SOURCE_DIR}/plugins/mqtt) +#target_link_libraries(mqtt_test neuron-base gtest_main gtest jansson ssl crypto) file(COPY ${CMAKE_SOURCE_DIR}/neuron.key DESTINATION ${CMAKE_BINARY_DIR}/tests/config) file(COPY ${CMAKE_SOURCE_DIR}/neuron.pem DESTINATION ${CMAKE_BINARY_DIR}/tests/config) @@ -110,16 +53,9 @@ target_link_libraries(tag_sort_test neuron-base gtest_main gtest) #target_link_directories(modbus_point_test PRIVATE /usr/local/lib) include(GoogleTest) -gtest_discover_tests(data_val_test) gtest_discover_tests(json_test) -gtest_discover_tests(json_rw_test) -gtest_discover_tests(json_datatag_table_test) -gtest_discover_tests(json_nodes_test) -gtest_discover_tests(json_plugin_test) -gtest_discover_tests(json_group_config_test) gtest_discover_tests(http_test) -gtest_discover_tests(mqtt_test) +#gtest_discover_tests(mqtt_test) gtest_discover_tests(jwt_test) -gtest_discover_tests(json_persistence_test) gtest_discover_tests(base64_test) gtest_discover_tests(tag_sort_test) diff --git a/tests/data_val_test.cc b/tests/data_val_test.cc deleted file mode 100644 index 3e98d128..00000000 --- a/tests/data_val_test.cc +++ /dev/null @@ -1,2492 +0,0 @@ -#include - -#include "data_expr.h" -#include "types.h" - -#include "utils/log.h" - -zlog_category_t *neuron = NULL; -TEST(DataValueTest, neu_dvalue_init_set_get_prim_val) -{ - neu_data_val_t *val; - - uint8_t ret_bit; - int8_t ret_int8; - int16_t ret_int16; - int32_t ret_int32; - int64_t ret_int64; - - uint8_t ret_uint8; - uint16_t ret_uint16; - uint32_t ret_uint32; - uint64_t ret_uint64; - - float ret_float; - double ret_double; - bool b; - - /** test bit **/ - val = neu_dvalue_new(NEU_DTYPE_BIT); - neu_dvalue_init_bit(val, 1); - EXPECT_EQ(0, neu_dvalue_get_bit(val, &ret_bit)); - EXPECT_EQ(1, ret_bit); - - neu_dvalue_set_bit(val, 0); - EXPECT_EQ(0, neu_dvalue_get_bit(val, &ret_bit)); - EXPECT_EQ(0, ret_bit); - neu_dvalue_free(val); - - /** test bool **/ - val = neu_dvalue_new(NEU_DTYPE_BOOL); - neu_dvalue_init_bool(val, true); - EXPECT_EQ(0, neu_dvalue_get_bool(val, &b)); - EXPECT_EQ(true, b); - - neu_dvalue_set_bool(val, false); - EXPECT_EQ(0, neu_dvalue_get_bool(val, &b)); - EXPECT_EQ(false, b); - neu_dvalue_free(val); - - /** test int8 **/ - val = neu_dvalue_new(NEU_DTYPE_INT8); - neu_dvalue_init_int8(val, 16); - EXPECT_EQ(0, neu_dvalue_get_int8(val, &ret_int8)); - EXPECT_EQ(16, ret_int8); - - neu_dvalue_set_int8(val, 17); - EXPECT_EQ(0, neu_dvalue_get_int8(val, &ret_int8)); - EXPECT_EQ(17, ret_int8); - neu_dvalue_free(val); - - /** test int16 **/ - val = neu_dvalue_new(NEU_DTYPE_INT16); - neu_dvalue_init_int16(val, 4096); - EXPECT_EQ(0, neu_dvalue_get_int16(val, &ret_int16)); - EXPECT_EQ(4096, ret_int16); - - neu_dvalue_set_int16(val, 32767); - EXPECT_EQ(0, neu_dvalue_get_int16(val, &ret_int16)); - EXPECT_EQ(32767, ret_int16); - neu_dvalue_free(val); - - /** test int32 **/ - val = neu_dvalue_new(NEU_DTYPE_INT32); - neu_dvalue_init_int32(val, 268435456); - EXPECT_EQ(0, neu_dvalue_get_int32(val, &ret_int32)); - EXPECT_EQ(268435456, ret_int32); - - neu_dvalue_set_int32(val, 268435457); - EXPECT_EQ(0, neu_dvalue_get_int32(val, &ret_int32)); - EXPECT_EQ(268435457, ret_int32); - neu_dvalue_free(val); - - /** test int64 **/ - val = neu_dvalue_new(NEU_DTYPE_INT64); - neu_dvalue_init_int64(val, 100010111010); - EXPECT_EQ(0, neu_dvalue_get_int64(val, &ret_int64)); - EXPECT_EQ(100010111010, ret_int64); - - neu_dvalue_set_int64(val, 100010111011); - EXPECT_EQ(0, neu_dvalue_get_int64(val, &ret_int64)); - EXPECT_EQ(100010111011, ret_int64); - neu_dvalue_free(val); - - /** test uint8**/ - val = neu_dvalue_new(NEU_DTYPE_UINT8); - neu_dvalue_init_uint8(val, 16); - EXPECT_EQ(0, neu_dvalue_get_uint8(val, &ret_uint8)); - EXPECT_EQ(16, ret_uint8); - - neu_dvalue_set_uint8(val, 17); - EXPECT_EQ(0, neu_dvalue_get_uint8(val, &ret_uint8)); - EXPECT_EQ(17, ret_uint8); - neu_dvalue_free(val); - - /** test uint16**/ - val = neu_dvalue_new(NEU_DTYPE_UINT16); - neu_dvalue_init_uint16(val, 4096); - EXPECT_EQ(0, neu_dvalue_get_uint16(val, &ret_uint16)); - EXPECT_EQ(4096, ret_uint16); - - neu_dvalue_set_uint16(val, 65535); - EXPECT_EQ(0, neu_dvalue_get_uint16(val, &ret_uint16)); - EXPECT_EQ(65535, ret_uint16); - neu_dvalue_free(val); - - /** test uint32 **/ - val = neu_dvalue_new(NEU_DTYPE_UINT32); - neu_dvalue_init_uint32(val, 268435456); - EXPECT_EQ(0, neu_dvalue_get_uint32(val, &ret_uint32)); - EXPECT_EQ(268435456, ret_uint32); - - neu_dvalue_set_uint32(val, 268435457); - EXPECT_EQ(0, neu_dvalue_get_uint32(val, &ret_uint32)); - EXPECT_EQ(268435457, ret_uint32); - neu_dvalue_free(val); - - /** test uint64 **/ - val = neu_dvalue_new(NEU_DTYPE_UINT64); - neu_dvalue_init_uint64(val, 100010111010); - EXPECT_EQ(0, neu_dvalue_get_uint64(val, &ret_uint64)); - EXPECT_EQ(100010111010, ret_uint64); - - neu_dvalue_set_uint64(val, 100010111011); - EXPECT_EQ(0, neu_dvalue_get_uint64(val, &ret_uint64)); - EXPECT_EQ(100010111011, ret_uint64); - neu_dvalue_free(val); - - /** test float **/ - val = neu_dvalue_new(NEU_DTYPE_FLOAT); - neu_dvalue_init_float(val, (float) 100.101); - EXPECT_EQ(0, neu_dvalue_get_float(val, &ret_float)); - EXPECT_EQ((float) 100.101, ret_float); - - neu_dvalue_set_float(val, (float) 101.101); - EXPECT_EQ(0, neu_dvalue_get_float(val, &ret_float)); - EXPECT_EQ((float) 101.101, ret_float); - neu_dvalue_free(val); - - /** test double **/ - val = neu_dvalue_new(NEU_DTYPE_DOUBLE); - neu_dvalue_init_double(val, 100010111010.010603); - EXPECT_EQ(0, neu_dvalue_get_double(val, &ret_double)); - EXPECT_EQ(100010111010.010603, ret_double); - - neu_dvalue_set_double(val, 100010111010.010604); - EXPECT_EQ(0, neu_dvalue_get_double(val, &ret_double)); - EXPECT_EQ(100010111010.010604, ret_double); - neu_dvalue_free(val); - - /** test errorcode **/ - int32_t ret_error = 0; - val = neu_dvalue_new(NEU_DTYPE_ERRORCODE); - neu_dvalue_init_errorcode(val, -1); - EXPECT_EQ(0, neu_dvalue_get_errorcode(val, &ret_error)); - EXPECT_EQ(NEU_DTYPE_ERRORCODE, neu_dvalue_get_type(val)); - EXPECT_EQ(-1, ret_error); - - EXPECT_EQ(0, neu_dvalue_set_errorcode(val, 0)); - EXPECT_EQ(0, neu_dvalue_get_errorcode(val, &ret_error)); - EXPECT_EQ(0, ret_error); - - EXPECT_EQ(0, neu_dvalue_set_errorcode(val, 1)); - EXPECT_EQ(0, neu_dvalue_get_errorcode(val, &ret_error)); - EXPECT_EQ(1, ret_error); - neu_dvalue_free(val); - - val = neu_dvalue_new(NEU_DTYPE_ERRORCODE); - EXPECT_EQ(NEU_DTYPE_ERRORCODE, neu_dvalue_get_type(val)); - EXPECT_EQ(0, neu_dvalue_set_errorcode(val, 2)); - EXPECT_EQ(0, neu_dvalue_get_errorcode(val, &ret_error)); - EXPECT_EQ(2, ret_error); - neu_dvalue_free(val); -} - -#define INT_VAL_TEST_STR "hello int-val" -#define STRING_KEY_TEST_STR "string-key" -#define STRING_VAL_TEST_STR "hello string-val" -TEST(DataValueTest, neu_dvalue_set_get_keyvalue) -{ - /* teset set/get int_val */ - neu_int_val_t int_val; - neu_data_val_t *input_val; - input_val = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_val, (char *) INT_VAL_TEST_STR); - neu_int_val_init(&int_val, 21, input_val); - - neu_data_val_t *val; - int rc; - val = neu_dvalue_new(NEU_DTYPE_INT_VAL); - rc = neu_dvalue_set_int_val(val, int_val); - EXPECT_EQ(0, rc); - - neu_int_val_t int_val_get; - char * cstr; - rc = neu_dvalue_get_int_val(val, &int_val_get); - EXPECT_EQ(0, rc); - rc = neu_dvalue_get_ref_cstr(int_val_get.val, &cstr); - EXPECT_EQ(0, rc); - EXPECT_STREQ((char *) INT_VAL_TEST_STR, cstr); - neu_int_val_uninit(&int_val_get); - neu_dvalue_free(val); - - /* teset set/get string_val */ - neu_string_t *input_key; - neu_string_t *test_string; - // neu_data_val_t* input_val; - neu_string_val_t string_val; - input_key = neu_string_from_cstr((char *) STRING_KEY_TEST_STR); - test_string = neu_string_from_cstr((char *) STRING_VAL_TEST_STR); - input_val = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_val, test_string); - neu_string_val_init(&string_val, input_key, input_val); - - val = neu_dvalue_new(NEU_DTYPE_STRING_VAL); - rc = neu_dvalue_set_string_val(val, string_val); - EXPECT_EQ(0, rc); - - neu_string_val_t string_val_get; - char * key_cstr; - char * val_cstr; - neu_string_t * string_get; - rc = neu_dvalue_get_string_val(val, &string_val_get); - EXPECT_EQ(0, rc); - key_cstr = neu_string_get_ref_cstr(string_val_get.key); - EXPECT_STREQ((char *) STRING_KEY_TEST_STR, key_cstr); - rc = neu_dvalue_get_ref_string(string_val_get.val, &string_get); - EXPECT_EQ(0, rc); - EXPECT_STREQ((char *) STRING_VAL_TEST_STR, - neu_string_get_ref_cstr(string_get)); - neu_string_val_uninit(&string_val_get); - neu_dvalue_free(val); -} - -TEST(DataValueTest, neu_dvalue_set_get_cstr) -{ - neu_data_val_t *val = neu_dvalue_new(NEU_DTYPE_CSTR); - int rc = neu_dvalue_set_cstr(val, (char *) "Hello, Neuron!"); - EXPECT_EQ(0, rc); - char *ret = NULL; - rc = neu_dvalue_get_cstr(val, &ret); - EXPECT_EQ(0, rc); - EXPECT_STREQ("Hello, Neuron!", ret); - free(ret); - neu_dvalue_free(val); -} - -TEST(DataValueTest, neu_dvalue_set_get_string) -{ - neu_data_val_t *val = neu_dvalue_new(NEU_DTYPE_STRING); - neu_string_t * string_set = NULL; - - // To do - - neu_dvalue_free(val); -} - -TEST(DataValueTest, neu_dvalue_set_get_bytes) -{ - neu_data_val_t *val = neu_dvalue_new(NEU_DTYPE_BYTES); - neu_bytes_t * bytes_set; - neu_bytes_t * bytes_get; - int rc; - - bytes_set = neu_bytes_new(16); - rc = neu_dvalue_set_bytes(val, bytes_set); - EXPECT_EQ(0, rc); - rc = neu_dvalue_get_bytes(val, &bytes_get); - EXPECT_EQ(0, rc); - - size_t bytes_length = bytes_set->length; - EXPECT_EQ(0, memcmp(bytes_set->buf, bytes_get->buf, bytes_length)); - EXPECT_EQ(bytes_set->length, bytes_get->length); - - neu_bytes_free(bytes_set); - neu_bytes_free(bytes_get); - neu_dvalue_free(val); -} - -TEST(DataValueTest, neu_dvalue_set_get_array) -{ - int rc; - neu_fixed_array_t *array_set; - neu_fixed_array_t *array_get; - neu_fixed_array_t *array_get_ref; - - int8_t i8_arr[4] = { 2, 7, 1, 8 }; - array_set = neu_fixed_array_new(4, sizeof(int8_t)); - neu_fixed_array_set(array_set, 0, &i8_arr[0]); - neu_fixed_array_set(array_set, 1, &i8_arr[1]); - neu_fixed_array_set(array_set, 2, &i8_arr[2]); - neu_fixed_array_set(array_set, 3, &i8_arr[3]); - - neu_data_val_t *val = neu_dvalue_unit_new(); - neu_dvalue_init_move_array(val, NEU_DTYPE_INT8, array_set); - - size_t array_length = array_set->length; - neu_dvalue_get_ref_array(val, &array_get_ref); - EXPECT_EQ(0, memcmp(array_set->buf, array_get_ref->buf, array_length)); - EXPECT_EQ(array_set->esize, array_get_ref->esize); - EXPECT_EQ(array_set->length, array_get_ref->length); - - rc = neu_dvalue_get_move_array(val, &array_get); - EXPECT_EQ(0, rc); - - EXPECT_EQ(0, memcmp(array_set->buf, array_get->buf, array_length)); - EXPECT_EQ(array_set->esize, array_get->esize); - EXPECT_EQ(array_set->length, array_get->length); - - neu_fixed_array_free(array_get); - neu_dvalue_free(val); -} - -TEST(DataValueTest, neu_dvalue_set_get_vec) -{ - int rc; - vector_t *vec_set; - int8_t i8_arr[4] = { 2, 7, 1, 8 }; - vec_set = vector_new(4, sizeof(int8_t)); - vector_push_back(vec_set, &i8_arr[0]); - vector_push_back(vec_set, &i8_arr[1]); - vector_push_back(vec_set, &i8_arr[2]); - vector_push_back(vec_set, &i8_arr[3]); - - neu_data_val_t *val = neu_dvalue_unit_new(); - neu_dvalue_init_move_vec(val, NEU_DTYPE_INT8, vec_set); - vector_t *vec_get; - rc = neu_dvalue_get_move_vec(val, &vec_get); - - // TODO: assert two vector is equal - - vector_free(vec_get); - neu_dvalue_free(val); -} - -TEST(DataValueTest, neu_dvalue_prim_val_deser) -{ - ssize_t size; - uint8_t *buf = NULL; - - neu_data_val_t *val = NULL; - neu_data_val_t *val1 = NULL; - - /** bit serialize and deserialize test **/ - val = neu_dvalue_new(NEU_DTYPE_BIT); - EXPECT_EQ(0, neu_dvalue_set_bit(val, 1)); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - size = neu_dvalue_deserialize(buf, size, &val1); - EXPECT_LT(0, size); - uint8_t bit; - EXPECT_EQ(0, neu_dvalue_get_bit(val1, &bit)); - EXPECT_EQ(1, bit); - - free(buf); - neu_dvalue_free(val1); - - /** bool serialize and deserialize test **/ - val = neu_dvalue_new(NEU_DTYPE_BOOL); - EXPECT_EQ(0, neu_dvalue_set_bool(val, true)); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - size = neu_dvalue_deserialize(buf, size, &val1); - EXPECT_LT(0, size); - bool b; - EXPECT_EQ(0, neu_dvalue_get_bool(val1, &b)); - EXPECT_EQ(true, b); - - free(buf); - neu_dvalue_free(val1); - - /** int8 serialize and deserialize test **/ - val = neu_dvalue_new(NEU_DTYPE_INT8); - EXPECT_EQ(0, neu_dvalue_set_int8(val, 8)); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - size = neu_dvalue_deserialize(buf, size, &val1); - EXPECT_LT(0, size); - int8_t i8; - EXPECT_EQ(0, neu_dvalue_get_int8(val1, &i8)); - EXPECT_EQ(8, i8); - - free(buf); - neu_dvalue_free(val1); - - /** int16 serialize and deserialize test **/ - val = neu_dvalue_new(NEU_DTYPE_INT16); - EXPECT_EQ(0, neu_dvalue_set_int16(val, 16)); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - size = neu_dvalue_deserialize(buf, size, &val1); - EXPECT_LT(0, size); - int16_t i16; - EXPECT_EQ(0, neu_dvalue_get_int16(val1, &i16)); - EXPECT_EQ(16, i16); - - free(buf); - neu_dvalue_free(val1); - - /** int32 serialize and deserialize test **/ - val = neu_dvalue_new(NEU_DTYPE_INT32); - EXPECT_EQ(0, neu_dvalue_set_int32(val, 32)); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - size = neu_dvalue_deserialize(buf, size, &val1); - EXPECT_LT(0, size); - int32_t i32; - EXPECT_EQ(0, neu_dvalue_get_int32(val1, &i32)); - EXPECT_EQ(32, i32); - - free(buf); - neu_dvalue_free(val1); - - /** int64 serialize and deserialize test **/ - val = neu_dvalue_new(NEU_DTYPE_INT64); - EXPECT_EQ(0, neu_dvalue_set_int64(val, 100)); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - size = neu_dvalue_deserialize(buf, size, &val1); - EXPECT_LT(0, size); - int64_t i64; - EXPECT_EQ(0, neu_dvalue_get_int64(val1, &i64)); - EXPECT_EQ(100, i64); - - free(buf); - neu_dvalue_free(val1); - - /** uint8 serialize and deserialize test **/ - val = neu_dvalue_new(NEU_DTYPE_UINT8); - EXPECT_EQ(0, neu_dvalue_set_uint8(val, 8)); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - size = neu_dvalue_deserialize(buf, size, &val1); - EXPECT_LT(0, size); - uint8_t ui8; - EXPECT_EQ(0, neu_dvalue_get_uint8(val1, &ui8)); - EXPECT_EQ(8, ui8); - - free(buf); - neu_dvalue_free(val1); - - /** uint16 serialize and deserialize test **/ - val = neu_dvalue_new(NEU_DTYPE_UINT16); - EXPECT_EQ(0, neu_dvalue_set_uint16(val, 16)); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - size = neu_dvalue_deserialize(buf, size, &val1); - EXPECT_LT(0, size); - uint16_t ui16; - EXPECT_EQ(0, neu_dvalue_get_uint16(val1, &ui16)); - EXPECT_EQ(16, ui16); - - free(buf); - neu_dvalue_free(val1); - - /** uint32 serialize and deserialize test **/ - val = neu_dvalue_new(NEU_DTYPE_UINT32); - EXPECT_EQ(0, neu_dvalue_set_uint32(val, 32)); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - size = neu_dvalue_deserialize(buf, size, &val1); - EXPECT_LT(0, size); - uint32_t ui32; - EXPECT_EQ(0, neu_dvalue_get_uint32(val1, &ui32)); - EXPECT_EQ(32, ui32); - - free(buf); - neu_dvalue_free(val1); - - /** uint64 serialize and deserialize test **/ - val = neu_dvalue_new(NEU_DTYPE_UINT64); - EXPECT_EQ(0, neu_dvalue_set_uint64(val, 100)); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - size = neu_dvalue_deserialize(buf, size, &val1); - EXPECT_LT(0, size); - uint64_t ui64; - EXPECT_EQ(0, neu_dvalue_get_uint64(val1, &ui64)); - EXPECT_EQ(100, ui64); - - free(buf); - neu_dvalue_free(val1); - - /** float serialize and deserialize test **/ - val = neu_dvalue_new(NEU_DTYPE_FLOAT); - EXPECT_EQ(0, neu_dvalue_set_float(val, (float) 3.14159)); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - size = neu_dvalue_deserialize(buf, size, &val1); - EXPECT_LT(0, size); - float f32; - EXPECT_EQ(0, neu_dvalue_get_float(val1, &f32)); - EXPECT_EQ((float) 3.14159, f32); - - free(buf); - neu_dvalue_free(val1); - - /** double serialize and deserialize **/ - val = neu_dvalue_new(NEU_DTYPE_DOUBLE); - EXPECT_EQ(0, neu_dvalue_set_double(val, 3.14159265)); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - size = neu_dvalue_deserialize(buf, size, &val1); - EXPECT_LT(0, size); - double f64; - EXPECT_EQ(0, neu_dvalue_get_double(val1, &f64)); - EXPECT_EQ(3.14159265, f64); - - free(buf); - neu_dvalue_free(val1); -} - -TEST(DataValueTest, neu_dvalue_cstr_deser) -{ - uint8_t *buf = NULL; - ssize_t size; - - neu_data_val_t *val = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_data_val_t *val_des; - char * get_cstr = NULL; - - EXPECT_EQ(0, neu_dvalue_set_cstr(val, (char *) "Hello, Neuron!")); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - size = neu_dvalue_deserialize(buf, size, &val_des); - EXPECT_LT(0, size); - EXPECT_EQ(0, neu_dvalue_get_cstr(val_des, &get_cstr)); - EXPECT_STREQ("Hello, Neuron!", get_cstr); - - free(buf); - free(get_cstr); - neu_dvalue_free(val_des); -} - -TEST(DataValueTest, neu_dvalue_keyvalue_deser) -{ - ssize_t size; - uint8_t *buf = NULL; - - neu_data_val_t *val; - neu_data_val_t *val1; - - /** test int_val serialize **/ - neu_int_val_t int_val; - neu_data_val_t *input_val = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_val, (char *) INT_VAL_TEST_STR); - neu_int_val_init(&int_val, 21, input_val); - - val = neu_dvalue_new(NEU_DTYPE_INT_VAL); - EXPECT_EQ(0, neu_dvalue_set_int_val(val, int_val)); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - size = neu_dvalue_deserialize(buf, size, &val1); - EXPECT_LT(0, size); - neu_int_val_t int_val_get; - char * cstr; - EXPECT_EQ(0, neu_dvalue_get_int_val(val1, &int_val_get)); - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(int_val_get.val, &cstr)); - EXPECT_STREQ((char *) INT_VAL_TEST_STR, cstr); - neu_int_val_uninit(&int_val_get); - - free(buf); - neu_dvalue_free(val1); - - /** test string_val serialize **/ - neu_string_val_t string_val; - neu_string_t * input_key = - neu_string_from_cstr((char *) STRING_KEY_TEST_STR); - neu_string_t *test_string = - neu_string_from_cstr((char *) STRING_VAL_TEST_STR); - input_val = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_val, test_string); - neu_string_val_init(&string_val, input_key, input_val); - - val = neu_dvalue_new(NEU_DTYPE_STRING_VAL); - EXPECT_EQ(0, neu_dvalue_set_string_val(val, string_val)); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - neu_data_val_t *val_des = NULL; - size = neu_dvalue_deserialize(buf, size, &val_des); - neu_string_val_t string_val_get; - neu_dvalue_get_string_val(val_des, &string_val_get); - EXPECT_STREQ((char *) STRING_KEY_TEST_STR, - neu_string_get_ref_cstr(string_val_get.key)); - neu_string_t *string_get = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_string(string_val_get.val, &string_get)); - EXPECT_STREQ((char *) STRING_VAL_TEST_STR, - neu_string_get_ref_cstr(string_get)); - neu_string_val_uninit(&string_val_get); - - free(buf); - neu_dvalue_free(val_des); -} - -neu_fixed_array_t *ser_deser_with_fixed_array(neu_fixed_array_t *array_set, - neu_dtype_e type) -{ - uint8_t *buf = NULL; - ssize_t size; - - neu_data_val_t *val = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(val, type, array_set); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - neu_data_val_t *val_des; - EXPECT_LT(0, neu_dvalue_deserialize(buf, size, &val_des)); - neu_fixed_array_t *array_get; - EXPECT_EQ(0, neu_dvalue_get_move_array(val_des, &array_get)); - - EXPECT_EQ(array_set->esize, array_get->esize); - EXPECT_EQ(array_set->length, array_get->length); - - free(buf); - neu_fixed_array_free(array_set); - neu_dvalue_free(val_des); - - return array_get; -} - -TEST(DataValueTest, neu_dvalue_array_deser) -{ - /** int64 **/ - int64_t i64_arr[4] = { 2, 7, 1, 8 }; - neu_fixed_array_t *set_array_int = neu_fixed_array_new(4, sizeof(int64_t)); - neu_fixed_array_set(set_array_int, 0, &i64_arr[0]); - neu_fixed_array_set(set_array_int, 1, &i64_arr[1]); - neu_fixed_array_set(set_array_int, 2, &i64_arr[2]); - neu_fixed_array_set(set_array_int, 3, &i64_arr[3]); - - neu_fixed_array_t *get_array_int = - ser_deser_with_fixed_array(set_array_int, NEU_DTYPE_INT64); - int64_t *int_get1 = (int64_t *) neu_fixed_array_get(get_array_int, 0); - EXPECT_EQ(2, *int_get1); - int64_t *int_get2 = (int64_t *) neu_fixed_array_get(get_array_int, 1); - EXPECT_EQ(7, *int_get2); - int64_t *int_get3 = (int64_t *) neu_fixed_array_get(get_array_int, 2); - EXPECT_EQ(1, *int_get3); - int64_t *int_get4 = (int64_t *) neu_fixed_array_get(get_array_int, 3); - EXPECT_EQ(8, *int_get4); - neu_fixed_array_free(get_array_int); - - /** double **/ - double double_arr[4] = { 0.11, 0.222, 0.3333, 0.4444 }; - neu_fixed_array_t *set_array_double = - neu_fixed_array_new(4, sizeof(double)); - neu_fixed_array_set(set_array_double, 0, &double_arr[0]); - neu_fixed_array_set(set_array_double, 1, &double_arr[1]); - neu_fixed_array_set(set_array_double, 2, &double_arr[2]); - neu_fixed_array_set(set_array_double, 3, &double_arr[3]); - - /** serialize and deserialize return **/ - neu_fixed_array_t *get_array_double = - ser_deser_with_fixed_array(set_array_double, NEU_DTYPE_DOUBLE); - - /** Compare **/ - double *double_get1 = (double *) neu_fixed_array_get(get_array_double, 0); - EXPECT_EQ(0.11, *double_get1); - double *double_get2 = (double *) neu_fixed_array_get(get_array_double, 1); - EXPECT_EQ(0.222, *double_get2); - double *double_get3 = (double *) neu_fixed_array_get(get_array_double, 2); - EXPECT_EQ(0.3333, *double_get3); - double *double_get4 = (double *) neu_fixed_array_get(get_array_double, 3); - EXPECT_EQ(0.4444, *double_get4); - neu_fixed_array_free(get_array_double); - - /** cstr **/ - char *cstr_arr1 = (char *) "Hello,cstr-test1"; - char *cstr_arr2 = (char *) "Hello,cstr-test2"; - char *cstr_arr3 = (char *) "Hello,cstr-test3"; - char *cstr_arr4 = (char *) "Hello,cstr-test4"; - - neu_fixed_array_t *set_array_cstr = neu_fixed_array_new(4, sizeof(char *)); - neu_fixed_array_set(set_array_cstr, 0, &cstr_arr1); - neu_fixed_array_set(set_array_cstr, 1, &cstr_arr2); - neu_fixed_array_set(set_array_cstr, 2, &cstr_arr3); - neu_fixed_array_set(set_array_cstr, 3, &cstr_arr4); - - /** serialize and deserialize return **/ - neu_fixed_array_t *get_array_cstr = - ser_deser_with_fixed_array(set_array_cstr, NEU_DTYPE_CSTR); - - /** Compare **/ - char *cstr_get1 = *(char **) neu_fixed_array_get(get_array_cstr, 0); - EXPECT_STREQ((char *) "Hello,cstr-test1", cstr_get1); - char *cstr_get2 = *(char **) neu_fixed_array_get(get_array_cstr, 1); - EXPECT_STREQ((char *) "Hello,cstr-test2", cstr_get2); - char *cstr_get3 = *(char **) neu_fixed_array_get(get_array_cstr, 2); - EXPECT_STREQ((char *) "Hello,cstr-test3", cstr_get3); - char *cstr_get4 = *(char **) neu_fixed_array_get(get_array_cstr, 3); - EXPECT_STREQ((char *) "Hello,cstr-test4", cstr_get4); - free(cstr_get1); - free(cstr_get2); - free(cstr_get3); - free(cstr_get4); - neu_fixed_array_free(get_array_cstr); - - /** int_val **/ - /** the fist element **/ - neu_int_val_t int_val1; - neu_data_val_t *input_val1 = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_val1, (char *) "hello,int-val1"); - neu_int_val_init(&int_val1, 21, input_val1); - - /** the second element **/ - neu_int_val_t int_val2; - neu_data_val_t *input_val2; - input_val2 = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_val2, (char *) "hello,int-val2"); - neu_int_val_init(&int_val2, 22, input_val2); - - /** set array **/ - neu_fixed_array_t *set_array_int_val = - neu_fixed_array_new(2, sizeof(neu_int_val_t)); - neu_fixed_array_set(set_array_int_val, 0, &int_val1); - neu_fixed_array_set(set_array_int_val, 1, &int_val2); - - /** serialize and deserialize return **/ - neu_fixed_array_t *get_array_int_val = - ser_deser_with_fixed_array(set_array_int_val, NEU_DTYPE_INT_VAL); - - /** Compare the first int_val element **/ - neu_int_val_t *get_int_val1 = - (neu_int_val_t *) neu_fixed_array_get(get_array_int_val, 0); - EXPECT_EQ(21, get_int_val1->key); - char *cstr1 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val1->val, &cstr1)); - EXPECT_STREQ((char *) "hello,int-val1", cstr1); - neu_int_val_uninit(get_int_val1); - - /** Compare the second int_val element **/ - neu_int_val_t *get_int_val2 = - (neu_int_val_t *) neu_fixed_array_get(get_array_int_val, 1); - EXPECT_EQ(22, get_int_val2->key); - char *cstr2 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val2->val, &cstr2)); - EXPECT_STREQ((char *) "hello,int-val2", cstr2); - neu_int_val_uninit(get_int_val2); - - neu_fixed_array_free(get_array_int_val); - - neu_dvalue_free(input_val1); - neu_dvalue_free(input_val2); - - /** string_val **/ - /** the fist element **/ - neu_string_t *input_str_key1 = neu_string_from_cstr((char *) "string-key1"); - neu_string_t *test_string1 = - neu_string_from_cstr((char *) "hello,string-val1"); - neu_data_val_t *input_str_val1 = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_str_val1, test_string1); - neu_string_val_t string_val1; - neu_string_val_init(&string_val1, input_str_key1, input_str_val1); - - /** the second element **/ - neu_string_t *input_str_key2 = neu_string_from_cstr((char *) "string-key2"); - neu_string_t *test_string2 = - neu_string_from_cstr((char *) "hello,string-val2"); - neu_data_val_t *input_str_val2 = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_str_val2, test_string2); - neu_string_val_t string_val2; - neu_string_val_init(&string_val2, input_str_key2, input_str_val2); - - /** set array **/ - neu_fixed_array_t *set_array_str_val = - neu_fixed_array_new(2, sizeof(neu_string_val_t)); - neu_fixed_array_set(set_array_str_val, 0, &string_val1); - neu_fixed_array_set(set_array_str_val, 1, &string_val2); - - /** serialize and deserialize return **/ - neu_fixed_array_t *get_array_str_val = - ser_deser_with_fixed_array(set_array_str_val, NEU_DTYPE_STRING_VAL); - - /** Compare the first str_val element **/ - neu_string_val_t *get_str_val1 = - (neu_string_val_t *) neu_fixed_array_get(get_array_str_val, 0); - - EXPECT_STREQ((char *) "string-key1", - neu_string_get_ref_cstr(get_str_val1->key)); - neu_string_t *string_get1 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_string(get_str_val1->val, &string_get1)); - EXPECT_STREQ((char *) "hello,string-val1", - neu_string_get_ref_cstr(string_get1)); - neu_string_val_uninit(get_str_val1); - - /** Compare the second str_val element **/ - neu_string_val_t *get_str_val2 = - (neu_string_val_t *) neu_fixed_array_get(get_array_str_val, 1); - - EXPECT_STREQ((char *) "string-key2", - neu_string_get_ref_cstr(get_str_val2->key)); - neu_string_t *string_get2 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_string(get_str_val2->val, &string_get2)); - EXPECT_STREQ((char *) "hello,string-val2", - neu_string_get_ref_cstr(string_get2)); - neu_string_val_uninit(get_str_val2); - - neu_fixed_array_free(get_array_str_val); - - neu_dvalue_free(input_str_val1); - neu_dvalue_free(input_str_val2); - - neu_string_free(input_str_key1); - neu_string_free(input_str_key2); -} - -void comp_arr_2d_int(neu_fixed_array_t *get_array_int) -{ - /** Compare the first element of 2D array **/ - neu_data_val_t *get_array_dval1 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_int, 0); - neu_fixed_array_t *get_array1 = NULL; - neu_dvalue_get_move_array(get_array_dval1, &get_array1); - int64_t *get_int11 = (int64_t *) neu_fixed_array_get(get_array1, 0); - EXPECT_EQ(3, *get_int11); - int64_t *get_int12 = (int64_t *) neu_fixed_array_get(get_array1, 1); - EXPECT_EQ(2, *get_int12); - int64_t *get_int13 = (int64_t *) neu_fixed_array_get(get_array1, 2); - EXPECT_EQ(1, *get_int13); - neu_fixed_array_free(get_array1); - neu_dvalue_free(get_array_dval1); - - /** Compare the second element of 2D array **/ - neu_data_val_t *get_array_dval2 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_int, 1); - neu_fixed_array_t *get_array2 = NULL; - neu_dvalue_get_move_array(get_array_dval2, &get_array2); - int64_t *get_int21 = (int64_t *) neu_fixed_array_get(get_array2, 0); - EXPECT_EQ(6, *get_int21); - int64_t *get_int22 = (int64_t *) neu_fixed_array_get(get_array2, 1); - EXPECT_EQ(5, *get_int22); - int64_t *get_int23 = (int64_t *) neu_fixed_array_get(get_array2, 2); - EXPECT_EQ(4, *get_int23); - neu_fixed_array_free(get_array2); - neu_dvalue_free(get_array_dval2); - - neu_fixed_array_free(get_array_int); -} - -void comp_arr_2d_double(neu_fixed_array_t *get_array_double) -{ - /** Compare the first element **/ - neu_data_val_t *get_array_dval1 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_double, 0); - neu_fixed_array_t *get_array1 = NULL; - neu_dvalue_get_move_array(get_array_dval1, &get_array1); - double *get_double11 = (double *) neu_fixed_array_get(get_array1, 0); - EXPECT_EQ(0.3, *get_double11); - double *get_double12 = (double *) neu_fixed_array_get(get_array1, 1); - EXPECT_EQ(0.2, *get_double12); - double *get_double13 = (double *) neu_fixed_array_get(get_array1, 2); - EXPECT_EQ(0.1, *get_double13); - neu_fixed_array_free(get_array1); - neu_dvalue_free(get_array_dval1); - - /** Compare the second element **/ - neu_data_val_t *get_array_dval2 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_double, 1); - neu_fixed_array_t *get_array2 = NULL; - neu_dvalue_get_move_array(get_array_dval2, &get_array2); - double *get_double21 = (double *) neu_fixed_array_get(get_array2, 0); - EXPECT_EQ(0.66, *get_double21); - double *get_double22 = (double *) neu_fixed_array_get(get_array2, 1); - EXPECT_EQ(0.555, *get_double22); - double *get_double23 = (double *) neu_fixed_array_get(get_array2, 2); - EXPECT_EQ(0.4444, *get_double23); - neu_fixed_array_free(get_array2); - neu_dvalue_free(get_array_dval2); - - neu_fixed_array_free(get_array_double); -} - -void comp_arr_2d_int_val(neu_fixed_array_t *get_array_int_val) -{ - /** Compare the first element of 2D array **/ - neu_data_val_t *get_array_dval1 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_int_val, 0); - neu_fixed_array_t *get_array1 = NULL; - neu_dvalue_get_move_array(get_array_dval1, &get_array1); - - /** Compare the first element of 1D array1 **/ - neu_int_val_t *get_int_val11 = - (neu_int_val_t *) neu_fixed_array_get(get_array1, 0); - EXPECT_EQ(21, get_int_val11->key); - char *output_val11 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val11->val, &output_val11)); - EXPECT_STREQ((char *) "hello,int-val1", output_val11); - neu_int_val_uninit(get_int_val11); - - /** Compare the second element of 1D array1 **/ - neu_int_val_t *get_int_val12 = - (neu_int_val_t *) neu_fixed_array_get(get_array1, 1); - EXPECT_EQ(22, get_int_val12->key); - char *output_val12 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val12->val, &output_val12)); - EXPECT_STREQ((char *) "hello,int-val2", output_val12); - neu_int_val_uninit(get_int_val12); - - neu_fixed_array_free(get_array1); - neu_dvalue_free(get_array_dval1); - - /** Compare the second element of 2D array **/ - neu_data_val_t *get_array_dval2 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_int_val, 1); - neu_fixed_array_t *get_array2 = NULL; - neu_dvalue_get_move_array(get_array_dval2, &get_array2); - - /** Compare the first element of 1D array2 **/ - neu_int_val_t *get_int_val21 = - (neu_int_val_t *) neu_fixed_array_get(get_array2, 0); - EXPECT_EQ(23, get_int_val21->key); - char *output_val21 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val21->val, &output_val21)); - EXPECT_STREQ((char *) "hello,int-val3", output_val21); - neu_int_val_uninit(get_int_val21); - - /** Compare the second element of 1D array2 **/ - neu_int_val_t *get_int_val22 = - (neu_int_val_t *) neu_fixed_array_get(get_array2, 1); - EXPECT_EQ(24, get_int_val22->key); - char *output_val22 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val22->val, &output_val22)); - EXPECT_STREQ((char *) "hello,int-val4", output_val22); - neu_int_val_uninit(get_int_val22); - - neu_fixed_array_free(get_array2); - neu_dvalue_free(get_array_dval2); - - neu_fixed_array_free(get_array_int_val); -} - -void comp_arr_2d_str_val(neu_fixed_array_t *get_array_str_val) -{ - /** Compare the first element of 2D array **/ - neu_data_val_t *get_array_dval1 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_str_val, 0); - neu_fixed_array_t *get_array1 = NULL; - neu_dvalue_get_move_array(get_array_dval1, &get_array1); - - /** Compare the first str_val element of 1D array1 **/ - neu_string_val_t *get_str_val11 = - (neu_string_val_t *) neu_fixed_array_get(get_array1, 0); - - EXPECT_STREQ((char *) "string-key1", - neu_string_get_ref_cstr(get_str_val11->key)); - neu_string_t *get_string11 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_string(get_str_val11->val, &get_string11)); - EXPECT_STREQ((char *) "hello,string-val1", - neu_string_get_ref_cstr(get_string11)); - neu_string_val_uninit(get_str_val11); - - /** Compare the second str_val element of 1D array1 **/ - neu_string_val_t *get_str_val12 = - (neu_string_val_t *) neu_fixed_array_get(get_array1, 1); - - EXPECT_STREQ((char *) "string-key2", - neu_string_get_ref_cstr(get_str_val12->key)); - neu_string_t *get_string12 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_string(get_str_val12->val, &get_string12)); - EXPECT_STREQ((char *) "hello,string-val2", - neu_string_get_ref_cstr(get_string12)); - neu_string_val_uninit(get_str_val12); - - neu_fixed_array_free(get_array1); - neu_dvalue_free(get_array_dval1); - - /** Compare the second element of 2D array **/ - neu_data_val_t *get_array_dval2 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_str_val, 1); - neu_fixed_array_t *get_array2 = NULL; - neu_dvalue_get_move_array(get_array_dval2, &get_array2); - - /** Compare the first str_val element of 1D array2 **/ - neu_string_val_t *get_str_val21 = - (neu_string_val_t *) neu_fixed_array_get(get_array2, 0); - - EXPECT_STREQ((char *) "string-key3", - neu_string_get_ref_cstr(get_str_val21->key)); - neu_string_t *get_string21 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_string(get_str_val21->val, &get_string21)); - EXPECT_STREQ((char *) "hello,string-val3", - neu_string_get_ref_cstr(get_string21)); - neu_string_val_uninit(get_str_val21); - - /** Compare the second str_val element of 1D array1 **/ - neu_string_val_t *get_str_val22 = - (neu_string_val_t *) neu_fixed_array_get(get_array2, 1); - - EXPECT_STREQ((char *) "string-key4", - neu_string_get_ref_cstr(get_str_val22->key)); - neu_string_t *get_string22 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_string(get_str_val22->val, &get_string22)); - EXPECT_STREQ((char *) "hello,string-val4", - neu_string_get_ref_cstr(get_string22)); - neu_string_val_uninit(get_str_val22); - - neu_fixed_array_free(get_array2); - neu_dvalue_free(get_array_dval2); - - neu_fixed_array_free(get_array_str_val); -} - -TEST(DataValueTest, neu_dvalue_2D_array_deser) -{ - /** int64 **/ - /** set array **/ - int64_t i64_arr[2][3] = { { 3, 2, 1 }, { 6, 5, 4 } }; - - neu_fixed_array_t *set_int_array1 = neu_fixed_array_new(3, sizeof(int64_t)); - neu_fixed_array_set(set_int_array1, 0, &i64_arr[0][0]); - neu_fixed_array_set(set_int_array1, 1, &i64_arr[0][1]); - neu_fixed_array_set(set_int_array1, 2, &i64_arr[0][2]); - neu_data_val_t *array_int_dval1 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_dval1, NEU_DTYPE_INT64, set_int_array1); - - neu_fixed_array_t *set_int_array2 = neu_fixed_array_new(3, sizeof(int64_t)); - neu_fixed_array_set(set_int_array2, 0, &i64_arr[1][0]); - neu_fixed_array_set(set_int_array2, 1, &i64_arr[1][1]); - neu_fixed_array_set(set_int_array2, 2, &i64_arr[1][2]); - neu_data_val_t *array_int_dval2 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_dval2, NEU_DTYPE_INT64, set_int_array2); - - neu_fixed_array_t *set_int_array = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_int_array, 0, &array_int_dval1); - neu_fixed_array_set(set_int_array, 1, &array_int_dval2); - - /** serialize and deserialize return **/ - neu_fixed_array_t *get_int_array = - ser_deser_with_fixed_array(set_int_array, NEU_DTYPE_DATA_VAL); - - /** free **/ - neu_fixed_array_free(set_int_array1); - neu_fixed_array_free(set_int_array2); - - neu_dvalue_free(array_int_dval1); - neu_dvalue_free(array_int_dval2); - - /** Compare **/ - comp_arr_2d_int(get_int_array); - - /** double **/ - /** set array **/ - double double_arr[2][3] = { { 0.3, 0.2, 0.1 }, { 0.66, 0.555, 0.4444 } }; - - /** set the first elem**/ - neu_fixed_array_t *set_double_array1 = - neu_fixed_array_new(3, sizeof(double)); - neu_fixed_array_set(set_double_array1, 0, &double_arr[0][0]); - neu_fixed_array_set(set_double_array1, 1, &double_arr[0][1]); - neu_fixed_array_set(set_double_array1, 2, &double_arr[0][2]); - neu_data_val_t *array_double_dval1 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_double_dval1, NEU_DTYPE_DOUBLE, - set_double_array1); - - neu_fixed_array_t *set_double_array2 = - neu_fixed_array_new(3, sizeof(double)); - neu_fixed_array_set(set_double_array2, 0, &double_arr[1][0]); - neu_fixed_array_set(set_double_array2, 1, &double_arr[1][1]); - neu_fixed_array_set(set_double_array2, 2, &double_arr[1][2]); - neu_data_val_t *array_double_dval2 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_double_dval2, NEU_DTYPE_DOUBLE, - set_double_array2); - - neu_fixed_array_t *set_double_array = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_double_array, 0, &array_double_dval1); - neu_fixed_array_set(set_double_array, 1, &array_double_dval2); - - /** serialize and deserialize return **/ - neu_fixed_array_t *get_double_array = - ser_deser_with_fixed_array(set_double_array, NEU_DTYPE_DATA_VAL); - - /** free **/ - neu_fixed_array_free(set_double_array1); - neu_fixed_array_free(set_double_array2); - - neu_dvalue_free(array_double_dval1); - neu_dvalue_free(array_double_dval2); - - /** Compare **/ - comp_arr_2d_double(get_double_array); - - /** int_val **/ - /** the fist element of 1D array **/ - neu_data_val_t *input_int_val11 = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_int_val11, (char *) "hello,int-val1"); - neu_int_val_t int_val11; - neu_int_val_init(&int_val11, 21, input_int_val11); - - /** the second element of 1D array **/ - neu_data_val_t *input_int_val12 = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_int_val12, (char *) "hello,int-val2"); - neu_int_val_t int_val12; - neu_int_val_init(&int_val12, 22, input_int_val12); - - /** set the first element of 2D array **/ - neu_fixed_array_t *set_int_val_array1 = - neu_fixed_array_new(2, sizeof(neu_int_val_t)); - neu_fixed_array_set(set_int_val_array1, 0, &int_val11); - neu_fixed_array_set(set_int_val_array1, 1, &int_val12); - - neu_data_val_t *array_int_val_dval1 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_val_dval1, NEU_DTYPE_INT_VAL, - set_int_val_array1); - - /** the third element of 1D array **/ - neu_data_val_t *input_int_val21 = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_int_val21, (char *) "hello,int-val3"); - neu_int_val_t int_val21; - neu_int_val_init(&int_val21, 23, input_int_val21); - - /** the fourth element of 1D array **/ - neu_data_val_t *input_int_val22 = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_int_val22, (char *) "hello,int-val4"); - neu_int_val_t int_val22; - neu_int_val_init(&int_val22, 24, input_int_val22); - - /** set the second element of 2D array **/ - neu_fixed_array_t *set_int_val_array2 = - neu_fixed_array_new(2, sizeof(neu_int_val_t)); - neu_fixed_array_set(set_int_val_array2, 0, &int_val21); - neu_fixed_array_set(set_int_val_array2, 1, &int_val22); - - neu_data_val_t *array_int_val_dval2 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_val_dval2, NEU_DTYPE_INT_VAL, - set_int_val_array2); - - /** set int_val 2D array **/ - neu_fixed_array_t *set_arr_2d_int_val = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_arr_2d_int_val, 0, &array_int_val_dval1); - neu_fixed_array_set(set_arr_2d_int_val, 1, &array_int_val_dval2); - - /** serialize and deserialize return **/ - neu_fixed_array_t *get_array_int_val = - ser_deser_with_fixed_array(set_arr_2d_int_val, NEU_DTYPE_DATA_VAL); - - /** free **/ - neu_dvalue_free(input_int_val11); - neu_dvalue_free(input_int_val12); - neu_dvalue_free(input_int_val21); - neu_dvalue_free(input_int_val22); - neu_fixed_array_free(set_int_val_array1); - neu_dvalue_free(array_int_val_dval1); - neu_fixed_array_free(set_int_val_array2); - neu_dvalue_free(array_int_val_dval2); - - /* Compare **/ - comp_arr_2d_int_val(get_array_int_val); - - /** string_val **/ - /** set the first element of 1D array **/ - neu_string_t *input_str_key1 = neu_string_from_cstr((char *) "string-key1"); - neu_string_t *test_string1 = - neu_string_from_cstr((char *) "hello,string-val1"); - neu_data_val_t *input_str_dval1 = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_str_dval1, test_string1); - neu_string_val_t string_val1; - neu_string_val_init(&string_val1, input_str_key1, input_str_dval1); - - /** set the second element of 1D array **/ - neu_string_t *input_str_key2 = neu_string_from_cstr((char *) "string-key2"); - neu_string_t *test_string2 = - neu_string_from_cstr((char *) "hello,string-val2"); - neu_data_val_t *input_str_dval2 = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_str_dval2, test_string2); - neu_string_val_t string_val2; - neu_string_val_init(&string_val2, input_str_key2, input_str_dval2); - - /** set the first element of 2D array **/ - neu_fixed_array_t *set_str_val_array1 = - neu_fixed_array_new(2, sizeof(neu_string_val_t)); - neu_fixed_array_set(set_str_val_array1, 0, &string_val1); - neu_fixed_array_set(set_str_val_array1, 1, &string_val2); - - neu_data_val_t *arr_2d_str_val_dval1 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(arr_2d_str_val_dval1, NEU_DTYPE_STRING_VAL, - set_str_val_array1); - - /** set the third element of 1D array **/ - neu_string_t *input_str_key3 = neu_string_from_cstr((char *) "string-key3"); - neu_string_t *test_string3 = - neu_string_from_cstr((char *) "hello,string-val3"); - neu_data_val_t *input_str_dval3 = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_str_dval3, test_string3); - neu_string_val_t string_val3; - neu_string_val_init(&string_val3, input_str_key3, input_str_dval3); - - /** set the fourth element of 1D array **/ - neu_string_t *input_str_key4 = neu_string_from_cstr((char *) "string-key4"); - neu_string_t *test_string4 = - neu_string_from_cstr((char *) "hello,string-val4"); - neu_data_val_t *input_str_dval4 = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_str_dval4, test_string4); - neu_string_val_t string_val4; - neu_string_val_init(&string_val4, input_str_key4, input_str_dval4); - - /** set the second element of 2D array **/ - neu_fixed_array_t *set_str_val_array2 = - neu_fixed_array_new(2, sizeof(neu_string_val_t)); - neu_fixed_array_set(set_str_val_array2, 0, &string_val3); - neu_fixed_array_set(set_str_val_array2, 1, &string_val4); - - neu_data_val_t *arr_2d_str_val_dval2 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(arr_2d_str_val_dval2, NEU_DTYPE_STRING_VAL, - set_str_val_array2); - - /** set string_val 2D array **/ - neu_fixed_array_t *set_arr_2d_str_val = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_arr_2d_str_val, 0, &arr_2d_str_val_dval1); - neu_fixed_array_set(set_arr_2d_str_val, 1, &arr_2d_str_val_dval2); - - /** serialize and deserialize return **/ - neu_fixed_array_t *get_array_str_val = - ser_deser_with_fixed_array(set_arr_2d_str_val, NEU_DTYPE_DATA_VAL); - - /** free **/ - neu_string_free(input_str_key1); - neu_dvalue_free(input_str_dval1); - - neu_string_free(input_str_key2); - neu_dvalue_free(input_str_dval2); - - neu_string_free(input_str_key3); - neu_dvalue_free(input_str_dval3); - - neu_string_free(input_str_key4); - neu_dvalue_free(input_str_dval4); - - neu_fixed_array_free(set_str_val_array1); - neu_fixed_array_free(set_str_val_array2); - neu_dvalue_free(arr_2d_str_val_dval1); - neu_dvalue_free(arr_2d_str_val_dval2); - - /** Compare **/ - comp_arr_2d_str_val(get_array_str_val); - - /** cstr **/ - /** set array **/ - char *cstr1 = (char *) "Hello,cstr-test1"; - char *cstr2 = (char *) "Hello,cstr-test2"; - char *cstr3 = (char *) "Hello,cstr-test3"; - char *cstr4 = (char *) "Hello,cstr-test4"; - - neu_fixed_array_t *set_cstr_array1 = neu_fixed_array_new(2, sizeof(char *)); - neu_fixed_array_set(set_cstr_array1, 0, &cstr1); - neu_fixed_array_set(set_cstr_array1, 1, &cstr2); - neu_data_val_t *array_cstr_dval1 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_cstr_dval1, NEU_DTYPE_CSTR, - set_cstr_array1); - - neu_fixed_array_t *set_cstr_array2 = neu_fixed_array_new(2, sizeof(char *)); - neu_fixed_array_set(set_cstr_array2, 0, &cstr3); - neu_fixed_array_set(set_cstr_array2, 1, &cstr4); - neu_data_val_t *array_cstr_dval2 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_cstr_dval2, NEU_DTYPE_CSTR, - set_cstr_array2); - - neu_fixed_array_t *set_cstr_array = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_cstr_array, 0, &array_cstr_dval1); - neu_fixed_array_set(set_cstr_array, 1, &array_cstr_dval2); - - /** serialize and deserialize return **/ - neu_fixed_array_t *get_cstr_array = - ser_deser_with_fixed_array(set_cstr_array, NEU_DTYPE_DATA_VAL); - - /** Compare the first element of 2D array **/ - neu_data_val_t *get_array_dval1 = - *(neu_data_val_t **) neu_fixed_array_get(get_cstr_array, 0); - neu_fixed_array_t *get_array1 = NULL; - neu_dvalue_get_move_array(get_array_dval1, &get_array1); - char *get_cstr1 = *(char **) neu_fixed_array_get(get_array1, 0); - EXPECT_STREQ((char *) "Hello,cstr-test1", get_cstr1); - char *get_cstr2 = *(char **) neu_fixed_array_get(get_array1, 1); - EXPECT_STREQ((char *) "Hello,cstr-test2", get_cstr2); - neu_fixed_array_free(get_array1); - neu_dvalue_free(get_array_dval1); - free(get_cstr1); - free(get_cstr2); - - /** Compare the second element of 2D array **/ - neu_data_val_t *get_array_dval2 = - *(neu_data_val_t **) neu_fixed_array_get(get_cstr_array, 1); - neu_fixed_array_t *get_array2 = NULL; - neu_dvalue_get_move_array(get_array_dval2, &get_array2); - char *get_cstr3 = *(char **) neu_fixed_array_get(get_array2, 0); - EXPECT_STREQ((char *) "Hello,cstr-test3", get_cstr3); - char *get_cstr4 = *(char **) neu_fixed_array_get(get_array2, 1); - EXPECT_STREQ((char *) "Hello,cstr-test4", get_cstr4); - neu_fixed_array_free(get_array2); - neu_dvalue_free(get_array_dval2); - free(get_cstr3); - free(get_cstr4); - - neu_fixed_array_free(get_cstr_array); - - /** free **/ - neu_fixed_array_free(set_cstr_array1); - neu_fixed_array_free(set_cstr_array2); - - neu_dvalue_free(array_cstr_dval1); - neu_dvalue_free(array_cstr_dval2); -} - -void comp_arr_3d_int(neu_fixed_array_t *get_array_int) -{ - /** Get the first element of the 3D array **/ - neu_data_val_t *get_array_dval1 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_int, 0); - neu_fixed_array_t *get_array1 = NULL; - neu_dvalue_get_move_array(get_array_dval1, &get_array1); - - /** Get the first element of the first 2D array **/ - neu_data_val_t *get_array_dval11 = - *(neu_data_val_t **) neu_fixed_array_get(get_array1, 0); - neu_fixed_array_t *get_array11 = NULL; - neu_dvalue_get_move_array(get_array_dval11, &get_array11); - int64_t *int_get111 = (int64_t *) neu_fixed_array_get(get_array11, 0); - EXPECT_EQ(1, *int_get111); - int64_t *int_get112 = (int64_t *) neu_fixed_array_get(get_array11, 1); - EXPECT_EQ(2, *int_get112); - int64_t *int_get113 = (int64_t *) neu_fixed_array_get(get_array11, 2); - EXPECT_EQ(3, *int_get113); - neu_fixed_array_free(get_array11); - neu_dvalue_free(get_array_dval11); - - /** Get the second element of the first 2D array **/ - neu_data_val_t *get_array_dval12 = - *(neu_data_val_t **) neu_fixed_array_get(get_array1, 1); - neu_fixed_array_t *get_array12 = NULL; - neu_dvalue_get_move_array(get_array_dval12, &get_array12); - int64_t *int_get121 = (int64_t *) neu_fixed_array_get(get_array12, 0); - EXPECT_EQ(11, *int_get121); - int64_t *int_get122 = (int64_t *) neu_fixed_array_get(get_array12, 1); - EXPECT_EQ(22, *int_get122); - int64_t *int_get123 = (int64_t *) neu_fixed_array_get(get_array12, 2); - EXPECT_EQ(33, *int_get123); - neu_fixed_array_free(get_array12); - neu_dvalue_free(get_array_dval12); - - neu_fixed_array_free(get_array1); - neu_dvalue_free(get_array_dval1); - - /** Get the second element of the 3D array **/ - neu_data_val_t *get_array_dval2 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_int, 1); - neu_fixed_array_t *get_array2 = NULL; - neu_dvalue_get_move_array(get_array_dval2, &get_array2); - - /** Get the first element of the second 2D array **/ - neu_data_val_t *get_array_dval21 = - *(neu_data_val_t **) neu_fixed_array_get(get_array2, 0); - neu_fixed_array_t *get_array21 = NULL; - neu_dvalue_get_move_array(get_array_dval21, &get_array21); - int64_t *int_get311 = (int64_t *) neu_fixed_array_get(get_array21, 0); - EXPECT_EQ(5, *int_get311); - int64_t *int_get312 = (int64_t *) neu_fixed_array_get(get_array21, 1); - EXPECT_EQ(6, *int_get312); - int64_t *int_get313 = (int64_t *) neu_fixed_array_get(get_array21, 2); - EXPECT_EQ(7, *int_get313); - neu_fixed_array_free(get_array21); - neu_dvalue_free(get_array_dval21); - - /** Get the second element of the second 2D array **/ - neu_data_val_t *get_array_dval22 = - *(neu_data_val_t **) neu_fixed_array_get(get_array2, 1); - neu_fixed_array_t *get_array22 = NULL; - neu_dvalue_get_move_array(get_array_dval22, &get_array22); - int64_t *int_get321 = (int64_t *) neu_fixed_array_get(get_array22, 0); - EXPECT_EQ(55, *int_get321); - int64_t *int_get322 = (int64_t *) neu_fixed_array_get(get_array22, 1); - EXPECT_EQ(66, *int_get322); - int64_t *int_get323 = (int64_t *) neu_fixed_array_get(get_array22, 2); - EXPECT_EQ(77, *int_get323); - neu_fixed_array_free(get_array22); - neu_dvalue_free(get_array_dval22); - - neu_fixed_array_free(get_array2); - neu_dvalue_free(get_array_dval2); - - neu_fixed_array_free(get_array_int); -} - -void comp_arr_3d_double(neu_fixed_array_t *get_array_double) -{ - /** Get the first element of the 3D array **/ - neu_data_val_t *get_array_dval1 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_double, 0); - neu_fixed_array_t *get_array1 = NULL; - neu_dvalue_get_move_array(get_array_dval1, &get_array1); - - /** Get the first element of the first 2D array **/ - neu_data_val_t *get_array_dval11 = - *(neu_data_val_t **) neu_fixed_array_get(get_array1, 0); - neu_fixed_array_t *get_array11 = NULL; - neu_dvalue_get_move_array(get_array_dval11, &get_array11); - double *get_double111 = (double *) neu_fixed_array_get(get_array11, 0); - EXPECT_EQ(0.11, *get_double111); - double *get_double112 = (double *) neu_fixed_array_get(get_array11, 1); - EXPECT_EQ(0.22, *get_double112); - double *get_double113 = (double *) neu_fixed_array_get(get_array11, 2); - EXPECT_EQ(0.33, *get_double113); - neu_fixed_array_free(get_array11); - neu_dvalue_free(get_array_dval11); - - /** Get the second element of the first 2D array **/ - neu_data_val_t *get_array_dval12 = - *(neu_data_val_t **) neu_fixed_array_get(get_array1, 1); - neu_fixed_array_t *get_array12 = NULL; - neu_dvalue_get_move_array(get_array_dval12, &get_array12); - double *get_double121 = (double *) neu_fixed_array_get(get_array12, 0); - EXPECT_EQ(0.111, *get_double121); - double *get_double122 = (double *) neu_fixed_array_get(get_array12, 1); - EXPECT_EQ(0.222, *get_double122); - double *get_double123 = (double *) neu_fixed_array_get(get_array12, 2); - EXPECT_EQ(0.333, *get_double123); - neu_fixed_array_free(get_array12); - neu_dvalue_free(get_array_dval12); - - neu_fixed_array_free(get_array1); - neu_dvalue_free(get_array_dval1); - - /** Get the second element of the 3D array **/ - neu_data_val_t *get_array_dval2 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_double, 1); - neu_fixed_array_t *get_array2 = NULL; - neu_dvalue_get_move_array(get_array_dval2, &get_array2); - - /** Get the first element of the second 2D array **/ - neu_data_val_t *get_array_dval21 = - *(neu_data_val_t **) neu_fixed_array_get(get_array2, 0); - neu_fixed_array_t *get_array21 = NULL; - neu_dvalue_get_move_array(get_array_dval21, &get_array21); - double *get_double311 = (double *) neu_fixed_array_get(get_array21, 0); - EXPECT_EQ(0.55, *get_double311); - double *get_double312 = (double *) neu_fixed_array_get(get_array21, 1); - EXPECT_EQ(0.66, *get_double312); - double *get_double313 = (double *) neu_fixed_array_get(get_array21, 2); - EXPECT_EQ(0.77, *get_double313); - neu_fixed_array_free(get_array21); - neu_dvalue_free(get_array_dval21); - - /** Get the second element of the second 2D array **/ - neu_data_val_t *get_array_dval22 = - *(neu_data_val_t **) neu_fixed_array_get(get_array2, 1); - neu_fixed_array_t *get_array22 = NULL; - neu_dvalue_get_move_array(get_array_dval22, &get_array22); - double *get_double321 = (double *) neu_fixed_array_get(get_array22, 0); - EXPECT_EQ(0.555, *get_double321); - double *get_double322 = (double *) neu_fixed_array_get(get_array22, 1); - EXPECT_EQ(0.666, *get_double322); - double *get_double323 = (double *) neu_fixed_array_get(get_array22, 2); - EXPECT_EQ(0.777, *get_double323); - neu_fixed_array_free(get_array22); - neu_dvalue_free(get_array_dval22); - - neu_fixed_array_free(get_array2); - neu_dvalue_free(get_array_dval2); - - neu_fixed_array_free(get_array_double); -} - -void comp_arr_3d_cstr(neu_fixed_array_t *get_array_cstr) -{ - /** Get the first element of the 3D array **/ - neu_data_val_t *get_array_dval1 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_cstr, 0); - neu_fixed_array_t *get_array1 = NULL; - neu_dvalue_get_move_array(get_array_dval1, &get_array1); - - /** Get the first element of the first 2D array **/ - neu_data_val_t *get_array_dval11 = - *(neu_data_val_t **) neu_fixed_array_get(get_array1, 0); - neu_fixed_array_t *get_array11 = NULL; - neu_dvalue_get_move_array(get_array_dval11, &get_array11); - char *get_cstr111 = *(char **) neu_fixed_array_get(get_array11, 0); - EXPECT_STREQ((char *) "Hello,cstr-test1", get_cstr111); - char *get_cstr112 = *(char **) neu_fixed_array_get(get_array11, 1); - EXPECT_STREQ((char *) "Hello,cstr-test2", get_cstr112); - neu_fixed_array_free(get_array11); - neu_dvalue_free(get_array_dval11); - free(get_cstr111); - free(get_cstr112); - - /** Get the second element of the first 2D array **/ - neu_data_val_t *get_array_dval12 = - *(neu_data_val_t **) neu_fixed_array_get(get_array1, 1); - neu_fixed_array_t *get_array12 = NULL; - neu_dvalue_get_move_array(get_array_dval12, &get_array12); - char *get_cstr121 = *(char **) neu_fixed_array_get(get_array12, 0); - EXPECT_STREQ((char *) "Hello,cstr-test3", get_cstr121); - char *get_cstr122 = *(char **) neu_fixed_array_get(get_array12, 1); - EXPECT_STREQ((char *) "Hello,cstr-test4", get_cstr122); - neu_fixed_array_free(get_array12); - neu_dvalue_free(get_array_dval12); - free(get_cstr121); - free(get_cstr122); - - neu_fixed_array_free(get_array1); - neu_dvalue_free(get_array_dval1); - - /** Get the second element of the 3D array **/ - neu_data_val_t *get_array_dval2 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_cstr, 1); - neu_fixed_array_t *get_array2 = NULL; - neu_dvalue_get_move_array(get_array_dval2, &get_array2); - - /** Get the first element of the second 2D array **/ - neu_data_val_t *get_array_dval21 = - *(neu_data_val_t **) neu_fixed_array_get(get_array2, 0); - neu_fixed_array_t *get_array21 = NULL; - neu_dvalue_get_move_array(get_array_dval21, &get_array21); - char *get_cstr311 = *(char **) neu_fixed_array_get(get_array21, 0); - EXPECT_STREQ((char *) "Hello,cstr-test5", get_cstr311); - char *get_cstr312 = *(char **) neu_fixed_array_get(get_array21, 1); - EXPECT_STREQ((char *) "Hello,cstr-test6", get_cstr312); - neu_fixed_array_free(get_array21); - neu_dvalue_free(get_array_dval21); - free(get_cstr311); - free(get_cstr312); - - /** Get the second element of the second 2D array **/ - neu_data_val_t *get_array_dval22 = - *(neu_data_val_t **) neu_fixed_array_get(get_array2, 1); - neu_fixed_array_t *get_array22 = NULL; - neu_dvalue_get_move_array(get_array_dval22, &get_array22); - char *get_cstr321 = *(char **) neu_fixed_array_get(get_array22, 0); - EXPECT_STREQ((char *) "Hello,cstr-test7", get_cstr321); - char *get_cstr322 = *(char **) neu_fixed_array_get(get_array22, 1); - EXPECT_STREQ((char *) "Hello,cstr-test8", get_cstr322); - neu_fixed_array_free(get_array22); - neu_dvalue_free(get_array_dval22); - free(get_cstr321); - free(get_cstr322); - - neu_fixed_array_free(get_array2); - neu_dvalue_free(get_array_dval2); - - neu_fixed_array_free(get_array_cstr); -} - -void comp_arr_3d_int_val(neu_fixed_array_t *get_array_int_val) -{ - /** Get the first 2D array1 within 3D array **/ - neu_data_val_t *get_array_dval1 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_int_val, 0); - neu_fixed_array_t *get_array1 = NULL; - neu_dvalue_get_move_array(get_array_dval1, &get_array1); - - /** Get the first 1D array11 within the first 2D array1 **/ - neu_data_val_t *get_array_dval11 = - *(neu_data_val_t **) neu_fixed_array_get(get_array1, 0); - neu_fixed_array_t *get_array11 = NULL; - neu_dvalue_get_move_array(get_array_dval11, &get_array11); - - /** Compare the first element of the first 1D array11 **/ - neu_int_val_t *get_int_val111 = - (neu_int_val_t *) neu_fixed_array_get(get_array11, 0); - EXPECT_EQ(111, get_int_val111->key); - char *output_val111 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val111->val, &output_val111)); - EXPECT_STREQ((char *) "hello,int-val1", output_val111); - neu_int_val_uninit(get_int_val111); - - /** Compare the second element of the first 1D array11 **/ - neu_int_val_t *get_int_val112 = - (neu_int_val_t *) neu_fixed_array_get(get_array11, 1); - EXPECT_EQ(112, get_int_val112->key); - char *output_val112 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val112->val, &output_val112)); - EXPECT_STREQ((char *) "hello,int-val2", output_val112); - neu_int_val_uninit(get_int_val112); - - neu_fixed_array_free(get_array11); - neu_dvalue_free(get_array_dval11); - - /** Get the second 1D array12 within the first 2D array1 **/ - neu_data_val_t *get_array_dval12 = - *(neu_data_val_t **) neu_fixed_array_get(get_array1, 1); - neu_fixed_array_t *get_array12 = NULL; - neu_dvalue_get_move_array(get_array_dval12, &get_array12); - - /** Compare the first element of the first 1D array12 **/ - neu_int_val_t *get_int_val121 = - (neu_int_val_t *) neu_fixed_array_get(get_array12, 0); - EXPECT_EQ(121, get_int_val121->key); - char *output_val121 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val121->val, &output_val121)); - EXPECT_STREQ((char *) "hello,int-val3", output_val121); - neu_int_val_uninit(get_int_val121); - - /** Compare the second element of the first 1D array12 **/ - neu_int_val_t *get_int_val122 = - (neu_int_val_t *) neu_fixed_array_get(get_array12, 1); - EXPECT_EQ(122, get_int_val122->key); - char *output_val122 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val122->val, &output_val122)); - EXPECT_STREQ((char *) "hello,int-val4", output_val122); - neu_int_val_uninit(get_int_val122); - - neu_fixed_array_free(get_array12); - neu_dvalue_free(get_array_dval12); - - neu_fixed_array_free(get_array1); - neu_dvalue_free(get_array_dval1); - - /** Get the second 2D array2 within 3D array **/ - neu_data_val_t *get_array_dval2 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_int_val, 1); - neu_fixed_array_t *get_array2 = NULL; - neu_dvalue_get_move_array(get_array_dval2, &get_array2); - - /** Get the first 1D array21 within the second 2D array2 **/ - neu_data_val_t *get_array_dval21 = - *(neu_data_val_t **) neu_fixed_array_get(get_array2, 0); - neu_fixed_array_t *get_array21 = NULL; - neu_dvalue_get_move_array(get_array_dval21, &get_array21); - - /** Compare the first element of the first 1D array21 **/ - neu_int_val_t *get_int_val211 = - (neu_int_val_t *) neu_fixed_array_get(get_array21, 0); - EXPECT_EQ(211, get_int_val211->key); - char *output_val211 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val211->val, &output_val211)); - EXPECT_STREQ((char *) "hello,int-val5", output_val211); - neu_int_val_uninit(get_int_val211); - - /** Compare the second element of the first 1D array21 **/ - neu_int_val_t *get_int_val212 = - (neu_int_val_t *) neu_fixed_array_get(get_array21, 1); - EXPECT_EQ(212, get_int_val212->key); - char *output_val212 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val212->val, &output_val212)); - EXPECT_STREQ((char *) "hello,int-val6", output_val212); - neu_int_val_uninit(get_int_val212); - - neu_fixed_array_free(get_array21); - neu_dvalue_free(get_array_dval21); - - /** Get the second 1D array22 within the second 2D array2 **/ - neu_data_val_t *get_array_dval22 = - *(neu_data_val_t **) neu_fixed_array_get(get_array2, 1); - neu_fixed_array_t *get_array22 = NULL; - neu_dvalue_get_move_array(get_array_dval22, &get_array22); - - /** Compare the first element of the first 1D array22 **/ - neu_int_val_t *get_int_val221 = - (neu_int_val_t *) neu_fixed_array_get(get_array22, 0); - EXPECT_EQ(221, get_int_val221->key); - char *output_val221 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val221->val, &output_val221)); - EXPECT_STREQ((char *) "hello,int-val7", output_val221); - neu_int_val_uninit(get_int_val221); - - /** Compare the second element of the first 1D array22 **/ - neu_int_val_t *get_int_val222 = - (neu_int_val_t *) neu_fixed_array_get(get_array22, 1); - EXPECT_EQ(222, get_int_val222->key); - char *output_val222 = NULL; - EXPECT_EQ(0, neu_dvalue_get_ref_cstr(get_int_val222->val, &output_val222)); - EXPECT_STREQ((char *) "hello,int-val8", output_val222); - neu_int_val_uninit(get_int_val222); - - neu_fixed_array_free(get_array22); - neu_dvalue_free(get_array_dval22); - - neu_fixed_array_free(get_array2); - neu_dvalue_free(get_array_dval2); - - neu_fixed_array_free(get_array_int_val); -} - -void comp_arr_3d_str_val(neu_fixed_array_t *get_array_str_val) -{ - /** Get the first 2D array1 within 3D array **/ - neu_data_val_t *get_array_dval1 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_str_val, 0); - neu_fixed_array_t *get_array1 = NULL; - neu_dvalue_get_move_array(get_array_dval1, &get_array1); - - /** Get the first 1D array11 within the first 2D array1 **/ - neu_data_val_t *get_array_dval11 = - *(neu_data_val_t **) neu_fixed_array_get(get_array1, 0); - neu_fixed_array_t *get_array11 = NULL; - neu_dvalue_get_move_array(get_array_dval11, &get_array11); - - /** Compare the first element of the first 1D array11 **/ - neu_string_val_t *get_str_val111 = - (neu_string_val_t *) neu_fixed_array_get(get_array11, 0); - EXPECT_STREQ((char *) "string-key1", - neu_string_get_ref_cstr(get_str_val111->key)); - neu_string_t *get_string111 = NULL; - EXPECT_EQ(0, - neu_dvalue_get_ref_string(get_str_val111->val, &get_string111)); - EXPECT_STREQ((char *) "hello,string-val1", - neu_string_get_ref_cstr(get_string111)); - neu_string_val_uninit(get_str_val111); - - /** Compare the second element of the first 1D array11 **/ - neu_string_val_t *get_str_val112 = - (neu_string_val_t *) neu_fixed_array_get(get_array11, 1); - EXPECT_STREQ((char *) "string-key2", - neu_string_get_ref_cstr(get_str_val112->key)); - neu_string_t *get_string112 = NULL; - EXPECT_EQ(0, - neu_dvalue_get_ref_string(get_str_val112->val, &get_string112)); - EXPECT_STREQ((char *) "hello,string-val2", - neu_string_get_ref_cstr(get_string112)); - neu_string_val_uninit(get_str_val112); - - neu_fixed_array_free(get_array11); - neu_dvalue_free(get_array_dval11); - - /** Get the second 1D array12 within the first 2D array1 **/ - neu_data_val_t *get_array_dval12 = - *(neu_data_val_t **) neu_fixed_array_get(get_array1, 1); - neu_fixed_array_t *get_array12 = NULL; - neu_dvalue_get_move_array(get_array_dval12, &get_array12); - - /** Compare the first element of the first 1D array12 **/ - neu_string_val_t *get_str_val121 = - (neu_string_val_t *) neu_fixed_array_get(get_array12, 0); - EXPECT_STREQ((char *) "string-key3", - neu_string_get_ref_cstr(get_str_val121->key)); - neu_string_t *get_string121 = NULL; - EXPECT_EQ(0, - neu_dvalue_get_ref_string(get_str_val121->val, &get_string121)); - EXPECT_STREQ((char *) "hello,string-val3", - neu_string_get_ref_cstr(get_string121)); - neu_string_val_uninit(get_str_val121); - - /** Compare the second element of the first 1D array12 **/ - neu_string_val_t *get_str_val122 = - (neu_string_val_t *) neu_fixed_array_get(get_array12, 1); - EXPECT_STREQ((char *) "string-key4", - neu_string_get_ref_cstr(get_str_val122->key)); - neu_string_t *get_string122 = NULL; - EXPECT_EQ(0, - neu_dvalue_get_ref_string(get_str_val122->val, &get_string122)); - EXPECT_STREQ((char *) "hello,string-val4", - neu_string_get_ref_cstr(get_string122)); - neu_string_val_uninit(get_str_val122); - - neu_fixed_array_free(get_array12); - neu_dvalue_free(get_array_dval12); - - neu_fixed_array_free(get_array1); - neu_dvalue_free(get_array_dval1); - - /** Get the second 2D array2 within 3D array **/ - neu_data_val_t *get_array_dval2 = - *(neu_data_val_t **) neu_fixed_array_get(get_array_str_val, 1); - neu_fixed_array_t *get_array2 = NULL; - neu_dvalue_get_move_array(get_array_dval2, &get_array2); - - /** Get the first 1D array21 within the second 2D array2 **/ - neu_data_val_t *get_array_dval21 = - *(neu_data_val_t **) neu_fixed_array_get(get_array2, 0); - neu_fixed_array_t *get_array21 = NULL; - neu_dvalue_get_move_array(get_array_dval21, &get_array21); - - /** Compare the first element of the first 1D array21 **/ - neu_string_val_t *get_str_val211 = - (neu_string_val_t *) neu_fixed_array_get(get_array21, 0); - EXPECT_STREQ((char *) "string-key5", - neu_string_get_ref_cstr(get_str_val211->key)); - neu_string_t *get_string211 = NULL; - EXPECT_EQ(0, - neu_dvalue_get_ref_string(get_str_val211->val, &get_string211)); - EXPECT_STREQ((char *) "hello,string-val5", - neu_string_get_ref_cstr(get_string211)); - neu_string_val_uninit(get_str_val211); - - /** Compare the second element of the first 1D array21 **/ - neu_string_val_t *get_str_val212 = - (neu_string_val_t *) neu_fixed_array_get(get_array21, 1); - EXPECT_STREQ((char *) "string-key6", - neu_string_get_ref_cstr(get_str_val212->key)); - neu_string_t *get_string212 = NULL; - EXPECT_EQ(0, - neu_dvalue_get_ref_string(get_str_val212->val, &get_string212)); - EXPECT_STREQ((char *) "hello,string-val6", - neu_string_get_ref_cstr(get_string212)); - neu_string_val_uninit(get_str_val212); - - neu_fixed_array_free(get_array21); - neu_dvalue_free(get_array_dval21); - - /** Get the second 1D array22 within the second 2D array2 **/ - neu_data_val_t *get_array_dval22 = - *(neu_data_val_t **) neu_fixed_array_get(get_array2, 1); - neu_fixed_array_t *get_array22 = NULL; - neu_dvalue_get_move_array(get_array_dval22, &get_array22); - - /** Compare the first element of the first 1D array22 **/ - neu_string_val_t *get_str_val221 = - (neu_string_val_t *) neu_fixed_array_get(get_array22, 0); - EXPECT_STREQ((char *) "string-key7", - neu_string_get_ref_cstr(get_str_val221->key)); - neu_string_t *get_string221 = NULL; - EXPECT_EQ(0, - neu_dvalue_get_ref_string(get_str_val221->val, &get_string221)); - EXPECT_STREQ((char *) "hello,string-val7", - neu_string_get_ref_cstr(get_string221)); - neu_string_val_uninit(get_str_val221); - - /** Compare the second element of the first 1D array22 **/ - neu_string_val_t *get_str_val222 = - (neu_string_val_t *) neu_fixed_array_get(get_array22, 1); - EXPECT_STREQ((char *) "string-key8", - neu_string_get_ref_cstr(get_str_val222->key)); - neu_string_t *get_string222 = NULL; - EXPECT_EQ(0, - neu_dvalue_get_ref_string(get_str_val222->val, &get_string222)); - EXPECT_STREQ((char *) "hello,string-val8", - neu_string_get_ref_cstr(get_string222)); - neu_string_val_uninit(get_str_val222); - - neu_fixed_array_free(get_array22); - neu_dvalue_free(get_array_dval22); - - neu_fixed_array_free(get_array2); - neu_dvalue_free(get_array_dval2); - - neu_fixed_array_free(get_array_str_val); -} - -TEST(DataValuTest, neu_dvalue_3D_array_deser) -{ - /** int64 **/ - int64_t i64_arr[2][2][3] = { { { 1, 2, 3 }, { 11, 22, 33 } }, - { { 5, 6, 7 }, { 55, 66, 77 } } }; - - neu_fixed_array_t *set_array_int11 = - neu_fixed_array_new(3, sizeof(int64_t)); - neu_fixed_array_set(set_array_int11, 0, &i64_arr[0][0][0]); - neu_fixed_array_set(set_array_int11, 1, &i64_arr[0][0][1]); - neu_fixed_array_set(set_array_int11, 2, &i64_arr[0][0][2]); - neu_fixed_array_t *set_array_int12 = - neu_fixed_array_new(3, sizeof(int64_t)); - neu_fixed_array_set(set_array_int12, 0, &i64_arr[0][1][0]); - neu_fixed_array_set(set_array_int12, 1, &i64_arr[0][1][1]); - neu_fixed_array_set(set_array_int12, 2, &i64_arr[0][1][2]); - neu_fixed_array_t *set_array_int21 = - neu_fixed_array_new(3, sizeof(int64_t)); - neu_fixed_array_set(set_array_int21, 0, &i64_arr[1][0][0]); - neu_fixed_array_set(set_array_int21, 1, &i64_arr[1][0][1]); - neu_fixed_array_set(set_array_int21, 2, &i64_arr[1][0][2]); - neu_fixed_array_t *set_array_int22 = - neu_fixed_array_new(3, sizeof(int64_t)); - neu_fixed_array_set(set_array_int22, 0, &i64_arr[1][1][0]); - neu_fixed_array_set(set_array_int22, 1, &i64_arr[1][1][1]); - neu_fixed_array_set(set_array_int22, 2, &i64_arr[1][1][2]); - - neu_data_val_t *array_int_dval11 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_dval11, NEU_DTYPE_INT64, - set_array_int11); - neu_data_val_t *array_int_dval12 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_dval12, NEU_DTYPE_INT64, - set_array_int12); - neu_data_val_t *array_int_dval21 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_dval21, NEU_DTYPE_INT64, - set_array_int21); - neu_data_val_t *array_int_dval22 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_dval22, NEU_DTYPE_INT64, - set_array_int22); - - neu_fixed_array_t *set_array1 = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_array1, 0, &array_int_dval11); - neu_fixed_array_set(set_array1, 1, &array_int_dval12); - neu_fixed_array_t *set_array2 = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_array2, 0, &array_int_dval21); - neu_fixed_array_set(set_array2, 1, &array_int_dval22); - - neu_data_val_t *array_int_dval1 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_dval1, NEU_DTYPE_DATA_VAL, set_array1); - neu_data_val_t *array_int_dval2 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_dval2, NEU_DTYPE_DATA_VAL, set_array2); - - neu_fixed_array_t *set_array_3d = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_array_3d, 0, &array_int_dval1); - neu_fixed_array_set(set_array_3d, 1, &array_int_dval2); - - /** serialize and deserialize return **/ - neu_fixed_array_t *get_array_int = - ser_deser_with_fixed_array(set_array_3d, NEU_DTYPE_DATA_VAL); - - /** free **/ - neu_fixed_array_free(set_array_int11); - neu_fixed_array_free(set_array_int12); - neu_fixed_array_free(set_array_int21); - neu_fixed_array_free(set_array_int22); - - neu_dvalue_free(array_int_dval11); - neu_dvalue_free(array_int_dval12); - neu_dvalue_free(array_int_dval21); - neu_dvalue_free(array_int_dval22); - - neu_fixed_array_free(set_array1); - neu_fixed_array_free(set_array2); - - neu_dvalue_free(array_int_dval1); - neu_dvalue_free(array_int_dval2); - - /** Compare **/ - comp_arr_3d_int(get_array_int); - - /** double **/ - /** set array **/ - double double_arr[2][2][3] = { - { { 0.11, 0.22, 0.33 }, { 0.111, 0.222, 0.333 } }, - { { 0.55, 0.66, 0.77 }, { 0.555, 0.666, 0.777 } } - }; - neu_fixed_array_t *set_array_double11 = - neu_fixed_array_new(3, sizeof(double)); - neu_fixed_array_set(set_array_double11, 0, &double_arr[0][0][0]); - neu_fixed_array_set(set_array_double11, 1, &double_arr[0][0][1]); - neu_fixed_array_set(set_array_double11, 2, &double_arr[0][0][2]); - neu_data_val_t *array_double_dval11 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_double_dval11, NEU_DTYPE_DOUBLE, - set_array_double11); - - neu_fixed_array_t *set_array_double12 = - neu_fixed_array_new(3, sizeof(double)); - neu_fixed_array_set(set_array_double12, 0, &double_arr[0][1][0]); - neu_fixed_array_set(set_array_double12, 1, &double_arr[0][1][1]); - neu_fixed_array_set(set_array_double12, 2, &double_arr[0][1][2]); - neu_data_val_t *array_double_dval12 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_double_dval12, NEU_DTYPE_DOUBLE, - set_array_double12); - - neu_fixed_array_t *set_array_double21 = - neu_fixed_array_new(3, sizeof(double)); - neu_fixed_array_set(set_array_double21, 0, &double_arr[1][0][0]); - neu_fixed_array_set(set_array_double21, 1, &double_arr[1][0][1]); - neu_fixed_array_set(set_array_double21, 2, &double_arr[1][0][2]); - neu_data_val_t *array_double_dval21 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_double_dval21, NEU_DTYPE_DOUBLE, - set_array_double21); - - neu_fixed_array_t *set_array_double22 = - neu_fixed_array_new(3, sizeof(double)); - neu_fixed_array_set(set_array_double22, 0, &double_arr[1][1][0]); - neu_fixed_array_set(set_array_double22, 1, &double_arr[1][1][1]); - neu_fixed_array_set(set_array_double22, 2, &double_arr[1][1][2]); - neu_data_val_t *array_double_dval22 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_double_dval22, NEU_DTYPE_DOUBLE, - set_array_double22); - - neu_fixed_array_t *set_array_double1 = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_array_double1, 0, &array_double_dval11); - neu_fixed_array_set(set_array_double1, 1, &array_double_dval12); - neu_data_val_t *array_double_dval1 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_double_dval1, NEU_DTYPE_DATA_VAL, - set_array_double1); - - neu_fixed_array_t *set_array_double2 = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_array_double2, 0, &array_double_dval21); - neu_fixed_array_set(set_array_double2, 1, &array_double_dval22); - neu_data_val_t *array_double_dval2 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_double_dval2, NEU_DTYPE_DATA_VAL, - set_array_double2); - - neu_fixed_array_t *set_array_double = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_array_double, 0, &array_double_dval1); - neu_fixed_array_set(set_array_double, 1, &array_double_dval2); - - /** serialize and deserialize return **/ - neu_fixed_array_t *get_array_double = - ser_deser_with_fixed_array(set_array_double, NEU_DTYPE_DATA_VAL); - - /** free **/ - neu_fixed_array_free(set_array_double11); - neu_fixed_array_free(set_array_double12); - neu_fixed_array_free(set_array_double21); - neu_fixed_array_free(set_array_double22); - - neu_dvalue_free(array_double_dval11); - neu_dvalue_free(array_double_dval12); - neu_dvalue_free(array_double_dval21); - neu_dvalue_free(array_double_dval22); - - neu_fixed_array_free(set_array_double1); - neu_fixed_array_free(set_array_double2); - - neu_dvalue_free(array_double_dval1); - neu_dvalue_free(array_double_dval2); - - /** Compare **/ - comp_arr_3d_double(get_array_double); - - /** cstr **/ - /** set array **/ - char *cstr1 = (char *) "Hello,cstr-test1"; - char *cstr2 = (char *) "Hello,cstr-test2"; - char *cstr3 = (char *) "Hello,cstr-test3"; - char *cstr4 = (char *) "Hello,cstr-test4"; - char *cstr5 = (char *) "Hello,cstr-test5"; - char *cstr6 = (char *) "Hello,cstr-test6"; - char *cstr7 = (char *) "Hello,cstr-test7"; - char *cstr8 = (char *) "Hello,cstr-test8"; - - neu_fixed_array_t *set_array_cstr11 = - neu_fixed_array_new(2, sizeof(char *)); - neu_fixed_array_set(set_array_cstr11, 0, &cstr1); - neu_fixed_array_set(set_array_cstr11, 1, &cstr2); - neu_data_val_t *array_cstr_dval11 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_cstr_dval11, NEU_DTYPE_CSTR, - set_array_cstr11); - - neu_fixed_array_t *set_array_cstr12 = - neu_fixed_array_new(2, sizeof(char *)); - neu_fixed_array_set(set_array_cstr12, 0, &cstr3); - neu_fixed_array_set(set_array_cstr12, 1, &cstr4); - neu_data_val_t *array_cstr_dval12 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_cstr_dval12, NEU_DTYPE_CSTR, - set_array_cstr12); - - neu_fixed_array_t *set_array_cstr21 = - neu_fixed_array_new(2, sizeof(char *)); - neu_fixed_array_set(set_array_cstr21, 0, &cstr5); - neu_fixed_array_set(set_array_cstr21, 1, &cstr6); - neu_data_val_t *array_cstr_dval21 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_cstr_dval21, NEU_DTYPE_CSTR, - set_array_cstr21); - - neu_fixed_array_t *set_array_cstr22 = - neu_fixed_array_new(2, sizeof(char *)); - neu_fixed_array_set(set_array_cstr22, 0, &cstr7); - neu_fixed_array_set(set_array_cstr22, 1, &cstr8); - neu_data_val_t *array_cstr_dval22 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_cstr_dval22, NEU_DTYPE_CSTR, - set_array_cstr22); - - neu_fixed_array_t *set_array_cstr1 = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_array_cstr1, 0, &array_cstr_dval11); - neu_fixed_array_set(set_array_cstr1, 1, &array_cstr_dval12); - neu_data_val_t *array_cstr_dval1 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_cstr_dval1, NEU_DTYPE_DATA_VAL, - set_array_cstr1); - - neu_fixed_array_t *set_array_cstr2 = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_array_cstr2, 0, &array_cstr_dval21); - neu_fixed_array_set(set_array_cstr2, 1, &array_cstr_dval22); - neu_data_val_t *array_cstr_dval2 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_cstr_dval2, NEU_DTYPE_DATA_VAL, - set_array_cstr2); - - neu_fixed_array_t *set_array_cstr = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_array_cstr, 0, &array_cstr_dval1); - neu_fixed_array_set(set_array_cstr, 1, &array_cstr_dval2); - - /** serialize and deserialize return **/ - neu_fixed_array_t *get_array_cstr = - ser_deser_with_fixed_array(set_array_cstr, NEU_DTYPE_DATA_VAL); - - /** Compare **/ - comp_arr_3d_cstr(get_array_cstr); - - /** free **/ - neu_fixed_array_free(set_array_cstr11); - neu_fixed_array_free(set_array_cstr12); - neu_fixed_array_free(set_array_cstr21); - neu_fixed_array_free(set_array_cstr22); - - neu_dvalue_free(array_cstr_dval11); - neu_dvalue_free(array_cstr_dval12); - neu_dvalue_free(array_cstr_dval21); - neu_dvalue_free(array_cstr_dval22); - - neu_fixed_array_free(set_array_cstr1); - neu_fixed_array_free(set_array_cstr2); - - neu_dvalue_free(array_cstr_dval1); - neu_dvalue_free(array_cstr_dval2); - - /** int_val **/ - /** the fist element of 1D array **/ - neu_data_val_t *input_int_val111 = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_int_val111, (char *) "hello,int-val1"); - neu_int_val_t int_val111; - neu_int_val_init(&int_val111, 111, input_int_val111); - - /** the second element of 1D array **/ - neu_data_val_t *input_int_val112 = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_int_val112, (char *) "hello,int-val2"); - neu_int_val_t int_val112; - neu_int_val_init(&int_val112, 112, input_int_val112); - - /** the third element of 1D array **/ - neu_data_val_t *input_int_val121 = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_int_val121, (char *) "hello,int-val3"); - neu_int_val_t int_val121; - neu_int_val_init(&int_val121, 121, input_int_val121); - - /** the fourth element of 1D array **/ - neu_data_val_t *input_int_val122 = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_int_val122, (char *) "hello,int-val4"); - neu_int_val_t int_val122; - neu_int_val_init(&int_val122, 122, input_int_val122); - - /** the fifth element of 1D array **/ - neu_data_val_t *input_int_val211 = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_int_val211, (char *) "hello,int-val5"); - neu_int_val_t int_val211; - neu_int_val_init(&int_val211, 211, input_int_val211); - - /** the sixth element of 1D array **/ - neu_data_val_t *input_int_val212 = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_int_val212, (char *) "hello,int-val6"); - neu_int_val_t int_val212; - neu_int_val_init(&int_val212, 212, input_int_val212); - - /** the seventh element of 1D array **/ - neu_data_val_t *input_int_val221 = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_int_val221, (char *) "hello,int-val7"); - neu_int_val_t int_val221; - neu_int_val_init(&int_val221, 221, input_int_val221); - - /** the eighth element of 1D array **/ - neu_data_val_t *input_int_val222 = neu_dvalue_new(NEU_DTYPE_CSTR); - neu_dvalue_set_cstr(input_int_val222, (char *) "hello,int-val8"); - neu_int_val_t int_val222; - neu_int_val_init(&int_val222, 222, input_int_val222); - - /** set the first element of 2D array11 **/ - neu_fixed_array_t *set_array_int_val11 = - neu_fixed_array_new(2, sizeof(neu_int_val_t)); - neu_fixed_array_set(set_array_int_val11, 0, &int_val111); - neu_fixed_array_set(set_array_int_val11, 1, &int_val112); - neu_data_val_t *array_int_val_dval11 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_val_dval11, NEU_DTYPE_INT_VAL, - set_array_int_val11); - - /** set the second element of 2D array12 **/ - neu_fixed_array_t *set_array_int_val12 = - neu_fixed_array_new(2, sizeof(neu_int_val_t)); - neu_fixed_array_set(set_array_int_val12, 0, &int_val121); - neu_fixed_array_set(set_array_int_val12, 1, &int_val122); - neu_data_val_t *array_int_val_dval12 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_val_dval12, NEU_DTYPE_INT_VAL, - set_array_int_val12); - - /** set the first element of 2D array21 **/ - neu_fixed_array_t *set_array_int_val21 = - neu_fixed_array_new(2, sizeof(neu_int_val_t)); - neu_fixed_array_set(set_array_int_val21, 0, &int_val211); - neu_fixed_array_set(set_array_int_val21, 1, &int_val212); - neu_data_val_t *array_int_val_dval21 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_val_dval21, NEU_DTYPE_INT_VAL, - set_array_int_val21); - - /** set the second element of 2D array22 **/ - neu_fixed_array_t *set_array_int_val22 = - neu_fixed_array_new(2, sizeof(neu_int_val_t)); - neu_fixed_array_set(set_array_int_val22, 0, &int_val221); - neu_fixed_array_set(set_array_int_val22, 1, &int_val222); - neu_data_val_t *array_int_val_dval22 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_val_dval22, NEU_DTYPE_INT_VAL, - set_array_int_val22); - - /** set the first element of 3D array1 **/ - neu_fixed_array_t *set_array_int_val1 = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_array_int_val1, 0, &array_int_val_dval11); - neu_fixed_array_set(set_array_int_val1, 1, &array_int_val_dval12); - neu_data_val_t *array_int_val_dval1 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_val_dval1, NEU_DTYPE_DATA_VAL, - set_array_int_val1); - - /** set the second element of 3D array1 **/ - neu_fixed_array_t *set_array_int_val2 = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_array_int_val2, 0, &array_int_val_dval21); - neu_fixed_array_set(set_array_int_val2, 1, &array_int_val_dval22); - neu_data_val_t *array_int_val_dval2 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_int_val_dval2, NEU_DTYPE_DATA_VAL, - set_array_int_val2); - - /** set 3D array **/ - neu_fixed_array_t *set_array_int_val = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_array_int_val, 0, &array_int_val_dval1); - neu_fixed_array_set(set_array_int_val, 1, &array_int_val_dval2); - - /** serialize and deserialize return **/ - neu_fixed_array_t *get_array_int_val = - ser_deser_with_fixed_array(set_array_int_val, NEU_DTYPE_DATA_VAL); - - /** free **/ - neu_dvalue_free(input_int_val111); - neu_dvalue_free(input_int_val112); - neu_dvalue_free(input_int_val121); - neu_dvalue_free(input_int_val122); - neu_dvalue_free(input_int_val211); - neu_dvalue_free(input_int_val212); - neu_dvalue_free(input_int_val221); - neu_dvalue_free(input_int_val222); - - neu_fixed_array_free(set_array_int_val11); - neu_fixed_array_free(set_array_int_val12); - neu_fixed_array_free(set_array_int_val21); - neu_fixed_array_free(set_array_int_val22); - - neu_dvalue_free(array_int_val_dval11); - neu_dvalue_free(array_int_val_dval12); - neu_dvalue_free(array_int_val_dval21); - neu_dvalue_free(array_int_val_dval22); - - neu_fixed_array_free(set_array_int_val1); - neu_fixed_array_free(set_array_int_val2); - - neu_dvalue_free(array_int_val_dval1); - neu_dvalue_free(array_int_val_dval2); - - /** Compare **/ - comp_arr_3d_int_val(get_array_int_val); - - /** string_val **/ - /** set the first element of 1D array **/ - neu_string_t *input_str_key1 = neu_string_from_cstr((char *) "string-key1"); - neu_string_t *test_string1 = - neu_string_from_cstr((char *) "hello,string-val1"); - neu_data_val_t *input_str_dval1 = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_str_dval1, test_string1); - neu_string_val_t string_val1; - neu_string_val_init(&string_val1, input_str_key1, input_str_dval1); - - /** set the second element of 1D array **/ - neu_string_t *input_str_key2 = neu_string_from_cstr((char *) "string-key2"); - neu_string_t *test_string2 = - neu_string_from_cstr((char *) "hello,string-val2"); - neu_data_val_t *input_str_dval2 = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_str_dval2, test_string2); - neu_string_val_t string_val2; - neu_string_val_init(&string_val2, input_str_key2, input_str_dval2); - - /** set the third element of 1D array **/ - neu_string_t *input_str_key3 = neu_string_from_cstr((char *) "string-key3"); - neu_string_t *test_string3 = - neu_string_from_cstr((char *) "hello,string-val3"); - neu_data_val_t *input_str_dval3 = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_str_dval3, test_string3); - neu_string_val_t string_val3; - neu_string_val_init(&string_val3, input_str_key3, input_str_dval3); - - /** set the fourth element of 1D array **/ - neu_string_t *input_str_key4 = neu_string_from_cstr((char *) "string-key4"); - neu_string_t *test_string4 = - neu_string_from_cstr((char *) "hello,string-val4"); - neu_data_val_t *input_str_dval4 = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_str_dval4, test_string4); - neu_string_val_t string_val4; - neu_string_val_init(&string_val4, input_str_key4, input_str_dval4); - - /** set the fifth element of 1D array **/ - neu_string_t *input_str_key5 = neu_string_from_cstr((char *) "string-key5"); - neu_string_t *test_string5 = - neu_string_from_cstr((char *) "hello,string-val5"); - neu_data_val_t *input_str_dval5 = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_str_dval5, test_string5); - neu_string_val_t string_val5; - neu_string_val_init(&string_val5, input_str_key5, input_str_dval5); - - /** set the sixth element of 1D array **/ - neu_string_t *input_str_key6 = neu_string_from_cstr((char *) "string-key6"); - neu_string_t *test_string6 = - neu_string_from_cstr((char *) "hello,string-val6"); - neu_data_val_t *input_str_dval6 = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_str_dval6, test_string6); - neu_string_val_t string_val6; - neu_string_val_init(&string_val6, input_str_key6, input_str_dval6); - - /** set the seventh element of 1D array **/ - neu_string_t *input_str_key7 = neu_string_from_cstr((char *) "string-key7"); - neu_string_t *test_string7 = - neu_string_from_cstr((char *) "hello,string-val7"); - neu_data_val_t *input_str_dval7 = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_str_dval7, test_string7); - neu_string_val_t string_val7; - neu_string_val_init(&string_val7, input_str_key7, input_str_dval7); - - /** set the eighth element of 1D array **/ - neu_string_t *input_str_key8 = neu_string_from_cstr((char *) "string-key8"); - neu_string_t *test_string8 = - neu_string_from_cstr((char *) "hello,string-val8"); - neu_data_val_t *input_str_dval8 = neu_dvalue_new(NEU_DTYPE_STRING); - neu_dvalue_set_move_string(input_str_dval8, test_string8); - neu_string_val_t string_val8; - neu_string_val_init(&string_val8, input_str_key8, input_str_dval8); - - /** set the first element of 2D array11 **/ - neu_fixed_array_t *set_str_val_array11 = - neu_fixed_array_new(2, sizeof(neu_string_val_t)); - neu_fixed_array_set(set_str_val_array11, 0, &string_val1); - neu_fixed_array_set(set_str_val_array11, 1, &string_val2); - - neu_data_val_t *array_str_val_dval11 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_str_val_dval11, NEU_DTYPE_STRING_VAL, - set_str_val_array11); - - /** set the second element of 2D array12 **/ - neu_fixed_array_t *set_str_val_array12 = - neu_fixed_array_new(2, sizeof(neu_string_val_t)); - neu_fixed_array_set(set_str_val_array12, 0, &string_val3); - neu_fixed_array_set(set_str_val_array12, 1, &string_val4); - - neu_data_val_t *array_str_val_dval12 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_str_val_dval12, NEU_DTYPE_STRING_VAL, - set_str_val_array12); - - /** set the first element of 2D array21 **/ - neu_fixed_array_t *set_str_val_array21 = - neu_fixed_array_new(2, sizeof(neu_string_val_t)); - neu_fixed_array_set(set_str_val_array21, 0, &string_val5); - neu_fixed_array_set(set_str_val_array21, 1, &string_val6); - - neu_data_val_t *array_str_val_dval21 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_str_val_dval21, NEU_DTYPE_STRING_VAL, - set_str_val_array21); - - /** set the second element of 2D array22 **/ - neu_fixed_array_t *set_str_val_array22 = - neu_fixed_array_new(2, sizeof(neu_string_val_t)); - neu_fixed_array_set(set_str_val_array22, 0, &string_val7); - neu_fixed_array_set(set_str_val_array22, 1, &string_val8); - - neu_data_val_t *array_str_val_dval22 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_str_val_dval22, NEU_DTYPE_STRING_VAL, - set_str_val_array22); - - /** set the first element of 3D array1 **/ - neu_fixed_array_t *set_str_val_array1 = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_str_val_array1, 0, &array_str_val_dval11); - neu_fixed_array_set(set_str_val_array1, 1, &array_str_val_dval12); - - neu_data_val_t *array_str_val_dval1 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_str_val_dval1, NEU_DTYPE_DATA_VAL, - set_str_val_array1); - - /** set the second element of 3D array1 **/ - neu_fixed_array_t *set_str_val_array2 = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_str_val_array2, 0, &array_str_val_dval21); - neu_fixed_array_set(set_str_val_array2, 1, &array_str_val_dval22); - - neu_data_val_t *array_str_val_dval2 = neu_dvalue_unit_new(); - neu_dvalue_init_ref_array(array_str_val_dval2, NEU_DTYPE_DATA_VAL, - set_str_val_array2); - - /** set 3D array **/ - neu_fixed_array_t *set_array_str_val = - neu_fixed_array_new(2, sizeof(neu_data_val_t *)); - neu_fixed_array_set(set_array_str_val, 0, &array_str_val_dval1); - neu_fixed_array_set(set_array_str_val, 1, &array_str_val_dval2); - - /** serialize and deserializa return **/ - neu_fixed_array_t *get_array_str_val = - ser_deser_with_fixed_array(set_array_str_val, NEU_DTYPE_DATA_VAL); - - /** free **/ - neu_string_free(input_str_key1); - neu_string_free(input_str_key2); - neu_string_free(input_str_key3); - neu_string_free(input_str_key4); - neu_string_free(input_str_key5); - neu_string_free(input_str_key6); - neu_string_free(input_str_key7); - neu_string_free(input_str_key8); - - neu_dvalue_free(input_str_dval1); - neu_dvalue_free(input_str_dval2); - neu_dvalue_free(input_str_dval3); - neu_dvalue_free(input_str_dval4); - neu_dvalue_free(input_str_dval5); - neu_dvalue_free(input_str_dval6); - neu_dvalue_free(input_str_dval7); - neu_dvalue_free(input_str_dval8); - - neu_fixed_array_free(set_str_val_array11); - neu_fixed_array_free(set_str_val_array12); - neu_fixed_array_free(set_str_val_array21); - neu_fixed_array_free(set_str_val_array22); - - neu_dvalue_free(array_str_val_dval11); - neu_dvalue_free(array_str_val_dval12); - neu_dvalue_free(array_str_val_dval21); - neu_dvalue_free(array_str_val_dval22); - - neu_fixed_array_free(set_str_val_array1); - neu_fixed_array_free(set_str_val_array2); - - neu_dvalue_free(array_str_val_dval1); - neu_dvalue_free(array_str_val_dval2); - - /** Compare **/ - comp_arr_3d_str_val(get_array_str_val); -} - -TEST(DataValueTest, neu_dvalue_vec_deser) -{ - int rc; - ssize_t size; - uint8_t *buf; - - vector_t *vec_set; - int8_t i8_arr[4] = { 2, 7, 1, 8 }; - vec_set = vector_new(4, sizeof(int8_t)); - vector_push_back(vec_set, &i8_arr[0]); - vector_push_back(vec_set, &i8_arr[1]); - vector_push_back(vec_set, &i8_arr[2]); - vector_push_back(vec_set, &i8_arr[3]); - - neu_data_val_t *val = neu_dvalue_unit_new(); - neu_dvalue_init_move_vec(val, NEU_DTYPE_INT8, vec_set); - size = neu_dvalue_serialize(val, &buf); - EXPECT_LT(0, size); - neu_dvalue_free(val); - - neu_data_val_t *val1; - size = neu_dvalue_deserialize(buf, size, &val1); - EXPECT_LT(0, size); - vector_t *vec_get; - rc = neu_dvalue_get_move_vec(val1, &vec_get); - EXPECT_EQ(0, rc); - // TODO: assert two vector is euqal - - free(buf); - vector_free(vec_get); - neu_dvalue_free(val1); -} - -int main(int argc, char **argv) -{ - zlog_init("./config/dev.conf"); - neuron = zlog_get_category("neuron"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file diff --git a/tests/json_datatag_table_test.cc b/tests/json_datatag_table_test.cc deleted file mode 100644 index 389271ab..00000000 --- a/tests/json_datatag_table_test.cc +++ /dev/null @@ -1,153 +0,0 @@ -#include - -#include - -#include "utils/log.h" -#include "json/neu_json_fn.h" -#include "json/neu_json_tag.h" - -zlog_category_t *neuron = NULL; - -TEST(JsonDatatagTableTest, AddTagDecode) -{ - char *buf = (char *) "{\"node_id\":123456, \"group_config_name\": \"name\"," - "\"tags\": " - "[{\"name\":\"name1\", \"attribute\":1, " - "\"address\":\"1!400001\", \"type\":0}, " - "{\"name\":\"name2\", \"attribute\":3," - "\"address\":\"1!400002\", \"type\":1} ] }"; - neu_json_add_tags_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_add_tags_req(buf, &req)); - - EXPECT_EQ(123456, req->node_id); - EXPECT_STREQ("name", req->group_config_name); - - EXPECT_STREQ("name1", req->tags[0].name); - EXPECT_EQ(0, req->tags[0].type); - EXPECT_STREQ("1!400001", req->tags[0].address); - EXPECT_EQ(1, req->tags[0].attribute); - - EXPECT_STREQ("name2", req->tags[1].name); - EXPECT_EQ(1, req->tags[1].type); - EXPECT_STREQ("1!400002", req->tags[1].address); - EXPECT_EQ(3, req->tags[1].attribute); - - neu_json_decode_add_tags_req_free(req); -} - -TEST(JsonDatatagTableTest, GetTagDecode) -{ - char *buf = (char *) "{\"node_id\": 123456, \"group_config_name\": " - "\"config_modbus_tcp_sample_2\"}"; - neu_json_get_tags_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_get_tags_req(buf, &req)); - - EXPECT_EQ(123456, req->node_id); - - neu_json_decode_get_tags_req_free(req); -} - -TEST(JsonDatatagTableTest, GetTagEncode) -{ - char *buf = - (char *) "{\"tags\": [{\"type\": 0, \"name\": \"Tag0001\", \"id\": 0, " - "\"group_config_name\": \"config_modbus_tcp_sample_2\", " - "\"attribute\": 0, \"address\": \"1!400001\"}, {\"type\": 1, " - "\"name\": \"Tag0002\", \"id\": 1, \"group_config_name\": " - "\"config_modbus_tcp_sample_2\", \"attribute\": 1, " - "\"address\": \"1!400002\"}]}"; - char * result = NULL; - neu_json_get_tags_resp_t res = { 0 }; - - res.n_tag = 2; - - res.tags = (neu_json_get_tags_resp_tag_t *) calloc( - 2, sizeof(neu_json_get_tags_resp_tag_t)); - res.tags[0].type = 0; - res.tags[0].name = strdup((char *) "Tag0001"); - res.tags[0].id = 0; - res.tags[0].attribute = 0; - res.tags[0].address = strdup((char *) "1!400001"); - res.tags[0].group_config_name = - strdup((char *) "config_modbus_tcp_sample_2"); - - res.tags[1].type = 1; - res.tags[1].name = strdup((char *) "Tag0002"); - res.tags[1].id = 1; - res.tags[1].attribute = 1; - res.tags[1].address = strdup((char *) "1!400002"); - res.tags[1].group_config_name = - strdup((char *) "config_modbus_tcp_sample_2"); - - EXPECT_EQ( - 0, neu_json_encode_by_fn(&res, neu_json_encode_get_tags_resp, &result)); - EXPECT_STREQ(buf, result); - - free(res.tags[0].name); - free(res.tags[1].name); - free(res.tags[0].address); - free(res.tags[1].address); - free(res.tags[0].group_config_name); - free(res.tags[1].group_config_name); - free(res.tags); - free(result); -} - -TEST(JsonDatatagTableTest, DeleteTagDecode) -{ - char *buf = - (char *) "{\"node_id\": 123456, \"group_config_name\": \"name\", " - "\"ids\": [123, 456]}"; - neu_json_del_tags_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_del_tags_req(buf, &req)); - - EXPECT_EQ(123456, req->node_id); - EXPECT_STREQ("name", req->group_config_name); - EXPECT_EQ(2, req->n_id); - EXPECT_EQ(123, req->ids[0]); - EXPECT_EQ(456, req->ids[1]); - - neu_json_decode_del_tags_req_free(req); -} - -TEST(JsonDatatagTableTest, UpdateTagDecode) -{ - char *buf = (char *) "{\"node_id\":123456, " - "\"group_config_name\": \"test-group\"," - "\"tags\": " - "[{\"id\":12,\"name\":\"name1\",\"type\":0," - "\"address\":\"1!400001\",\"attribute\":0}, " - "{\"id\":13,\"name\":\"name2\",\"type\":1, " - "\"address\":\"1!400003\",\"attribute\":1} ] }"; - neu_json_update_tags_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_update_tags_req(buf, &req)); - - EXPECT_EQ(123456, req->node_id); - EXPECT_STREQ("test-group", req->group_config_name); - - EXPECT_EQ(12, req->tags[0].id); - EXPECT_STREQ("name1", req->tags[0].name); - EXPECT_EQ(0, req->tags[0].type); - EXPECT_STREQ("1!400001", req->tags[0].address); - EXPECT_EQ(0, req->tags[0].attribute); - - EXPECT_EQ(13, req->tags[1].id); - EXPECT_STREQ("name2", req->tags[1].name); - EXPECT_EQ(1, req->tags[1].type); - EXPECT_STREQ("1!400003", req->tags[1].address); - EXPECT_EQ(1, req->tags[1].attribute); - - neu_json_decode_update_tags_req_free(req); -} - -int main(int argc, char **argv) -{ - zlog_init("./config/dev.conf"); - neuron = zlog_get_category("neuron"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file diff --git a/tests/json_group_config_test.cc b/tests/json_group_config_test.cc deleted file mode 100644 index 63bf98f4..00000000 --- a/tests/json_group_config_test.cc +++ /dev/null @@ -1,114 +0,0 @@ -#include -#include - -#include "utils/log.h" -#include "json/neu_json_fn.h" -#include "json/neu_json_group_config.h" - -zlog_category_t *neuron = NULL; - -TEST(TagGroupConfigTest, neu_parse_decode_get_group_config_req) -{ - char *json = (char *) "{\"node_id\": 123456 }"; - - neu_json_get_group_config_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_get_group_config_req(json, &req)); - - EXPECT_EQ(123456, req->node_id); - - neu_json_decode_get_group_config_req_free(req); -} - -TEST(TagGroupConfigTest, neu_parse_encode_get_group_config_res) -{ - char *buf = - (char *) "{\"group_configs\": [{\"tag_count\": 0, \"pipe_count\": 0, " - "\"name\": \"config0\", \"interval\": 0}, {\"tag_count\": 0, " - "\"pipe_count\": 0, \"name\": \"config1\", \"interval\": 0}, " - "{\"tag_count\": 0, \"pipe_count\": 0, \"name\": \"config2\", " - "\"interval\": 0}]}"; - char * result = NULL; - neu_json_get_group_config_resp_t res = { - .n_group_config = 3, - }; - - res.group_configs = - (neu_json_get_group_config_resp_group_config_t *) calloc( - 3, sizeof(neu_json_get_group_config_resp_group_config_t)); - - res.group_configs[0].name = strdup((char *) "config0"); - res.group_configs[1].name = strdup((char *) "config1"); - res.group_configs[2].name = strdup((char *) "config2"); - - EXPECT_EQ(0, - neu_json_encode_by_fn(&res, neu_json_encode_get_group_config_resp, - &result)); - EXPECT_STREQ(buf, result); - - free(res.group_configs[0].name); - free(res.group_configs[1].name); - free(res.group_configs[2].name); - free(res.group_configs); - free(result); -} - -TEST(TagGroupConfigTest, neu_parse_decode_add_group_config_req) -{ - char *buf = (char *) "{\"name\":\"Config0\", " - "\"node_id\":123456, " - "\"interval\": 2000 " - " }"; - - neu_json_add_group_config_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_add_group_config_req(buf, &req)); - - EXPECT_STREQ("Config0", req->name); - EXPECT_EQ(123456, req->node_id); - EXPECT_EQ(2000, req->interval); - - neu_json_decode_add_group_config_req_free(req); -} - -TEST(TagGroupConfigTest, neu_parse_decode_update_group_config_req) -{ - char *buf = (char *) "{\"name\":\"Config0\", " - "\"node_id\":123456, " - "\"interval\": 2000 " - " }"; - - neu_json_update_group_config_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_update_group_config_req(buf, &req)); - - EXPECT_STREQ("Config0", req->name); - EXPECT_EQ(123456, req->node_id); - EXPECT_EQ(2000, req->interval); - - neu_json_decode_update_group_config_req_free(req); -} - -TEST(TagGroupConfigTest, neu_parse_decode_delete_group_config_req) -{ - char *buf = (char *) "{\"name\":\"Config0\", " - "\"node_id\":123456 " - "}"; - - neu_json_del_group_config_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_del_group_config_req(buf, &req)); - - EXPECT_STREQ("Config0", req->name); - EXPECT_EQ(123456, req->node_id); - - neu_json_decode_del_group_config_req_free(req); -} - -int main(int argc, char **argv) -{ - zlog_init("./config/dev.conf"); - neuron = zlog_get_category("neuron"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file diff --git a/tests/json_nodes_test.cc b/tests/json_nodes_test.cc deleted file mode 100644 index f217f117..00000000 --- a/tests/json_nodes_test.cc +++ /dev/null @@ -1,108 +0,0 @@ -#include - -#include - -#include "adapter.h" -#include "json/neu_json_fn.h" -#include "json/neu_json_node.h" - -#include "utils/log.h" - -zlog_category_t *neuron = NULL; - -TEST(JsonNodesTest, AddNodesDecode) -{ - char *buf = (char *) "{\"type\": 1, " - "\"name\": \"adapter1\" ," - "\"plugin_name\": \"plugin1\" }"; - neu_json_add_node_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_add_node_req(buf, &req)); - - EXPECT_EQ(NEU_NA_TYPE_DRIVER, req->type); - EXPECT_STREQ("adapter1", req->name); - EXPECT_STREQ("plugin1", req->plugin_name); - - neu_json_decode_add_node_req_free(req); -} - -TEST(JsonNodesTest, GetNodesDecode) -{ - char * buf = (char *) "{\"node_type\": 1 }"; - neu_json_get_nodes_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_get_nodes_req(buf, &req)); - - EXPECT_EQ(1, req->node_type); - - neu_json_decode_get_nodes_req_free(req); -} - -TEST(JsonNodesTest, GetNodesEncode) -{ - char *buf = - (char *) "{\"nodes\": [{\"plugin_id\": 0, \"name\": \"node1\", \"id\": " - "123}, {\"plugin_id\": 0, \"name\": \"node2\", \"id\": 456}, " - "{\"plugin_id\": 0, \"name\": \"node3\", \"id\": 789}]}"; - char * result = NULL; - neu_json_get_nodes_resp_t res = { - .n_node = 3, - }; - - res.nodes = (neu_json_get_nodes_resp_node_t *) calloc( - 3, sizeof(neu_json_get_nodes_resp_node_t)); - res.nodes[0].name = strdup((char *) "node1"); - res.nodes[0].id = 123; - - res.nodes[1].name = strdup((char *) "node2"); - res.nodes[1].id = 456; - - res.nodes[2].name = strdup((char *) "node3"); - res.nodes[2].id = 789; - - EXPECT_EQ( - 0, - neu_json_encode_by_fn(&res, neu_json_encode_get_nodes_resp, &result)); - EXPECT_STREQ(buf, result); - - free(res.nodes[0].name); - free(res.nodes[1].name); - free(res.nodes[2].name); - free(res.nodes); - - free(result); -} - -TEST(JsonNodesTest, DeleteNodesDecode) -{ - char * buf = (char *) "{\"id\": 123 }"; - neu_json_del_node_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_del_node_req(buf, &req)); - - EXPECT_EQ(123, req->id); - - neu_json_decode_del_node_req_free(req); -} - -TEST(JsonNodesTest, UpdateNodesDecode) -{ - char *buf = (char *) "{\"id\": 1, " - "\"name\": \"adapter1\" }"; - neu_json_update_node_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_update_node_req(buf, &req)); - - EXPECT_EQ(1, req->id); - EXPECT_STREQ("adapter1", req->name); - - neu_json_decode_update_node_req_free(req); -} - -int main(int argc, char **argv) -{ - zlog_init("./config/dev.conf"); - neuron = zlog_get_category("neuron"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file diff --git a/tests/json_persistence_test.cc b/tests/json_persistence_test.cc deleted file mode 100644 index 78ecd6ff..00000000 --- a/tests/json_persistence_test.cc +++ /dev/null @@ -1,442 +0,0 @@ -#include - -#include - -#include "persist/json/persist_json_adapter.h" -#include "persist/json/persist_json_datatags.h" -#include "persist/json/persist_json_group_configs.h" -#include "persist/json/persist_json_plugin.h" -#include "persist/json/persist_json_subs.h" -#include "json/neu_json_fn.h" - -#include "utils/log.h" -zlog_category_t *neuron = NULL; - -TEST(JsonAdapter, AdapterPersistenceDecode) -{ - char *buf = - (char *) "{\"nodes\": " - "[{\"id\":1, \"type\":1, \"state\": 1, \"name\": " - "\"sample-driver-adapter\", \"plugin_name\": " - "\"sample-drv-plugin\"}, " - "{\"id\":2, \"type\":5, \"state\": 2, \"name\": " - "\"sample-app-adapter\", \"plugin_name\": " - "\"sample-app-plugin\"}, " - "{\"id\":3, \"type\": 3, \"state\": 3, \"name\": " - "\"mqtt-adapter\", \"plugin_name\": \"mqtt-plugin\"}]}"; - - neu_json_node_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_node_req(buf, &req)); - - EXPECT_EQ(1, req->nodes[0].state); - EXPECT_EQ(1, req->nodes[0].type); - EXPECT_STREQ("sample-driver-adapter", req->nodes[0].name); - EXPECT_STREQ("sample-drv-plugin", req->nodes[0].plugin_name); - - EXPECT_EQ(2, req->nodes[1].state); - EXPECT_EQ(5, req->nodes[1].type); - EXPECT_STREQ("sample-app-adapter", req->nodes[1].name); - EXPECT_STREQ("sample-app-plugin", req->nodes[1].plugin_name); - - EXPECT_EQ(3, req->nodes[2].state); - EXPECT_EQ(3, req->nodes[2].type); - EXPECT_STREQ("mqtt-adapter", req->nodes[2].name); - EXPECT_STREQ("mqtt-plugin", req->nodes[2].plugin_name); - - neu_json_decode_node_req_free(req); -} - -TEST(JsonPlugin, PluginPersistenceDecode) -{ - char *buf = - (char *) "{\"plugins\": " - "[ \"libplugin-sample-drv.so\", \"libplugin-sample-app.so\", " - "\"libplugin-mqtt.so\" ]}"; - - neu_json_plugin_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_plugin_req(buf, &req)); - - EXPECT_STREQ("libplugin-sample-drv.so", req->plugins[0]); - EXPECT_STREQ("libplugin-sample-app.so", req->plugins[1]); - EXPECT_STREQ("libplugin-mqtt.so", req->plugins[2]); - - neu_json_decode_plugin_req_free(req); -} - -TEST(JsonDatatags, DatatagPersistenceDecode) -{ - char *buf = - (char *) "{\"tags\": [{\"id\": 1, \"attribute\": 1, \"type\": 3, " - "\"address\": \"1!400001\", \"name\": \"modbus1\"}, " - "{\"id\": 2, \"attribute\": 1, \"type\": 4, \"address\": " - "\"1!400002\", " - "\"name\": \"modbus2\"}, {\"id\": 3, \"attribute\": 1, " - "\"type\": 4, \"address\": \"1!400003\", \"name\": " - "\"modbus3\"}]}"; - - neu_json_datatag_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_datatag_req(buf, &req)); - - EXPECT_EQ(1, req->tags[0].id); - EXPECT_EQ(1, req->tags[0].attribute); - EXPECT_EQ(3, req->tags[0].type); - EXPECT_STREQ("1!400001", req->tags[0].address); - EXPECT_STREQ("modbus1", req->tags[0].name); - - EXPECT_EQ(2, req->tags[1].id); - EXPECT_EQ(1, req->tags[1].attribute); - EXPECT_EQ(4, req->tags[1].type); - EXPECT_STREQ("1!400002", req->tags[1].address); - EXPECT_STREQ("modbus2", req->tags[1].name); - - EXPECT_EQ(3, req->tags[2].id); - EXPECT_EQ(1, req->tags[2].attribute); - EXPECT_EQ(4, req->tags[2].type); - EXPECT_STREQ("1!400003", req->tags[2].address); - EXPECT_STREQ("modbus3", req->tags[2].name); - - neu_json_decode_datatag_req_free(req); -} - -TEST(JsonSubs, SubsPersistenceDecode) -{ - char *buf = (char *) "{\"subscriptions\": [{\"sub_adapter_name\": " - "\"sample-app-adapter\", \"group_config_name\": " - "\"config_drv_sample\", \"src_adapter_name\": " - "\"sample-driver-adapter\", \"read_interval\": 2000}, " - "{\"sub_adapter_name\": \"sample-driver-adapter\", " - "\"group_config_name\": \"config_app_sample\", " - "\"src_adapter_name\": \"config_app_sample\", " - "\"read_interval\": 2000}, " - "{\"sub_adapter_name\": \"mqtt-adapter\", " - "\"group_config_name\": \"config_mqtt_sample\", " - "\"src_adapter_name\": \"sample-driver-adapter\", " - "\"read_interval\": 2000}]}"; - - neu_json_subscriptions_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_subscriptions_req(buf, &req)); - - EXPECT_STREQ("sample-app-adapter", req->subscriptions[0].sub_adapter_name); - EXPECT_STREQ("config_drv_sample", req->subscriptions[0].group_config_name); - EXPECT_STREQ("sample-driver-adapter", - req->subscriptions[0].src_adapter_name); - EXPECT_EQ(2000, req->subscriptions[0].read_interval); - - EXPECT_STREQ("sample-driver-adapter", - req->subscriptions[1].sub_adapter_name); - EXPECT_STREQ("config_app_sample", req->subscriptions[1].group_config_name); - EXPECT_STREQ("config_app_sample", req->subscriptions[1].src_adapter_name); - EXPECT_EQ(2000, req->subscriptions[1].read_interval); - - EXPECT_STREQ("mqtt-adapter", req->subscriptions[2].sub_adapter_name); - EXPECT_STREQ("config_mqtt_sample", req->subscriptions[2].group_config_name); - EXPECT_STREQ("sample-driver-adapter", - req->subscriptions[2].src_adapter_name); - EXPECT_EQ(2000, req->subscriptions[2].read_interval); - - neu_json_decode_subscriptions_req_free(req); -} - -TEST(JsonGroupConfigs, GroupConfigsPersistenceDecode) -{ - char *buf = - (char *) "{\"adapter_name\": \"modbus_tcp_adapter\", " - "\"group_config_name\": \"config_modbus_tcp_sample_2\", " - "\"read_interval\": 2000 }"; - - neu_json_group_configs_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_group_configs_req(buf, &req)); - - EXPECT_STREQ("modbus_tcp_adapter", req->adapter_name); - EXPECT_STREQ("config_modbus_tcp_sample_2", req->group_config_name); - EXPECT_EQ(2000, req->read_interval); - - neu_json_decode_group_configs_req_free(req); -} - -TEST(JsonAdapterTest, AdapterPersistenceEncode) -{ - char *buf = - (char *) "{\"nodes\": [{\"type\": 1, \"state\": 1, \"plugin_name\": " - "\"sample-drv-plugin\", \"name\": \"sample-driver-adapter\", " - "\"id\": 1}, {\"type\": 5, \"state\": 2, \"plugin_name\": " - "\"sample-app-plugin\", \"name\": \"sample-app-adapter\", " - "\"id\": 2}, {\"type\": 3, \"state\": 3, \"plugin_name\": " - "\"mqtt-plugin\", \"name\": \"mqtt-adapter\", \"id\": 3}]}"; - char *buf2 = (char *) "{\"nodes\": []}"; - - char *result = NULL; - char *result2 = NULL; - - neu_json_node_resp_t resp = { - .n_node = 3, - }; - neu_json_node_resp_t resp2 = { - .n_node = 0, - }; - - resp.nodes = (neu_json_node_resp_node_t *) calloc( - 3, sizeof(neu_json_node_resp_node_t)); - resp.nodes[0].id = 1; - resp.nodes[0].state = 1; - resp.nodes[0].type = 1; - resp.nodes[0].name = strdup((char *) "sample-driver-adapter"); - resp.nodes[0].plugin_name = strdup((char *) "sample-drv-plugin"); - - resp.nodes[1].id = 2; - resp.nodes[1].state = 2; - resp.nodes[1].type = 5; - resp.nodes[1].name = strdup((char *) "sample-app-adapter"); - resp.nodes[1].plugin_name = strdup((char *) "sample-app-plugin"); - - resp.nodes[2].id = 3; - resp.nodes[2].state = 3; - resp.nodes[2].type = 3; - resp.nodes[2].name = strdup((char *) "mqtt-adapter"); - resp.nodes[2].plugin_name = strdup((char *) "mqtt-plugin"); - - EXPECT_EQ(0, - neu_json_encode_by_fn(&resp, neu_json_encode_node_resp, &result)); - EXPECT_EQ( - 0, neu_json_encode_by_fn(&resp2, neu_json_encode_node_resp, &result2)); - EXPECT_STREQ(buf, result); - EXPECT_STREQ(buf2, result2); - - free(resp.nodes[0].name); - free(resp.nodes[0].plugin_name); - free(resp.nodes[1].name); - free(resp.nodes[1].plugin_name); - free(resp.nodes[2].name); - free(resp.nodes[2].plugin_name); - free(resp.nodes); - - free(result); - free(result2); -} - -TEST(JsonPluginTest, PluginPersistenceEncode) -{ - char *buf = (char *) "{\"plugins\": [\"libplugin-sample-drv.so\", " - "\"libplugin-sample-app.so\", \"libplugin-mqtt.so\"]}"; - char *buf2 = (char *) "{\"plugins\": []}"; - - char *result = NULL; - char *result2 = NULL; - - neu_json_plugin_resp_t resp = { - .n_plugin = 3, - }; - neu_json_plugin_resp_t resp2 = { - .n_plugin = 0, - }; - - resp.plugins = (neu_json_plugin_resp_plugin_t *) calloc( - 3, sizeof(neu_json_plugin_resp_plugin_t)); - - resp.plugins[0] = strdup("libplugin-sample-drv.so"); - resp.plugins[1] = strdup("libplugin-sample-app.so"); - resp.plugins[2] = strdup("libplugin-mqtt.so"); - - EXPECT_EQ( - 0, neu_json_encode_by_fn(&resp, neu_json_encode_plugin_resp, &result)); - EXPECT_EQ( - 0, - neu_json_encode_by_fn(&resp2, neu_json_encode_plugin_resp, &result2)); - - EXPECT_STREQ(buf, result); - EXPECT_STREQ(buf2, result2); - - free(resp.plugins[0]); - free(resp.plugins[1]); - free(resp.plugins[2]); - free(resp.plugins); - - free(result); - free(result2); -} - -TEST(JsonSubscriptionsTest, SbuscriptionsPersistenceEncode) -{ - char *buf = (char *) "{\"subscriptions\": [{\"sub_adapter_name\": " - "\"sub_adapter_name\", \"src_adapter_name\": " - "\"sample-driver-adapter\", \"read_interval\": 2000, " - "\"group_config_name\": \"config_drv_sample\"}, " - "{\"sub_adapter_name\": \"sample-driver-adapter\", " - "\"src_adapter_name\": \"config_app_sample\", " - "\"read_interval\": 2000, \"group_config_name\": " - "\"config_app_sample\"}, {\"sub_adapter_name\": " - "\"mqtt-adapter\", \"src_adapter_name\": " - "\"sample-driver-adapter\", \"read_interval\": 2000, " - "\"group_config_name\": \"config_mqtt_sample\"}]}"; - char *buf2 = (char *) "{\"subscriptions\": []}"; - - char *result = NULL; - char *result2 = NULL; - - neu_json_subscriptions_resp_t resp = { - .n_subscription = 3, - }; - neu_json_subscriptions_resp_t resp2 = { - .n_subscription = 0, - }; - - resp.subscriptions = (neu_json_subscriptions_resp_subscription_t *) calloc( - 3, sizeof(neu_json_subscriptions_resp_subscription_t)); - resp.subscriptions[0].group_config_name = strdup("config_drv_sample"); - resp.subscriptions[0].sub_adapter_name = strdup("sub_adapter_name"); - resp.subscriptions[0].src_adapter_name = strdup("sample-driver-adapter"); - resp.subscriptions[0].read_interval = 2000; - - resp.subscriptions[1].group_config_name = strdup("config_app_sample"); - resp.subscriptions[1].sub_adapter_name = strdup("sample-driver-adapter"); - resp.subscriptions[1].src_adapter_name = strdup("config_app_sample"); - resp.subscriptions[1].read_interval = 2000; - - resp.subscriptions[2].group_config_name = strdup("config_mqtt_sample"); - resp.subscriptions[2].sub_adapter_name = strdup("mqtt-adapter"); - resp.subscriptions[2].src_adapter_name = strdup("sample-driver-adapter"); - resp.subscriptions[2].read_interval = 2000; - - EXPECT_EQ(0, - neu_json_encode_by_fn(&resp, neu_json_encode_subscriptions_resp, - &result)); - EXPECT_EQ(0, - neu_json_encode_by_fn(&resp2, neu_json_encode_subscriptions_resp, - &result2)); - - EXPECT_STREQ(buf, result); - EXPECT_STREQ(buf2, result2); - - free(resp.subscriptions[0].group_config_name); - free(resp.subscriptions[0].src_adapter_name); - free(resp.subscriptions[0].sub_adapter_name); - free(resp.subscriptions[1].group_config_name); - free(resp.subscriptions[1].src_adapter_name); - free(resp.subscriptions[1].sub_adapter_name); - free(resp.subscriptions[2].group_config_name); - free(resp.subscriptions[2].src_adapter_name); - free(resp.subscriptions[2].sub_adapter_name); - free(resp.subscriptions); - - free(result); - free(result2); -} - -TEST(JsonDatatags, DatatagPersistenceEncode) -{ - char *buf = - (char *) "{\"tags\": [{\"type\": 3, \"name\": \"modbus1\", " - "\"attribute\": 1, \"address\": \"1!400001\", \"id\": 1}, {" - "\"type\": 4, " - "\"name\": \"modbus2\", \"attribute\": 1, \"address\": " - "\"1!400002\", \"id\": 2}, {\"type\": 4, \"name\": " - "\"modbus3\", " - "\"attribute\": 1, \"address\": \"1!400003\", \"id\": 3}]}"; - char *buf2 = (char *) "{\"tags\": []}"; - - char *result = NULL; - char *result2 = NULL; - - neu_json_datatag_resp_t resp = { - .n_tag = 3, - }; - neu_json_datatag_resp_t resp2 = { - .n_tag = 0, - }; - - resp.tags = (neu_json_datatag_resp_tag_t *) calloc( - 3, sizeof(neu_json_datatag_resp_tag_t)); - resp.tags[0].attribute = 1; - resp.tags[0].type = 3; - resp.tags[0].address = strdup("1!400001"); - resp.tags[0].name = strdup("modbus1"); - resp.tags[0].id = 1; - - resp.tags[1].attribute = 1; - resp.tags[1].type = 4; - resp.tags[1].address = strdup("1!400002"); - resp.tags[1].name = strdup("modbus2"); - resp.tags[1].id = 2; - - resp.tags[2].attribute = 1; - resp.tags[2].type = 4; - resp.tags[2].address = strdup("1!400003"); - resp.tags[2].name = strdup("modbus3"); - resp.tags[2].id = 3; - - EXPECT_EQ( - 0, neu_json_encode_by_fn(&resp, neu_json_encode_datatag_resp, &result)); - EXPECT_EQ( - 0, - neu_json_encode_by_fn(&resp2, neu_json_encode_datatag_resp, &result2)); - - EXPECT_STREQ(buf, result); - EXPECT_STREQ(buf2, result2); - - free(resp.tags[0].address); - free(resp.tags[0].name); - free(resp.tags[1].address); - free(resp.tags[1].name); - free(resp.tags[2].address); - free(resp.tags[2].name); - free(resp.tags); - - free(result); - free(result2); -} - -TEST(JsonGroupConfigTest, GroupConfigPersistenceEncode) -{ - char *buf = (char *) "{\"read_interval\": 2000, \"group_config_name\": " - "\"config_modbus_tcp_sample_2\", \"adapter_name\": " - "\"config_modbus_tcp_sample_2\"}"; - - char *buf2 = (char *) "{\"read_interval\": 2000, \"group_config_name\": " - "\"\", \"adapter_name\": \"\"}"; - - char *result = NULL; - char *result2 = NULL; - - neu_json_group_configs_resp_t resp = { - .group_config_name = strdup("config_modbus_tcp_sample_2"), - .adapter_name = strdup("config_modbus_tcp_sample_2"), - .read_interval = 2000, - }; - neu_json_group_configs_resp_t resp2 = { - .group_config_name = strdup(""), - .adapter_name = strdup(""), - .read_interval = 2000, - }; - - EXPECT_EQ(0, - neu_json_encode_by_fn(&resp, neu_json_encode_group_configs_resp, - &result)); - EXPECT_EQ(0, - neu_json_encode_by_fn(&resp2, neu_json_encode_group_configs_resp, - &result2)); - - EXPECT_STREQ(buf, result); - EXPECT_STREQ(buf2, result2); - - free(resp.adapter_name); - free(resp.group_config_name); - - free(resp2.adapter_name); - free(resp2.group_config_name); - - free(result); - free(result2); -} - -int main(int argc, char **argv) -{ - zlog_init("./config/dev.conf"); - neuron = zlog_get_category("neuron"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file diff --git a/tests/json_plugin_test.cc b/tests/json_plugin_test.cc deleted file mode 100644 index cf7d7533..00000000 --- a/tests/json_plugin_test.cc +++ /dev/null @@ -1,95 +0,0 @@ -#include - -#include - -#include "json/neu_json_fn.h" -#include "json/neu_json_plugin.h" - -#include "adapter.h" -#include "utils/log.h" - -zlog_category_t *neuron = NULL; - -TEST(JsonPluginTest, AddPluginDecode) -{ - char * buf = (char *) "{\"lib_name\": \"lib1\" }"; - neu_json_add_plugin_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_add_plugin_req(buf, &req)); - - EXPECT_STREQ("lib1", req->lib_name); - - neu_json_decode_add_plugin_req_free(req); -} - -TEST(JsonPluginTest, DeletePluginDecode) -{ - char * buf = (char *) "{\"id\": 1 }"; - neu_json_del_plugin_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_del_plugin_req(buf, &req)); - - EXPECT_EQ(1, req->id); - - neu_json_decode_del_plugin_req_free(req); -} - -TEST(JsonPluginTest, GetPluginEncode) -{ - char *buf = - (char *) "{\"plugin_libs\": [{\"node_type\": 1, \"name\": \"plugin1\", " - "\"lib_name\": \"lib1\", \"kind\": 1, \"id\": 123}, " - "{\"node_type\": 1, \"name\": \"plugin2\", \"lib_name\": " - "\"lib2\", \"kind\": 1, \"id\": 456}, {\"node_type\": 1, " - "\"name\": \"plugin3\", \"lib_name\": \"lib3\", \"kind\": 1, " - "\"id\": 789}]}"; - char *result = NULL; - - neu_json_get_plugin_resp_t res = { - .n_plugin_lib = 3, - }; - - res.plugin_libs = (neu_json_get_plugin_resp_plugin_lib_t *) calloc( - 3, sizeof(neu_json_get_plugin_resp_plugin_lib_t)); - - res.plugin_libs[0].id = 123; - res.plugin_libs[0].kind = PLUGIN_KIND_SYSTEM; - res.plugin_libs[0].node_type = NEU_NA_TYPE_DRIVER; - res.plugin_libs[0].name = strdup((char *) "plugin1"); - res.plugin_libs[0].lib_name = strdup((char *) "lib1"); - - res.plugin_libs[1].id = 456; - res.plugin_libs[1].kind = PLUGIN_KIND_SYSTEM; - res.plugin_libs[1].node_type = NEU_NA_TYPE_DRIVER; - res.plugin_libs[1].name = strdup((char *) "plugin2"); - res.plugin_libs[1].lib_name = strdup((char *) "lib2"); - - res.plugin_libs[2].id = 789; - res.plugin_libs[2].kind = PLUGIN_KIND_SYSTEM; - res.plugin_libs[2].node_type = NEU_NA_TYPE_DRIVER; - res.plugin_libs[2].name = strdup((char *) "plugin3"); - res.plugin_libs[2].lib_name = strdup((char *) "lib3"); - - EXPECT_EQ( - 0, - neu_json_encode_by_fn(&res, neu_json_encode_get_plugin_resp, &result)); - EXPECT_STREQ(buf, result); - - free(res.plugin_libs[0].name); - free(res.plugin_libs[0].lib_name); - free(res.plugin_libs[1].name); - free(res.plugin_libs[1].lib_name); - free(res.plugin_libs[2].name); - free(res.plugin_libs[2].lib_name); - free(res.plugin_libs); - - free(result); -} - -int main(int argc, char **argv) -{ - zlog_init("./config/dev.conf"); - neuron = zlog_get_category("neuron"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file diff --git a/tests/json_rw_test.cc b/tests/json_rw_test.cc deleted file mode 100644 index a0025e51..00000000 --- a/tests/json_rw_test.cc +++ /dev/null @@ -1,87 +0,0 @@ -#include - -#include - -#include "json/neu_json_fn.h" -#include "json/neu_json_mqtt.h" -#include "json/neu_json_rw.h" - -#include "utils/log.h" - -zlog_category_t *neuron = NULL; - -TEST(JsonAPITest, ReadReqDecode) -{ - char *buf = (char *) "{\"command\":\"\", " - "\"uuid\":\"554f5fd8-f437-11eb-975c-7704b9e17821\", " - "\"node_name\": \"name1\" ," - "\"group_name\": \"group1\"}"; - neu_json_read_req_t *req = NULL; - neu_json_mqtt_t * mqtt = NULL; - - EXPECT_EQ(0, neu_json_decode_mqtt_req(buf, &mqtt)); - EXPECT_EQ(0, neu_json_decode_read_req(buf, &req)); - - EXPECT_STREQ("554f5fd8-f437-11eb-975c-7704b9e17821", mqtt->uuid); - EXPECT_STREQ("name1", req->node_name); - EXPECT_STREQ("group1", req->group_name); - - neu_json_decode_mqtt_req_free(mqtt); - neu_json_decode_read_req_free(req); -} - -TEST(JsonAPITest, ReadResEncode) -{ - char *buf = (char *) "{\"tags\": [{\"name\": \"data1\", \"value\": 123}, " - "{\"name\": \"data2\", \"value\": 11.123456789}]}"; - char * result = NULL; - neu_json_read_resp_t res = { - .n_tag = 2, - }; - - res.tags = (neu_json_read_resp_tag_t *) calloc( - 2, sizeof(neu_json_read_resp_tag_t)); - res.tags[0].name = strdup((char *) "data1"); - res.tags[0].t = NEU_JSON_INT; - res.tags[0].value.val_int = 123; - - res.tags[1].name = strdup((char *) "data2"); - res.tags[1].t = NEU_JSON_DOUBLE; - res.tags[1].value.val_double = 11.123456789; - - EXPECT_EQ(0, - neu_json_encode_by_fn(&res, neu_json_encode_read_resp, &result)); - EXPECT_STREQ(buf, result); - - free(res.tags[0].name); - free(res.tags[1].name); - free(res.tags); - free(result); -} - -TEST(JsonAPITest, WriteReqDecode) -{ - char *buf = (char *) "{\"node_name\": \"name1\", \"group_name\": " - "\"config_opcua_sample\", \"tag_name\": \"name1\", " - "\"value\": \"hello world\"}"; - neu_json_write_req_t *req = NULL; - - EXPECT_EQ(0, neu_json_decode_write_req(buf, &req)); - - EXPECT_STREQ("name1", req->node_name); - - EXPECT_STREQ("config_opcua_sample", req->group_name); - - EXPECT_STREQ("name1", req->tag_name); - EXPECT_STREQ("hello world", req->value.val_str); - - neu_json_decode_write_req_free(req); -} - -int main(int argc, char **argv) -{ - zlog_init("./config/dev.conf"); - neuron = zlog_get_category("neuron"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file diff --git a/tests/json_test.cc b/tests/json_test.cc index 821cf014..0510ef84 100644 --- a/tests/json_test.cc +++ b/tests/json_test.cc @@ -11,26 +11,28 @@ TEST(JsonTest, DecodeField) (char *) "{\"field1\": true, \"field2\": false, \"field3\": 12345, " "\"field4\": 11.223, \"field5\": \"hello world\"}"; - neu_json_elem_t elems[] = { { - .name = (char *) "field1", - .t = NEU_JSON_BOOL, - }, - { - .name = (char *) "field2", - .t = NEU_JSON_BOOL, - }, - { - .name = (char *) "field3", - .t = NEU_JSON_INT, - }, - { - .name = (char *) "field4", - .t = NEU_JSON_DOUBLE, - }, - { - .name = (char *) "field5", - .t = NEU_JSON_STR, - } }; + neu_json_elem_t elems[] = { + { + .name = (char *) "field1", + .t = NEU_JSON_BOOL, + }, + { + .name = (char *) "field2", + .t = NEU_JSON_BOOL, + }, + { + .name = (char *) "field3", + .t = NEU_JSON_INT, + }, + { + .name = (char *) "field4", + .t = NEU_JSON_DOUBLE, + }, + { + .name = (char *) "field5", + .t = NEU_JSON_STR, + }, + }; EXPECT_EQ(5, sizeof(elems) / sizeof(neu_json_elem_t)); EXPECT_EQ(5, NEU_JSON_ELEM_SIZE(elems)); EXPECT_EQ(0, neu_json_decode(buf, NEU_JSON_ELEM_SIZE(elems), elems)); diff --git a/tests/variable_test.cc b/tests/variable_test.cc deleted file mode 100644 index caf202d0..00000000 --- a/tests/variable_test.cc +++ /dev/null @@ -1,296 +0,0 @@ -#include - -#include "types.h" - -#include "utils/log.h" - -zlog_category_t *neuron = NULL; - -TEST(VariableTest, neu_variable_create) -{ - neu_variable_t *v = neu_variable_create(); - EXPECT_NE(v, nullptr); - neu_variable_destroy(v); -} - -TEST(VariableTest, neu_variable_count) -{ - neu_variable_t *v = neu_variable_create(); - size_t count = neu_variable_count(v); - EXPECT_EQ(NULL, v->key); - EXPECT_EQ(1, count); - neu_variable_destroy(v); -} - -TEST(VariableTest, neu_variable_set_byte) -{ - neu_variable_t *v = neu_variable_create(); - int rc = neu_variable_set_byte(v, 16); - EXPECT_EQ(0, rc); - int8_t ret; - rc = neu_variable_get_byte(v, &ret); - EXPECT_EQ(0, rc); - EXPECT_EQ(16, ret); - neu_variable_destroy(v); -} - -TEST(VariableTest, neu_variable_set_qword) -{ - neu_variable_t *v = neu_variable_create(); - int rc = neu_variable_set_qword(v, 100010111010); - EXPECT_EQ(0, rc); - int64_t ret; - rc = neu_variable_get_qword(v, &ret); - EXPECT_EQ(0, rc); - EXPECT_EQ(100010111010, ret); - neu_variable_destroy(v); -} - -TEST(VariableTest, neu_variable_set_double) -{ - neu_variable_t *v = neu_variable_create(); - int rc = neu_variable_set_double(v, 100010111010.010603); - EXPECT_EQ(0, rc); - double ret; - rc = neu_variable_get_double(v, &ret); - EXPECT_EQ(0, rc); - EXPECT_EQ(100010111010.010603, ret); - neu_variable_destroy(v); -} - -TEST(VariableTest, neu_variable_set_string) -{ - neu_variable_t *v = neu_variable_create(); - int rc = neu_variable_set_string(v, "Hello, Neuron!"); - EXPECT_EQ(0, rc); - char * ret = NULL; - size_t len; - rc = neu_variable_get_string(v, &ret, &len); - EXPECT_EQ(0, rc); - EXPECT_STREQ("Hello, Neuron!", ret); - neu_variable_destroy(v); -} - -TEST(VariableTest, neu_variable_add_item) -{ - neu_variable_t *v = neu_variable_create(); - neu_variable_t *i0 = neu_variable_create(); - neu_variable_t *i1 = neu_variable_create(); - neu_variable_t *i2 = neu_variable_create(); - neu_variable_t *i3 = neu_variable_create(); - neu_variable_t *i4 = neu_variable_create(); - - EXPECT_EQ(0, neu_variable_add_item(v, i0)); - EXPECT_EQ(0, neu_variable_add_item(v, i1)); - EXPECT_EQ(0, neu_variable_add_item(v, i2)); - EXPECT_EQ(0, neu_variable_add_item(v, i3)); - EXPECT_EQ(0, neu_variable_add_item(v, i4)); - - size_t count = neu_variable_count(v); - EXPECT_EQ(6, count); - neu_variable_destroy(v); -} - -TEST(VariableTest, neu_variable_get_item) -{ - neu_variable_t *v = neu_variable_create(); - - neu_variable_t *i0 = neu_variable_create(); - neu_variable_set_qword(i0, 100); - neu_variable_set_error(i0, 0); - - neu_variable_t *i1 = neu_variable_create(); - neu_variable_set_double(i1, 100010111010.010603); - neu_variable_set_error(i1, 0); - - neu_variable_t *i2 = neu_variable_create(); - neu_variable_set_string(i2, "Read Error"); - neu_variable_set_error(i2, 10); - - EXPECT_EQ(0, neu_variable_add_item(v, i0)); - EXPECT_EQ(0, neu_variable_add_item(v, i1)); - EXPECT_EQ(0, neu_variable_add_item(v, i2)); - - size_t count = neu_variable_count(v); - EXPECT_EQ(4, count); - - neu_variable_t *ii0 = NULL; - neu_variable_t *ii1 = NULL; - neu_variable_t *ii2 = NULL; - int rc = neu_variable_get_item(v, 1, &ii0); - EXPECT_EQ(0, rc); - int64_t ret_qword; - rc = neu_variable_get_qword(ii0, &ret_qword); - EXPECT_EQ(0, rc); - EXPECT_EQ(100, ret_qword); - - rc = neu_variable_get_item(v, 2, &ii1); - EXPECT_EQ(0, rc); - double ret_double; - rc = neu_variable_get_double(ii1, &ret_double); - EXPECT_EQ(0, rc); - EXPECT_EQ(100010111010.010603, ret_double); - - rc = neu_variable_get_item(v, 3, &ii2); - EXPECT_EQ(0, rc); - char * ret_string = NULL; - size_t len; - rc = neu_variable_get_string(ii2, &ret_string, &len); - EXPECT_EQ(0, rc); - EXPECT_STREQ("Read Error", ret_string); - - neu_variable_destroy(v); -} - -TEST(VariableTest, neu_variable_serialize) -{ - neu_variable_t *v = neu_variable_create(); - neu_variable_set_qword(v, 100); - neu_variable_set_error(v, 0); - neu_variable_set_key(v, ""); - - void * buf; - size_t len = neu_variable_serialize(v, &buf); - EXPECT_EQ(32, len); - neu_variable_serialize_free(buf); - - buf = NULL; - neu_variable_t *i2 = neu_variable_create(); - neu_variable_set_string(i2, "Read Error."); - neu_variable_set_error(i2, 10); - char *key2 = (char *) "h8438945u3trheofnfeigfewojgeohgeof"; - neu_variable_set_key(i2, key2); - neu_variable_add_item(v, i2); - len = neu_variable_serialize(v, &buf); - EXPECT_EQ(68 + strlen(key2), len); - neu_variable_serialize_free(buf); - - buf = NULL; - neu_variable_t *i1 = neu_variable_create(); - neu_variable_set_double(i1, 100010111010.010603); - neu_variable_set_error(i1, 0); - char *key1 = (char *) "===========fnfeigfewojgeohgeof"; - neu_variable_set_key(i1, key1); - neu_variable_add_item(v, i1); - len = neu_variable_serialize(v, &buf); - EXPECT_EQ(100 + strlen(key2) + strlen(key1), len); - neu_variable_serialize_free(buf); - - neu_variable_destroy(v); -} - -TEST(VariableTest, neu_variable_deserialize) -{ - neu_variable_t *v = neu_variable_create(); - neu_variable_set_qword(v, 100); - neu_variable_set_error(v, 0); - neu_variable_set_key(v, ""); - - neu_variable_t *i1 = neu_variable_create(); - neu_variable_set_string(i1, "Read Error."); - neu_variable_set_error(i1, 10); - char *key1 = (char *) "`13232edsjferuuu88****#$%^&"; - neu_variable_set_key(i1, key1); - neu_variable_add_item(v, i1); - - neu_variable_t *i2 = neu_variable_create(); - neu_variable_set_double(i2, 100010111010.010603); - neu_variable_set_error(i2, 0); - char *key2 = (char *) "`@#$%^&*&*()13232edsjferuuu88****#$%^&"; - neu_variable_set_key(i2, key2); - neu_variable_add_item(v, i2); - - void * buf; - size_t len = neu_variable_serialize(v, &buf); - EXPECT_EQ(100 + strlen(key1) + strlen(key2), len); - - neu_variable_t *vv = neu_variable_deserialize(buf, len); - EXPECT_NE(nullptr, vv); - size_t count = neu_variable_count(vv); - EXPECT_EQ(3, count); - char *kkey = NULL; - neu_variable_get_key(vv, &kkey); - EXPECT_EQ(NULL, kkey); - - neu_variable_t *ii0 = NULL; - neu_variable_t *ii1 = NULL; - neu_variable_t *ii2 = NULL; - int rc = neu_variable_get_item(v, 0, &ii0); - EXPECT_EQ(0, rc); - int64_t ret_qword; - rc = neu_variable_get_qword(ii0, &ret_qword); - EXPECT_EQ(0, rc); - EXPECT_EQ(100, ret_qword); - - char *kkey0 = NULL; - neu_variable_get_key(ii0, &kkey0); - EXPECT_EQ(NULL, kkey0); - - rc = neu_variable_get_item(v, 1, &ii1); - EXPECT_EQ(0, rc); - char * ret_string = NULL; - size_t len_string; - rc = neu_variable_get_string(ii1, &ret_string, &len_string); - EXPECT_EQ(0, rc); - EXPECT_STREQ("Read Error.", ret_string); - - char *kkey1 = NULL; - neu_variable_get_key(ii1, &kkey1); - EXPECT_STREQ(key1, kkey1); - - rc = neu_variable_get_item(v, 2, &ii2); - EXPECT_EQ(0, rc); - double ret_double; - rc = neu_variable_get_double(ii2, &ret_double); - EXPECT_EQ(0, rc); - EXPECT_EQ(100010111010.010603, ret_double); - - char *kkey2 = NULL; - neu_variable_get_key(ii2, &kkey2); - EXPECT_STREQ(key2, kkey2); - - neu_variable_destroy(vv); - neu_variable_serialize_free(buf); - neu_variable_destroy(v); -} - -TEST(VariableTest, neu_variable_set_key) -{ - neu_variable_t *v = neu_variable_create(); - neu_variable_set_qword(v, 100); - neu_variable_set_error(v, 0); - neu_variable_set_key(v, ""); - char *key = NULL; - neu_variable_get_key(v, &key); - EXPECT_EQ(NULL, key); - - neu_variable_t *i1 = neu_variable_create(); - neu_variable_set_string(i1, "Read Error."); - neu_variable_set_error(i1, 10); - neu_variable_set_key(i1, "1000"); - key = NULL; - neu_variable_get_key(i1, &key); - EXPECT_STREQ("1000", key); - - neu_variable_add_item(v, i1); - - neu_variable_t *i2 = neu_variable_create(); - neu_variable_set_double(i2, 100010111010.010603); - neu_variable_set_error(i2, 0); - neu_variable_set_key(i2, "xaijerjgj--3erjier?ien555"); - key = NULL; - neu_variable_get_key(i2, &key); - EXPECT_STREQ("xaijerjgj--3erjier?ien555", key); - - neu_variable_add_item(v, i2); - - neu_variable_destroy(v); -} - -int main(int argc, char **argv) -{ - zlog_init("./config/dev.conf"); - neuron = zlog_get_category("neuron"); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} \ No newline at end of file