From 1a498e26da178577f1ed6c565406fa0ee4d40a81 Mon Sep 17 00:00:00 2001 From: Jihoon Jung Date: Tue, 1 Sep 2020 15:48:17 +0900 Subject: [PATCH] Add gtest for coverage and auto test Change-Id: I82eb9117e1fe4a7831fa591ea62e2acc992b8039 Signed-off-by: Jihoon Jung --- CMakeLists.txt | 5 +- packaging/capi-network-uwb.spec | 7 +- src/CMakeLists.txt | 1 + src/uwb-util.c | 4 + src/uwb.c | 36 ++ tests/CMakeLists.txt | 38 +- tests/capi-network-uwb-gtest.cpp | 872 +++++++++++++++++++++++++++++++++++++++ tests/capi-network-uwb-test.c | 6 +- tests/mocks/uwb_mock.c | 258 ++++++++++++ 9 files changed, 1218 insertions(+), 9 deletions(-) create mode 100755 tests/capi-network-uwb-gtest.cpp create mode 100755 tests/mocks/uwb_mock.c diff --git a/CMakeLists.txt b/CMakeLists.txt index b430e62..24c177f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -27,12 +27,13 @@ INCLUDE(FindPkgConfig) SET(COMMON_DEPS "dlog glib-2.0 gio-2.0 gio-unix-2.0 capi-system-info") SET(PC_DEPS "capi-base-common") +SET(GTEST_DEPS "capi-base-common dlog capi-system-info glib-2.0 gio-unix-2.0 gmock") SET(TEST_DEPS "glib-2.0") -SET(GTEST_DEPS "gmock") SET(TARGET_UWB "capi-network-uwb") -SET(TARGET_UWB_TEST "capi-network-uwb-test") +SET(TARGET_UWB_MOCK "uwb-mock") SET(TARGET_UWB_GTEST "capi-network-uwb-gtest") +SET(TARGET_UWB_TEST "capi-network-uwb-test") ADD_DEFINITIONS("-DUSE_DLOG") diff --git a/packaging/capi-network-uwb.spec b/packaging/capi-network-uwb.spec index 25a9794..56ae13f 100644 --- a/packaging/capi-network-uwb.spec +++ b/packaging/capi-network-uwb.spec @@ -92,9 +92,10 @@ tar xf %{name}-gcov.tar -C %{buildroot}%{_datadir}/gcov/obj %endif %check -#tests/%{name}-gtest %if 0%{?gcov:1} -lcov -c --ignore-errors graph --no-external -b . -d . -o %{name}.info +LD_PRELOAD=./tests/libuwb-mock.so tests/%{name}-gtest +lcov -c --ignore-errors graph --no-external -b . -d . \ +--exclude "/home/abuild/rpmbuild/BUILD/%{name}-%{version}/src/uwb-gdbus.c" -o %{name}.info genhtml %{name}.info -o out --legend --show-details %endif @@ -117,7 +118,7 @@ genhtml %{name}.info -o out --legend --show-details %files tests %{_bindir}/%{name}-test -#%{_bindir}/%{name}-gtest +%{_bindir}/%{name}-gtest %if 0%{?gcov:1} %files gcov diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 3c99212..cc9a8b6 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -6,6 +6,7 @@ PKG_CHECK_MODULES(UWB_DEPS REQUIRED ${COMMON_DEPS}) SET(EXTRA_FLAGS "-fPIC -Wall -Werror -fvisibility=hidden") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_FLAGS}") +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_FLAGS}") SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lpthread -pie") ######################## directory configuration ############################ diff --git a/src/uwb-util.c b/src/uwb-util.c index 96f52d1..6a901e7 100755 --- a/src/uwb-util.c +++ b/src/uwb-util.c @@ -20,6 +20,7 @@ #include #include +/* LCOV_EXCL_START */ void _node_free_func(gpointer data) { uwb_node_s *node = (uwb_node_s *)data; @@ -27,6 +28,7 @@ void _node_free_func(gpointer data) free(node); node = NULL; } +/* LCOV_EXCL_STOP */ void uwb_util_destroy_network(uwb_network_s *network) { @@ -47,8 +49,10 @@ uwb_node_s *uwb_util_get_node_from_variant(GVariant *va) uwb_node_s *node = calloc(1, sizeof(uwb_node_s)); if (NULL == node) { + /* LCOV_EXCL_START */ _ERR("Memory allocation failed"); return NULL; + /* LCOV_EXCL_STOP */ } g_variant_get(va, "a{sv}", &iter); diff --git a/src/uwb.c b/src/uwb.c index 752d305..c4bf9ec 100755 --- a/src/uwb.c +++ b/src/uwb.c @@ -41,6 +41,7 @@ static struct _uwb_ctx { uwb_network_foreach_remote_node_cb foreach_remote_node_cb; } uwb_ctx = {NULL,}; +/* LCOV_EXCL_START */ static inline void __handle_error(GError *error, int *ret) { if (!error) @@ -111,6 +112,7 @@ static void __position_changed(GObject *source_object, if (uwb_ctx.position_changed_cb != NULL) uwb_ctx.position_changed_cb(node_id, x, y, z, uwb_ctx.position_changed_user_data); } +/* LCOV_EXCL_STOP */ static int manager_proxy_init(void) { @@ -191,8 +193,10 @@ EXPORT_API int uwb_reset(void) _BEGIN(); if (manager_call_reset_sync(uwb_ctx.manager_proxy, NULL, &error) == FALSE) { + /* LCOV_EXCL_START */ _ERR("manager_call_reset_sync failed : %s", error->message); __handle_error(error, &ret); + /* LCOV_EXCL_STOP */ } _END(); @@ -211,8 +215,10 @@ EXPORT_API int uwb_factory_reset(void) _BEGIN(); if (manager_call_factory_reset_sync(uwb_ctx.manager_proxy, NULL, &error) == FALSE) { + /* LCOV_EXCL_START */ _ERR("manager_call_factory_reset_sync failed : %s", error->message); __handle_error(error, &ret); + /* LCOV_EXCL_STOP */ } _END(); @@ -225,6 +231,7 @@ EXPORT_API int uwb_set_message_received_cb(uwb_message_received_cb message_recei int ret = UWB_ERROR_NONE; CHECK_FEATURE_SUPPORTED(UWB_FEATURE); + uwb_check_null_ret_error("message_received_cb", message_received_cb, UWB_ERROR_INVALID_PARAMETER); _BEGIN(); @@ -241,6 +248,7 @@ EXPORT_API int uwb_set_position_changed_cb(uwb_position_changed_cb position_chan int ret = UWB_ERROR_NONE; CHECK_FEATURE_SUPPORTED(UWB_FEATURE); + uwb_check_null_ret_error("position_changed_cb", position_changed_cb, UWB_ERROR_INVALID_PARAMETER); _BEGIN(); @@ -300,13 +308,17 @@ EXPORT_API int uwb_get_own_node(uwb_node_h *own_node) if (manager_call_get_own_node_sync(uwb_ctx.manager_proxy, &own_node_va, NULL, &error) == FALSE) { + /* LCOV_EXCL_START */ __handle_error(error, &ret); + /* LCOV_EXCL_STOP */ } + /* LCOV_EXCL_START */ if (ret == UWB_ERROR_NONE && own_node_va != NULL) *_own_node = uwb_util_get_node_from_variant(own_node_va); else *_own_node = NULL; + /* LCOV_EXCL_STOP */ _END(); @@ -327,8 +339,10 @@ EXPORT_API int uwb_node_set_position(uwb_node_h node, int x, int y, int z) if (manager_call_set_position_sync(uwb_ctx.manager_proxy, ((uwb_node_s *)node)->node_id, x, y, z, NULL, &error) == FALSE) { + /* LCOV_EXCL_START */ _ERR("manager_call_set_position_sync failed : %s", error->message); __handle_error(error, &ret); + /* LCOV_EXCL_STOP */ } _END(); @@ -369,8 +383,10 @@ EXPORT_API int uwb_node_send_message(const unsigned char *message, int len) if (manager_call_send_message_sync(uwb_ctx.manager_proxy, msg, len, NULL, &error) == FALSE) { + /* LCOV_EXCL_START */ _ERR("manager_call_send_message_sync failed : %s", error->message); __handle_error(error, &ret); + /* LCOV_EXCL_STOP */ } _END(); @@ -397,8 +413,10 @@ EXPORT_API int uwb_node_send_message_to(uwb_node_h node, const unsigned char *me if (manager_call_send_message_to_sync(uwb_ctx.manager_proxy, ((uwb_node_s *)node)->node_id, msg, len, NULL, &error) == FALSE) { + /* LCOV_EXCL_START */ _ERR("manager_call_send_message_to_sync failed : %s", error->message); __handle_error(error, &ret); + /* LCOV_EXCL_STOP */ } _END(); @@ -415,8 +433,10 @@ static int __get_configurations(uwb_node_h node, const char *key, if (manager_call_get_configurations_sync(uwb_ctx.manager_proxy, ((uwb_node_s *)node)->node_id, &va, NULL, &error) == FALSE) { + /* LCOV_EXCL_START */ _ERR("__get_configurations failed : %s", error->message); __handle_error(error, &ret); + /* LCOV_EXCL_STOP */ } else { *va_out = g_variant_lookup_value(va, key, va_type); } @@ -438,10 +458,12 @@ EXPORT_API int uwb_node_get_configuration_int32(uwb_node_h node, const char *key ret = __get_configurations(node, key, G_VARIANT_TYPE_INT32, &value_va); + /* LCOV_EXCL_START */ if (value_va != NULL) *value = g_variant_get_int32(value_va); else *value = 0; + /* LCOV_EXCL_STOP */ _END(); @@ -462,10 +484,12 @@ EXPORT_API int uwb_node_get_configuration_int64(uwb_node_h node, const char *key ret = __get_configurations(node, key, G_VARIANT_TYPE_INT64, &value_va); + /* LCOV_EXCL_START */ if (value_va != NULL) *value = g_variant_get_int64(value_va); else *value = 0; + /* LCOV_EXCL_STOP */ _END(); @@ -506,8 +530,10 @@ static int __set_configuration(uwb_node_h node, GVariant *va) if (manager_call_set_configurations_sync(uwb_ctx.manager_proxy, ((uwb_node_s *)node)->node_id, va, NULL, &error) == FALSE) { + /* LCOV_EXCL_START */ _ERR("__set_configurations : %s", error->message); __handle_error(error, &ret); + /* LCOV_EXCL_STOP */ } return ret; @@ -746,6 +772,7 @@ static void __get_network_cb(GObject *source_object, GAsyncResult *res, gpointer &remote_node_list_va, res, &error) == FALSE) { + /* LCOV_EXCL_START */ _ERR("manager_call_get_network_info_finish failed : %s", error->message); __handle_error(error, &ret); @@ -754,6 +781,7 @@ static void __get_network_cb(GObject *source_object, GAsyncResult *res, gpointer } return; + /* LCOV_EXCL_STOP */ } /* create network handle */ @@ -765,6 +793,7 @@ static void __get_network_cb(GObject *source_object, GAsyncResult *res, gpointer network_s->remote_node_count = g_variant_n_children(remote_node_list_va); if (network_s->remote_node_count > 0) { + /* LCOV_EXCL_START */ GVariantIter *iter = NULL; GVariant *nodes_va = NULL; @@ -779,6 +808,7 @@ static void __get_network_cb(GObject *source_object, GAsyncResult *res, gpointer remote_node_list = g_slist_append(remote_node_list, node); } g_variant_iter_free(iter); + /* LCOV_EXCL_STOP */ } network_s->remote_node_list = remote_node_list; @@ -810,6 +840,7 @@ EXPORT_API int uwb_get_network(uwb_get_network_finished_cb finished_cb, void *us return ret; } +/* LCOV_EXCL_START */ static gpointer __copy_node(gconstpointer src, gpointer data) { if (!src) @@ -830,6 +861,7 @@ static gpointer __copy_node(gconstpointer src, gpointer data) return (gpointer)dst_ptr; } +/* LCOV_EXCL_STOP */ EXPORT_API int uwb_network_clone(uwb_network_h source, uwb_network_h *target) { @@ -846,8 +878,10 @@ EXPORT_API int uwb_network_clone(uwb_network_h source, uwb_network_h *target) result_network = (uwb_network_s *)malloc(sizeof(uwb_network_s)); if (result_network == NULL) { + /* LCOV_EXCL_START */ _ERR("malloc failed"); return UWB_ERROR_OPERATION_FAILED; + /* LCOV_EXCL_STOP */ } result_network->pan_id = src_network->pan_id; @@ -916,6 +950,7 @@ EXPORT_API int uwb_network_get_remote_node_count(uwb_network_h network, int *rem return ret; } +/* LCOV_EXCL_START */ static void __foreach_node(gpointer data, gpointer user_data) { uwb_node_s *node = (uwb_node_s *)data; @@ -949,3 +984,4 @@ EXPORT_API int uwb_network_foreach_remote_node(uwb_network_h network, return ret; } +/* LCOV_EXCL_STOP */ diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index da32239..f7e6703 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,6 +1,42 @@ ########################## search for packages ################################ -PKG_CHECK_MODULES(TARGET_UWB_TEST_REQ_PKGS REQUIRED glib-2.0) +PKG_CHECK_MODULES(TARGET_UWB_GTEST_REQ_PKGS REQUIRED ${GTEST_DEPS}) + +############################# compiler flags ################################## + +SET(EXTRA_FLAGS "-Wall -Werror") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} ${CFLAGS} -fPIE -fPIC") +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXXFLAGS} ${CXXFLAGS} -fPIE -fPIC") +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -pie") + +######################## directory configuration ############################ + +INCLUDE_DIRECTORIES(${TARGET_UWB_GTEST_REQ_PKGS_INCLUDE_DIRS}) +LINK_DIRECTORIES(${TARGET_UWB_GTEST_REQ_PKGS_LIBRARY_DIRS}) + +INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/include) + +SET(TARGET_UWB_MOCK_SRCS + mocks/uwb_mock.c) +SET(TARGET_UWB_MOCK_CFLAGS "${CMAKE_C_FLAGS}" ) +ADD_LIBRARY(${TARGET_UWB_MOCK} SHARED ${TARGET_UWB_MOCK_SRCS}) +SET_TARGET_PROPERTIES(${TARGET_UWB_MOCK} PROPERTIES + COMPILE_FLAGS ${TARGET_UWB_MOCK_CFLAGS} +) + +# Build +ADD_EXECUTABLE(${TARGET_UWB_GTEST} + ${CMAKE_CURRENT_SOURCE_DIR}/capi-network-uwb-gtest.cpp +) + +TARGET_LINK_LIBRARIES(${TARGET_UWB_GTEST} + ${TARGET_UWB_GTEST_REQ_PKGS_LIBRARIES} ${PROJECT_NAME}) + +#Install +INSTALL(PROGRAMS ${TARGET_UWB_GTEST} DESTINATION ${BIN_DIR}) +########################## search for packages ################################ + +PKG_CHECK_MODULES(TARGET_UWB_TEST_REQ_PKGS REQUIRED ${TEST_DEPS}) ############################# compiler flags ################################## diff --git a/tests/capi-network-uwb-gtest.cpp b/tests/capi-network-uwb-gtest.cpp new file mode 100755 index 0000000..69613cd --- /dev/null +++ b/tests/capi-network-uwb-gtest.cpp @@ -0,0 +1,872 @@ +/* + * gtest-uwb.cpp + * + * Copyright (c) 2020 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jihoon Jung + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +/***************************************************************************** + * Standard headers + *****************************************************************************/ + +/***************************************************************************** + * System headers + *****************************************************************************/ +#include +#include +/***************************************************************************** + * Local headers + *****************************************************************************/ +#include + +/***************************************************************************** + * Macros and Typedefs + *****************************************************************************/ +/***************************************************************************** + * Global Variables + *****************************************************************************/ +/***************************************************************************** + * Local Functions Definition + *****************************************************************************/ + +class UwbManagerTest : public ::testing::Test { +protected: + void SetUp() override + { + uwb_initialize(); + } + + void TearDown() override + { + uwb_deinitialize(); + } +}; + +TEST_F(UwbManagerTest, uwb_initialize_Positive) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbManagerTest, uwb_initialize_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_ALREADY_INITIALIZED, ret); +} + +TEST_F(UwbManagerTest, uwb_deinitialize_Positive) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbManagerTest, uwb_deinitialize_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NOT_INITIALIZED, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbManagerTest, uwb_reset_Positive) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_reset(); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbManagerTest, uwb_reset_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_reset(); + EXPECT_EQ(UWB_ERROR_NOT_INITIALIZED, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbManagerTest, uwb_factory_reset_Positive) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_factory_reset(); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbManagerTest, uwb_factory_reset_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_factory_reset(); + EXPECT_EQ(UWB_ERROR_NOT_INITIALIZED, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +void __uwb_message_received_cb(uint64_t node_id, const unsigned char *message, + int message_length, void *user_data) +{ + +} + +TEST_F(UwbManagerTest, uwb_set_message_received_cb_Positive) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_set_message_received_cb(__uwb_message_received_cb, NULL); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbManagerTest, uwb_set_message_received_cb_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_set_message_received_cb(NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +void __uwb_position_changed_cb(uint64_t node_id, int x, int y, int z, + void *user_data) +{ + +} + +TEST_F(UwbManagerTest, uwb_set_position_changed_cb_Positive) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_set_position_changed_cb(__uwb_position_changed_cb, NULL); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbManagerTest, uwb_set_position_changed_cb_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_set_position_changed_cb(NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbManagerTest, uwb_unset_message_received_cb_Positive) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_unset_message_received_cb(); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbManagerTest, uwb_unset_position_changed_cb_Positive) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_unset_position_changed_cb(); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbManagerTest, uwb_get_own_node_Positive) +{ + int ret = UWB_ERROR_NONE; + uwb_node_h own_node = NULL; + + ret = uwb_get_own_node(&own_node); + + if (own_node != NULL) + uwb_node_destroy(own_node); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbManagerTest, uwb_get_own_node_Negative1) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_get_own_node(NULL); + EXPECT_EQ(UWB_ERROR_NOT_INITIALIZED, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbManagerTest, uwb_get_own_node_Negative2) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_get_own_node(NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +GMainLoop *tc_loop; +uwb_network_h _network; + +void __uwb_network_get_finished_cb(int result, uwb_network_h network, void *user_data) +{ + uwb_network_clone(network, &_network); + + uwb_network_destroy(network); + + g_main_loop_quit(tc_loop); + tc_loop = NULL; +} + +class UwbNetworkTest : public ::testing::Test { +protected: + void SetUp() override + { + uwb_initialize(); + + tc_loop = g_main_loop_new(NULL, FALSE); + + uwb_get_network(__uwb_network_get_finished_cb, NULL); + + g_main_loop_run(tc_loop); + } + + void TearDown() override + { + _network = NULL; + + uwb_deinitialize(); + } + +}; + +GMainLoop *tc_loop2; + +void __uwb_network_get_finished_cb2(int result, uwb_network_h network, void *user_data) +{ + g_main_loop_quit(tc_loop2); +} + +TEST_F(UwbNetworkTest, uwb_network_get_Positive) +{ + int ret = UWB_ERROR_NONE; + + tc_loop2 = g_main_loop_new(NULL, FALSE); + + ret = uwb_get_network(__uwb_network_get_finished_cb2, NULL); + + g_main_loop_run(tc_loop2); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNetworkTest, uwb_network_get_Negative1) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_get_network(NULL, NULL); + EXPECT_EQ(UWB_ERROR_NOT_INITIALIZED, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNetworkTest, uwb_network_get_Negative2) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_get_network(NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNetworkTest, uwb_network_clone_Positive) +{ + int ret = UWB_ERROR_NONE; + + uwb_node_h network = NULL; + + ret = uwb_network_clone(_network, &network); + ASSERT_TRUE(network != NULL); + + uwb_network_destroy(network); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNetworkTest, uwb_network_clone_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_network_clone(NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNetworkTest, uwb_network_destroy_Positive) +{ + int ret = UWB_ERROR_NONE; + + uwb_node_h network = NULL; + + uwb_network_clone(_network, &network); + ASSERT_TRUE(network != NULL); + + ret = uwb_network_destroy(network); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNetworkTest, uwb_network_destroy_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_network_destroy(NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNetworkTest, uwb_network_get_pan_id_Positive) +{ + int ret = UWB_ERROR_NONE; + uint64_t pan_id; + + ret = uwb_network_get_pan_id(_network, &pan_id); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNetworkTest, uwb_network_get_pan_id_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_network_get_pan_id(NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNetworkTest, uwb_network_get_remote_node_count_Positive) +{ + int ret = UWB_ERROR_NONE; + int remote_node_count = 0; + + ret = uwb_network_get_remote_node_count(_network, &remote_node_count); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNetworkTest, uwb_network_get_remote_node_count_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_network_get_remote_node_count(NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +bool __uwb_network_foreach_remote_node_cb(uwb_node_h remote_node, void *user_data) +{ + return true; +} + +TEST_F(UwbNetworkTest, uwb_network_foreach_remote_node_Positive) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_network_foreach_remote_node(_network, __uwb_network_foreach_remote_node_cb, NULL); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNetworkTest, uwb_network_foreach_remote_node_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_network_foreach_remote_node(NULL, NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +class UwbNodeTest : public ::testing::Test { +protected: + void SetUp() override + { + uwb_initialize(); + + uwb_get_own_node(&_node); + + strncpy(_key_int32, "TEMP", sizeof(_key_int32)); + strncpy(_key_int64, "NETWORK_TIMEOUT", sizeof(_key_int64)); + strncpy(_key_string, "MODE", sizeof(_key_string)); + } + + void TearDown() override + { + uwb_deinitialize(); + } + + char _key_int32[1024] = {0,}; + char _key_int64[1024] = {0,}; + char _key_string[1024] = {0,}; + uwb_node_h _node; +}; + +TEST_F(UwbNodeTest, uwb_node_clone_Positive) +{ + int ret = UWB_ERROR_NONE; + uwb_node_h node = NULL; + + ret = uwb_node_clone(_node, &node); + ASSERT_TRUE(node != NULL); + + uwb_node_destroy(node); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_clone_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_clone(NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_destroy_Positive) +{ + int ret = UWB_ERROR_NONE; + uwb_node_h node = NULL; + + uwb_get_own_node(&node); + ASSERT_TRUE(node != NULL); + + ret = uwb_node_destroy(node); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_destroy_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_destroy(NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_distance_Positive) +{ + int ret = UWB_ERROR_NONE; + uint64_t distance; + + ret = uwb_node_get_distance(_node, &distance); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_distance_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_get_distance(NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_node_id_Positive) +{ + int ret = UWB_ERROR_NONE; + uint64_t node_id = 0; + + ret = uwb_node_get_node_id(_node, &node_id); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_node_id_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_get_node_id(NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_pan_id_Positive) +{ + int ret = UWB_ERROR_NONE; + uint64_t pan_id; + + ret = uwb_node_get_pan_id(_node, &pan_id); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_pan_id_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_get_pan_id(NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_is_remote_Positive) +{ + int ret = UWB_ERROR_NONE; + bool is_remote = false; + + ret = uwb_node_get_is_remote(_node, &is_remote); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_is_remote_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_get_is_remote(NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_position_Positive) +{ + int ret = UWB_ERROR_NONE; + int x = 0; + int y = 0; + int z = 0; + + ret = uwb_node_get_position(_node, &x, &y, &z); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_position_Negative) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_get_position(NULL, NULL, NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_set_position_Positive) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_set_position(_node, 1, 2, 3); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_set_position_Negative1) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_node_set_position(NULL, 0, 0, 0); + EXPECT_EQ(UWB_ERROR_NOT_INITIALIZED, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_set_position_Negative2) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_set_position(NULL, 0, 0, 0); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_send_message_Positive) +{ + int ret = UWB_ERROR_NONE; + const unsigned char message[1024] = {0x00, 0x01, 0x02}; + + ret = uwb_node_send_message(message, sizeof(message)); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_send_message_Negative1) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_node_send_message(NULL, 0); + EXPECT_EQ(UWB_ERROR_NOT_INITIALIZED, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_send_message_Negative2) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_send_message(NULL, 0); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_send_message_to_Positive) +{ + int ret = UWB_ERROR_NONE; + const unsigned char message[1024] = {0x00, 0x01, 0x02}; + + ret = uwb_node_send_message_to(_node, message, sizeof(message)); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_send_message_to_Negative1) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_node_send_message_to(NULL, NULL, 0); + EXPECT_EQ(UWB_ERROR_NOT_INITIALIZED, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_send_message_to_Negative2) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_send_message_to(NULL, NULL, 0); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_configuration_int32_Positive) +{ + int ret = UWB_ERROR_NONE; + + int value; + + ret = uwb_node_get_configuration_int32(_node, _key_int32, &value); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_configuration_int32_Negative1) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_node_get_configuration_int32(NULL, NULL, NULL); + EXPECT_EQ(UWB_ERROR_NOT_INITIALIZED, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_configuration_int32_Negative2) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_get_configuration_int32(NULL, NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_set_configuration_int32_Positive) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_set_configuration_int32(_node, _key_int32, 0); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_set_configuration_int32_Negative1) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_node_set_configuration_int32(NULL, NULL, 0); + EXPECT_EQ(UWB_ERROR_NOT_INITIALIZED, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_set_configuration_int32_Negative2) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_set_configuration_int32(NULL, NULL, 0); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_configuration_int64_Positive) +{ + int ret = UWB_ERROR_NONE; + int64_t value = 0; + + ret = uwb_node_get_configuration_int64(_node, _key_int64, &value); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_configuration_int64_Negative1) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_node_get_configuration_int64(NULL, NULL, NULL); + EXPECT_EQ(UWB_ERROR_NOT_INITIALIZED, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_configuration_int64_Negative2) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_get_configuration_int64(NULL, NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_set_configuration_int64_Positive) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_set_configuration_int64(_node, _key_int64, 0); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_set_configuration_int64_Negative1) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_node_set_configuration_int64(NULL, NULL, 0); + EXPECT_EQ(UWB_ERROR_NOT_INITIALIZED, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_set_configuration_int64_Negative2) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_set_configuration_int64(NULL, NULL, 0); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_configuration_string_Positive) +{ + int ret = UWB_ERROR_NONE; + char *value = NULL; + + ret = uwb_node_get_configuration_string(_node, _key_string, &value); + + if (value != NULL) + free(value); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_configuration_string_Negative1) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_node_get_configuration_string(NULL, NULL, NULL); + EXPECT_EQ(UWB_ERROR_NOT_INITIALIZED, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_get_configuration_string_Negative2) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_get_configuration_string(NULL, NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +TEST_F(UwbNodeTest, uwb_node_set_configuration_string_Positive) +{ + int ret = UWB_ERROR_NONE; + char conf_str[1024] = {0,}; + + strncpy(conf_str, "HELLO", sizeof(conf_str)); + + ret = uwb_node_set_configuration_string(_node, _key_string, (const char *)conf_str); + + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_set_configuration_string_Negative1) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_deinitialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); + + ret = uwb_node_set_configuration_string(NULL, NULL, NULL); + EXPECT_EQ(UWB_ERROR_NOT_INITIALIZED, ret); + + ret = uwb_initialize(); + ASSERT_EQ(UWB_ERROR_NONE, ret); +} + +TEST_F(UwbNodeTest, uwb_node_set_configuration_string_Negative2) +{ + int ret = UWB_ERROR_NONE; + + ret = uwb_node_set_configuration_string(NULL, NULL, NULL); + ASSERT_EQ(UWB_ERROR_INVALID_PARAMETER, ret); +} + +int main(int argc, char **argv) +{ + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/tests/capi-network-uwb-test.c b/tests/capi-network-uwb-test.c index e8207bb..4c6b47a 100644 --- a/tests/capi-network-uwb-test.c +++ b/tests/capi-network-uwb-test.c @@ -360,9 +360,9 @@ void test_set_position(void) { uwb_node_h own_node = NULL; int ret = 0; - int test_x = 10; - int test_y = 10; - int test_z = 10; + int test_x = 1000; + int test_y = 1000; + int test_z = 1000; RET_IF_LOOP_IS_NULL(); ret = uwb_get_own_node(&own_node); diff --git a/tests/mocks/uwb_mock.c b/tests/mocks/uwb_mock.c new file mode 100755 index 0000000..d1073be --- /dev/null +++ b/tests/mocks/uwb_mock.c @@ -0,0 +1,258 @@ +// +// Copyright (c) 2020 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +#include +#include +#include +#include + +#include +#include + +#ifndef API +#define API __attribute__ ((visibility("default"))) +#endif + +typedef enum { + LOG_ID_INVALID = -1, + LOG_ID_MAIN, + LOG_ID_RADIO, + LOG_ID_SYSTEM, + LOG_ID_APPS, + LOG_ID_KMSG, + LOG_ID_SYSLOG, + LOG_ID_MAX +} log_id_t; + +API int __dlog_print(log_id_t log_id, int prio, const char *tag, const char *fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + vprintf(fmt, ap); + va_end(ap); + printf("\n"); + + return 0; +} + +API int system_info_get_platform_bool(const char *key, bool *value) +{ + *value = true; + return 0; +} + +API gulong g_signal_connect_data(gpointer instance, + const gchar *detailed_signal, + GCallback c_handler, + gpointer data, + GClosureNotify destroy_data, + GConnectFlags connect_flags) +{ + return 0; +} + +API GVariant *g_variant_new(const gchar *format_string, ...) +{ + return (void *)1234; +} + +API gsize g_variant_iter_init(GVariantIter *iter, GVariant *value) +{ + return 0; +} + +API void g_object_unref(gpointer _object) +{ + return; +} + +API gpointer g_initable_new(GType object_type, GCancellable *cancellable, + GError **error, const gchar *first_property_name, ...) +{ + return (void *)1234; +} + +API GTypeInstance *g_type_check_instance_cast(GTypeInstance *type_instance, + GType iface_type) +{ + return (void *)1234; +} + +API GVariant *g_dbus_proxy_call_sync(GDBusProxy *proxy, const gchar *method_name, + GVariant *parameters, GDBusCallFlags flags, gint timeout_msec, GCancellable *cancellable, + GError **error) +{ + return (void *)1234; +} + +API void g_variant_unref (GVariant *value) +{ + return; +} + +GAsyncReadyCallback _callback; + +gboolean __get_network_info_cb(gpointer user_data) +{ + _callback(NULL, NULL, user_data); + + return FALSE; +} + +API void g_dbus_proxy_call (GDBusProxy *proxy, const gchar *method_name, GVariant *parameters, + GDBusCallFlags flags, gint timeout_msec, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) +{ + _callback = callback; + + if (0 == strncmp(method_name, "GetNetworkInfo", strlen(method_name))) { + g_timeout_add_seconds(1, __get_network_info_cb, user_data); + } + + return; +} + +API GVariant *g_dbus_proxy_call_finish(GDBusProxy *proxy, GAsyncResult *res, GError **error) +{ + return (void *)1234; +} + +static GVariant *__create_dummy() +{ + GVariant *va = NULL; + GVariantBuilder *builder = NULL; + + builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}")); + va = g_variant_builder_end(builder); + g_variant_builder_unref(builder); + + return va; +} + +static GVariant *__create_vardict() +{ + GVariant *va = NULL; + GVariantBuilder *builder = NULL; + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(builder, "{sv}", "Distance", g_variant_new_uint64(1)); + g_variant_builder_add(builder, "{sv}", "NodeID", g_variant_new_uint64(2)); + g_variant_builder_add(builder, "{sv}", "PanID", g_variant_new_uint16(3)); + g_variant_builder_add(builder, "{sv}", "X", g_variant_new_int32(4)); + g_variant_builder_add(builder, "{sv}", "Y", g_variant_new_int32(5)); + g_variant_builder_add(builder, "{sv}", "Z", g_variant_new_int32(6)); + + g_variant_builder_add(builder, "{sv}", "MODE", g_variant_new_string("ANCHOR")); + g_variant_builder_add(builder, "{sv}", "NETWORK_TIMEOUT", g_variant_new_int64(1)); + g_variant_builder_add(builder, "{sv}", "HARDWARE_WAIT_TIME", g_variant_new_int64(1)); + g_variant_builder_add(builder, "{sv}", "PANID", g_variant_new_int64(1)); + + va = g_variant_builder_end(builder); + g_variant_builder_unref(builder); + + return va; +} + +int state; +API gboolean g_variant_iter_loop(GVariantIter *iter, const gchar *format_string, ...) +{ + va_list ap; + const gchar **key = NULL; + char _key[1024] = {0,}; + GVariant **value = NULL; + bool ret = true; + + if (0 != strncmp(format_string, "{sv}", strlen(format_string))) + return false; + + va_start(ap, format_string); + key = va_arg(ap, const gchar **); + value = va_arg(ap, GVariant **); + + switch (state) { + case 0: + strncpy(_key, "Distance", sizeof(_key)); + *value = g_variant_new_uint64(1); + break; + case 1: + strncpy(_key, "NodeID", sizeof(_key)); + *value = g_variant_new_uint64(1); + break; + case 2: + strncpy(_key, "PanID", sizeof(_key)); + *value = g_variant_new_uint16(1); + break; + case 3: + strncpy(_key, "X", sizeof(_key)); + *value = g_variant_new_int32(1); + break; + case 4: + strncpy(_key, "Y", sizeof(_key)); + *value = g_variant_new_int32(1); + break; + case 5: + strncpy(_key, "Z", sizeof(_key)); + *value = g_variant_new_int32(1); + break; + default: + ret = false; + } + + if (ret == true) { + *key = (const gchar *)_key; + state += 1; + } else { + state = 0; + } + + va_end(ap); + + return ret; +} + +API void g_variant_get (GVariant *value, const gchar *format_string, ...) +{ + va_list ap; + + if (0 == strncmp(format_string, "(q@aa{sv})", strlen(format_string))) { + guint16 *out_pan_id; + GVariant **out_remote_node_list = NULL; + va_start(ap, format_string); + + out_pan_id = va_arg(ap, guint16 *); + *out_pan_id = 1; + + out_remote_node_list = va_arg(ap, GVariant **); + *out_remote_node_list = __create_dummy(); + + va_end(ap); + } else if (0 == strncmp(format_string, "(@a{sv})", strlen(format_string))) { + GVariant **out_own_node = NULL; + va_start(ap, format_string); + + out_own_node = va_arg(ap, GVariant **); + *out_own_node = __create_vardict(); + + va_end(ap); + } +} + +API gsize g_variant_n_children(GVariant *value) +{ + return 0; +} + +API void g_variant_iter_free (GVariantIter *iter) +{ + return; +} -- 2.7.4