GithubStar/neuron
1
0
Fork 0
mirror of https://github.com/emqx/neuron.git synced 2026-10-17 04:40:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

ut

Browse Source
This commit is contained in:
fengzero
2022-06-09 10:51:41 +00:00
parent 52aef263e6
commit 4f4ae61fa0
11 changed files with 37 additions and 3898 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CMakeLists.txt
+6 -18
View File
@@ -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
tests/CMakeLists.txt
+9 -73
View File
@@ -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)
tests/data_val_test.cc
-2492
View File
File diff suppressed because it is too large Load Diff
tests/json_datatag_table_test.cc
-153
View File
@@ -1,153 +0,0 @@
#include <stdlib.h>
#include <gtest/gtest.h>
#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();
}
tests/json_group_config_test.cc
-114
View File
@@ -1,114 +0,0 @@
#include <cstdlib>
#include <gtest/gtest.h>
#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();
}
tests/json_nodes_test.cc
-108
View File
@@ -1,108 +0,0 @@
#include <stdlib.h>
#include <gtest/gtest.h>
#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();
}
tests/json_persistence_test.cc
-442
View File
@@ -1,442 +0,0 @@
#include <stdlib.h>
#include <gtest/gtest.h>
#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();
}
tests/json_plugin_test.cc
-95
View File
@@ -1,95 +0,0 @@
#include <stdlib.h>
#include <gtest/gtest.h>
#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();
}
tests/json_rw_test.cc
-87
View File
@@ -1,87 +0,0 @@
#include <stdlib.h>
#include <gtest/gtest.h>
#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();
}
tests/json_test.cc
+22 -20
View File
@@ -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));
tests/variable_test.cc
-296
View File
@@ -1,296 +0,0 @@
#include <gtest/gtest.h>
#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();
}