--- /dev/null
+/*
+ * gtest-uwb.cpp
+ *
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Jihoon Jung <jh8801.jung@samsung.com>
+ *
+ * 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 <glib.h>
+#include <gtest/gtest.h>
+/*****************************************************************************
+ * Local headers
+ *****************************************************************************/
+#include <uwb.h>
+
+/*****************************************************************************
+ * 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();
+}
--- /dev/null
+//
+// 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 <stdio.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include <glib.h>
+#include <gio/gio.h>
+
+#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;
+}
projects / platform / core / api / uwb.git / commitdiff