From: Seonah Moon Date: Thu, 18 Jun 2020 07:50:37 +0000 (+0900) Subject: gtest: Add async test cases X-Git-Tag: submit/tizen/20200623.020916^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F79%2F236579%2F4;p=platform%2Fcore%2Fapi%2Fsoftap.git gtest: Add async test cases Change-Id: Ie1bfe6c0db0e4664d35fbb5f69875e0ed1379809 --- diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 05e3eb4..a1c53fe 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,7 +1,7 @@ LINK_DIRECTORIES(${CMAKE_BINARY_DIR}) ADD_DEFINITIONS("-DSOFTAP_GTEST") -pkg_check_modules(gtest_pkgs REQUIRED gmock) +pkg_check_modules(gtest_pkgs REQUIRED gmock glib-2.0) INCLUDE_DIRECTORIES(${gtest_pkgs_INCLUDE_DIRS}) LINK_DIRECTORIES(${gtest_pkgs_LIBRARY_DIRS}) @@ -18,8 +18,11 @@ SET_TARGET_PROPERTIES(${SOFTAP_GTEST} PROPERTIES --wrap=g_bus_get_sync,\ --wrap=g_dbus_connection_signal_subscribe,\ --wrap=g_dbus_connection_signal_unsubscribe,\ ---wrap=g_dbus_proxy_new_sync,\ +--wrap=g_dbus_proxy_call,\ +--wrap=g_dbus_proxy_call_finish,\ --wrap=g_dbus_proxy_call_sync,\ +--wrap=g_dbus_proxy_new_sync,\ +--wrap=g_dbus_proxy_set_default_timeout,\ --wrap=ioctl,\ --wrap=cynara_check,\ --wrap=system_info_get_platform_bool,\ diff --git a/tests/mocks/softap_dummy_client.c b/tests/mocks/softap_dummy_client.c index bfede45..3ae177d 100644 --- a/tests/mocks/softap_dummy_client.c +++ b/tests/mocks/softap_dummy_client.c @@ -24,10 +24,10 @@ #define SOFTAP_STR_INFO_LEN 20 typedef struct { - char ip[SOFTAP_STR_INFO_LEN]; - char mac[SOFTAP_STR_INFO_LEN]; - char *hostname; - time_t tm; + char ip[SOFTAP_STR_INFO_LEN]; + char mac[SOFTAP_STR_INFO_LEN]; + char *hostname; + time_t tm; } __softap_client_h; void softap_mock_create_dummy_client(void **dummy_client) diff --git a/tests/mocks/softap_gdbus.c b/tests/mocks/softap_gdbus.c index 70ff5fc..e723e0e 100644 --- a/tests/mocks/softap_gdbus.c +++ b/tests/mocks/softap_gdbus.c @@ -21,6 +21,32 @@ #include #include +typedef struct { + GAsyncReadyCallback callback; + gpointer user_data; +} gdbus_async_callback_info_s; + +typedef struct { + GDBusSignalCallback callback; + gpointer user_data; +} gdbus_signal_callback_info_s; + +static const char *gdbus_signal_list[SOFTAP_MOCK_GDBUS_SIGNAL_MAX] = { + [SOFTAP_MOCK_GDBUS_SIGNAL_ON] = "soft_ap_on", + [SOFTAP_MOCK_GDBUS_SIGNAL_OFF] = "soft_ap_off", + [SOFTAP_MOCK_GDBUS_SIGNAL_LOW_BATTERY_MODE] = "low_batt_mode", + [SOFTAP_MOCK_GDBUS_SIGNAL_FLIGHT_MODE] = "flight_mode", + [SOFTAP_MOCK_GDBUS_SIGNAL_SECURITY_TYPE_CHANGED] = "security_type_changed", + [SOFTAP_MOCK_GDBUS_SIGNAL_SSID_VISIBILITY_CHANGED] = "ssid_visibility_changed", + [SOFTAP_MOCK_GDBUS_SIGNAL_PASSPHRASE_CHANGED] = "passphrase_changed", + [SOFTAP_MOCK_GDBUS_SIGNAL_DHCP_STATUS] = "dhcp_status", +}; + +static gdbus_async_callback_info_s gdbus_async_callback = {NULL, NULL}; +static gdbus_signal_callback_info_s gdbus_signal_callbacks[SOFTAP_MOCK_GDBUS_SIGNAL_MAX] = { + {NULL, NULL}, {NULL, NULL}, {NULL, NULL}, {NULL, NULL}, {NULL, NULL}, + {NULL, NULL}, {NULL, NULL}, {NULL, NULL}, {NULL, NULL} }; + static bool softap_mock_gdbus_result; void softap_mock_set_gdbus_result(bool value) @@ -28,6 +54,55 @@ void softap_mock_set_gdbus_result(bool value) softap_mock_gdbus_result = value; } +void softap_mock_invoke_gdbus_async_callback(void) +{ + if (!gdbus_async_callback.callback) + return; + + gdbus_async_callback.callback(NULL, NULL, gdbus_async_callback.user_data); + gdbus_async_callback.callback = NULL; + gdbus_async_callback.user_data = NULL; +} + +void softap_mock_emit_gdbus_signal(int signo) +{ + if (signo < SOFTAP_MOCK_GDBUS_SIGNAL_ON || signo >= SOFTAP_MOCK_GDBUS_SIGNAL_MAX) + return; + + if (!gdbus_signal_callbacks[signo].callback) + return; + + GVariant *params = NULL; + + switch (signo) { + case SOFTAP_MOCK_GDBUS_SIGNAL_ON: + break; + case SOFTAP_MOCK_GDBUS_SIGNAL_OFF: + params = g_variant_new("(s)", "There is no connection for a while"); + break; + case SOFTAP_MOCK_GDBUS_SIGNAL_LOW_BATTERY_MODE: + case SOFTAP_MOCK_GDBUS_SIGNAL_FLIGHT_MODE: + break; + case SOFTAP_MOCK_GDBUS_SIGNAL_SECURITY_TYPE_CHANGED: + case SOFTAP_MOCK_GDBUS_SIGNAL_SSID_VISIBILITY_CHANGED: + params = g_variant_new("(i)", 1); + break; + case SOFTAP_MOCK_GDBUS_SIGNAL_PASSPHRASE_CHANGED: + break; + case SOFTAP_MOCK_GDBUS_SIGNAL_DHCP_STATUS: + params = g_variant_new("(ssssu)", "DhcpConnected", + "192.168.43.24", "ab:cd:ef:ab:cd:ef", + "client", 1592460260); + break; + default: + break; + } + + gdbus_signal_callbacks[signo].callback(NULL, NULL, + NULL, NULL, gdbus_signal_list[signo], + params, gdbus_signal_callbacks[signo].user_data); +} + GCancellable *__wrap_g_cancellable_new(void) { return (GCancellable *)g_object_new(G_TYPE_CANCELLABLE, NULL); @@ -61,12 +136,25 @@ guint __wrap_g_dbus_connection_signal_subscribe(GDBusConnection *connection, gpointer user_data, GDestroyNotify user_data_free_func) { - return 1; + for (int i = 1; i < SOFTAP_MOCK_GDBUS_SIGNAL_MAX; i++) { + if (strcmp(gdbus_signal_list[i], member) == 0) { + gdbus_signal_callbacks[i].callback = callback; + gdbus_signal_callbacks[i].user_data = user_data; + return i; + } + } + return 0; } void __wrap_g_dbus_connection_signal_unsubscribe(GDBusConnection *connection, guint subscription_id) { + if (subscription_id >= SOFTAP_MOCK_GDBUS_SIGNAL_ON + && subscription_id < SOFTAP_MOCK_GDBUS_SIGNAL_MAX) { + gdbus_signal_callbacks[subscription_id].callback = NULL; + gdbus_signal_callbacks[subscription_id].user_data = NULL; + } + return; } @@ -78,8 +166,8 @@ typedef struct { int time; } clients_info_s; -#define TEST_CLIENTS_NUM 3 -clients_info_s dummy_clients[TEST_CLIENTS_NUM + 1] = { +#define DUMMY_CLIENTS_NUM 3 +clients_info_s dummy_clients[DUMMY_CLIENTS_NUM + 1] = { {4, "192.168.43.10", "aa:bb:cc:aa:bb:cc", "client1", 1592379558}, {4, "192.168.43.23", "bb:cc:aa:bb:cc:aa", "client2", 1592379626}, {4, "192.168.43.57", "cc:aa:bb:cc:aa:bb", "client3", 1592379687}, @@ -94,7 +182,7 @@ static GVariant *_get_connected_clients_info(void) outer_builder = g_variant_builder_new(G_VARIANT_TYPE("a(a{sv})")); - for (int i = 0; i < TEST_CLIENTS_NUM; i++) { + for (int i = 0; i < DUMMY_CLIENTS_NUM; i++) { inner_builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); g_variant_builder_add(inner_builder, "{sv}", "Type", g_variant_new_int32(dummy_clients[i].type)); @@ -141,3 +229,27 @@ GVariant *__wrap_g_dbus_proxy_call_sync(GDBusProxy *proxy, return params; } + +void __wrap_g_dbus_proxy_call(GDBusProxy *proxy, + const gchar *method_name, + GVariant *parameters, + GDBusCallFlags flags, + gint timeout_msec, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + gdbus_async_callback.callback = callback; + gdbus_async_callback.user_data = user_data; +} + +GVariant *__wrap_g_dbus_proxy_call_finish(GDBusProxy *proxy, + GAsyncResult *res, GError **error) +{ + return g_variant_new("(u)", 0); +} + +void __wrap_g_dbus_proxy_set_default_timeout(GDBusProxy *proxy, gint timeout_msec) +{ + return; +} diff --git a/tests/mocks/softap_gdbus.h b/tests/mocks/softap_gdbus.h index fa66ddd..dc00f66 100644 --- a/tests/mocks/softap_gdbus.h +++ b/tests/mocks/softap_gdbus.h @@ -18,4 +18,18 @@ #include +enum { + SOFTAP_MOCK_GDBUS_SIGNAL_ON = 1, + SOFTAP_MOCK_GDBUS_SIGNAL_OFF, + SOFTAP_MOCK_GDBUS_SIGNAL_LOW_BATTERY_MODE, + SOFTAP_MOCK_GDBUS_SIGNAL_FLIGHT_MODE, + SOFTAP_MOCK_GDBUS_SIGNAL_SECURITY_TYPE_CHANGED, + SOFTAP_MOCK_GDBUS_SIGNAL_SSID_VISIBILITY_CHANGED, + SOFTAP_MOCK_GDBUS_SIGNAL_PASSPHRASE_CHANGED, + SOFTAP_MOCK_GDBUS_SIGNAL_DHCP_STATUS, + SOFTAP_MOCK_GDBUS_SIGNAL_MAX +}; + void softap_mock_set_gdbus_result(bool value); +void softap_mock_invoke_gdbus_async_callback(void); +void softap_mock_emit_gdbus_signal(int signo); diff --git a/tests/mocks/softap_ioctl.c b/tests/mocks/softap_ioctl.c index c0e92fd..aaaa350 100644 --- a/tests/mocks/softap_ioctl.c +++ b/tests/mocks/softap_ioctl.c @@ -52,7 +52,7 @@ int __wrap_ioctl(int fd, unsigned long int request, ...) va_start(vl, request); arg = va_arg(vl, void *); - switch(request) { + switch (request) { case SIOCGIFHWADDR: _set_mac_address(arg); break; diff --git a/tests/mocks/softap_vconf.c b/tests/mocks/softap_vconf.c index 2301b9d..18b68fc 100644 --- a/tests/mocks/softap_vconf.c +++ b/tests/mocks/softap_vconf.c @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include "softap_memory.h" +#include "softap_vconf.h" #include diff --git a/tests/softap-gtest-async.cpp b/tests/softap-gtest-async.cpp new file mode 100755 index 0000000..492e58d --- /dev/null +++ b/tests/softap-gtest-async.cpp @@ -0,0 +1,324 @@ +/* +* Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved +* +* 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 "softap.h" + +extern "C" { +#include "mocks/softap_gdbus.h" +#include "mocks/softap_memory.h" +#include "mocks/softap_system_info.h" +#include "mocks/softap_permission.h" +#include "mocks/softap_vconf.h" +} + +#include "softap-gtest-util.h" + +static int resultFlags; +static void enabledCallback(softap_error_e error, bool requested, void *data); +static void disabledCallback(softap_error_e error, softap_disabled_cause_e cause, void *data); + +class SoftApAsyncTest: public ::testing::Test { + protected: + softap_h handle; + SoftApTestUtil testUtil; + + void SetUp() override + { + softap_mock_set_gdbus_result(true); + softap_mock_set_memory_result(true); + softap_mock_set_sysinfo_result(true); + softap_mock_set_permission(true); + softap_mock_set_vconf_result(true); + + softap_create(&handle); + softap_set_enabled_cb(handle, enabledCallback, NULL); + softap_set_disabled_cb(handle, disabledCallback, NULL); + + resultFlags = 0; + } + + void TearDown() override + { + softap_unset_enabled_cb(handle); + softap_unset_disabled_cb(handle); + softap_destroy(handle); + + softap_mock_set_vconf_result(false); + softap_mock_set_permission(false); + softap_mock_set_sysinfo_result(false); + softap_mock_set_memory_result(true); + softap_mock_set_gdbus_result(false); + } +}; + +enum { + SOFTAP_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST = 1 << 0, + SOFTAP_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS = 1 << 1, + SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST = 1 << 2, + SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_OTHERS = 1 << 3, + SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_FLIGHT_MODE = 1 << 4, + SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_LOW_BATTERY = 1 << 5, + SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT = 1 << 6, + SOFTAP_GTEST_RESULT_FLAG_RELOADED = 1 << 7, + SOFTAP_GTEST_RESULT_FLAG_CLIENT_CONNECTION_STATE_CHANGED = 1 << 8, + SOFTAP_GTEST_RESULT_FLAG_SECURITY_TYPE_CHANGED = 1 << 9, + SOFTAP_GTEST_RESULT_FLAG_SSID_VISIBILITY_CHANGED = 1 << 10, + SOFTAP_GTEST_RESULT_FLAG_PASSPHRASE_CHANGED = 1 << 11, + SOFTAP_GTEST_RESULT_FLAG_SUCCESS = 1 << 12, + SOFTAP_GTEST_RESULT_FLAG_FAILURE = 1 << 13, +}; + +static void enabledCallback(softap_error_e error, bool requested, void *user_data) +{ + resultFlags |= (error == SOFTAP_ERROR_NONE) + ? SOFTAP_GTEST_RESULT_FLAG_SUCCESS : SOFTAP_GTEST_RESULT_FLAG_FAILURE; + + resultFlags |= requested + ? SOFTAP_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST : SOFTAP_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS; +} + +static void disabledCallback(softap_error_e error, softap_disabled_cause_e cause, void *user_data) +{ + resultFlags |= (error == SOFTAP_ERROR_NONE) + ? SOFTAP_GTEST_RESULT_FLAG_SUCCESS : SOFTAP_GTEST_RESULT_FLAG_FAILURE; + + if (cause == SOFTAP_DISABLED_BY_FLIGHT_MODE) + resultFlags |= SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_FLIGHT_MODE; + else if (cause == SOFTAP_DISABLED_BY_LOW_BATTERY) + resultFlags |= SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_LOW_BATTERY; + else if (cause == SOFTAP_DISABLED_BY_TIMEOUT) + resultFlags |= SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT; + else if (cause == SOFTAP_DISABLED_BY_OTHERS) + resultFlags |= SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_OTHERS; + else if (cause == SOFTAP_DISABLED_BY_REQUEST) + resultFlags |= SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST; +} + +static void reloadedCallback(softap_error_e result, void *user_data) +{ + resultFlags |= SOFTAP_GTEST_RESULT_FLAG_RELOADED; + resultFlags |= (result == SOFTAP_ERROR_NONE) + ? SOFTAP_GTEST_RESULT_FLAG_SUCCESS : SOFTAP_GTEST_RESULT_FLAG_FAILURE; +} + +static void securityTypeChangedCallback(softap_security_type_e changed_type, void *user_data) +{ + resultFlags |= SOFTAP_GTEST_RESULT_FLAG_SECURITY_TYPE_CHANGED; +} + +static void ssidVisibilityChangedCallback(bool changed_visibile, void *user_data) +{ + resultFlags |= SOFTAP_GTEST_RESULT_FLAG_SSID_VISIBILITY_CHANGED; +} + +static void passphraseChangedCallback(void *user_data) +{ + resultFlags |= SOFTAP_GTEST_RESULT_FLAG_PASSPHRASE_CHANGED; +} + +static void clientConnectionChangedCallback(softap_client_h client, bool opened, void *user_data) +{ + resultFlags |= SOFTAP_GTEST_RESULT_FLAG_CLIENT_CONNECTION_STATE_CHANGED; +} + +TEST_F(SoftApAsyncTest, EnableN) +{ + EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_enable(NULL)); +} + +TEST_F(SoftApAsyncTest, EnableP) +{ + EXPECT_EQ(SOFTAP_ERROR_NONE, softap_enable(handle)); + + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_ENABLE); + testUtil.runMainLoop(); + + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST, + resultFlags & SOFTAP_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST); + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_SUCCESS, resultFlags & SOFTAP_GTEST_RESULT_FLAG_SUCCESS); +} + +TEST_F(SoftApAsyncTest, DisableN) +{ + EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_disable(NULL)); +} + +TEST_F(SoftApAsyncTest, DisableP) +{ + EXPECT_EQ(SOFTAP_ERROR_NONE, softap_disable(handle)); + + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_DISABLE); + testUtil.runMainLoop(); + + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST, + resultFlags & SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST); + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_SUCCESS, resultFlags & SOFTAP_GTEST_RESULT_FLAG_SUCCESS); +} + +TEST_F(SoftApAsyncTest, ReloadSettingsN) +{ + EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_reload_settings(NULL, reloadedCallback, NULL)); + EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_reload_settings(handle, NULL, NULL)); + EXPECT_EQ(SOFTAP_ERROR_INVALID_PARAMETER, softap_reload_settings(NULL, NULL, NULL)); +} + +TEST_F(SoftApAsyncTest, ReloadSettingsP) +{ + EXPECT_EQ(SOFTAP_ERROR_NONE, softap_reload_settings(handle, reloadedCallback, NULL)); + + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_RELOAD); + testUtil.runMainLoop(); + + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_RELOADED, resultFlags & SOFTAP_GTEST_RESULT_FLAG_RELOADED); + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_SUCCESS, resultFlags & SOFTAP_GTEST_RESULT_FLAG_SUCCESS); +} + +// Positive only. +// In case of an error, signals aren't emitted. +TEST_F(SoftApAsyncTest, EnableEventP) +{ + // wait changed callback. + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_ENABLE_EVENT); + testUtil.runMainLoop(); + + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS, + resultFlags & SOFTAP_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS); + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_SUCCESS, resultFlags & SOFTAP_GTEST_RESULT_FLAG_SUCCESS); +} + +TEST_F(SoftApAsyncTest, DisableEventP) +{ + // wait changed callback. + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_DISABLE_EVENT); + testUtil.runMainLoop(); + + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT, + resultFlags & SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT); + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_SUCCESS, resultFlags & SOFTAP_GTEST_RESULT_FLAG_SUCCESS); +} + +TEST_F(SoftApAsyncTest, LowBatterModeEventP) +{ + // wait changed callback. + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_LOW_BATTERY_MODE); + testUtil.runMainLoop(); + + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_LOW_BATTERY, + resultFlags & SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_LOW_BATTERY); + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_SUCCESS, resultFlags & SOFTAP_GTEST_RESULT_FLAG_SUCCESS); +} + +TEST_F(SoftApAsyncTest, FlightModeEventP) +{ + // wait changed callback. + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_FLIGHT_MODE); + testUtil.runMainLoop(); + + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_FLIGHT_MODE, + resultFlags & SOFTAP_GTEST_RESULT_FLAG_DISABLED_BY_FLIGHT_MODE); + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_SUCCESS, resultFlags & SOFTAP_GTEST_RESULT_FLAG_SUCCESS); +} + +TEST_F(SoftApAsyncTest, SecurityTypeChangedEventP) +{ + EXPECT_EQ(SOFTAP_ERROR_NONE, + softap_set_security_type_changed_cb(handle, securityTypeChangedCallback, NULL)); + + softap_reload_settings(handle, reloadedCallback, NULL); + + // wait reloaded callback. + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_RELOAD); + testUtil.runMainLoop(); + resultFlags = false; + + // wait changed callback. + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_SECURITY_TYPE_CHANGED); + testUtil.runMainLoop(); + + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_SECURITY_TYPE_CHANGED, + resultFlags & SOFTAP_GTEST_RESULT_FLAG_SECURITY_TYPE_CHANGED); + EXPECT_EQ(SOFTAP_ERROR_NONE, + softap_unset_security_type_changed_cb(handle)); +} + +TEST_F(SoftApAsyncTest, SsidVisibilityChangedEventP) +{ + EXPECT_EQ(SOFTAP_ERROR_NONE, + softap_set_ssid_visibility_changed_cb(handle, ssidVisibilityChangedCallback, NULL)); + + softap_reload_settings(handle, reloadedCallback, NULL); + + // wait reloaded callback. + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_RELOAD); + testUtil.runMainLoop(); + resultFlags = false; + + // wait changed callback. + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_SSID_VISIBILITY_CHANGED); + testUtil.runMainLoop(); + + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_SSID_VISIBILITY_CHANGED, + resultFlags & SOFTAP_GTEST_RESULT_FLAG_SSID_VISIBILITY_CHANGED); + EXPECT_EQ(SOFTAP_ERROR_NONE, + softap_unset_ssid_visibility_changed_cb(handle)); +} + +TEST_F(SoftApAsyncTest, PassphraseChangedEventP) +{ + EXPECT_EQ(SOFTAP_ERROR_NONE, + softap_set_passphrase_changed_cb(handle, passphraseChangedCallback, NULL)); + + softap_reload_settings(handle, reloadedCallback, NULL); + + // wait reloaded callback. + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_RELOAD); + testUtil.runMainLoop(); + resultFlags = false; + + // wait changed callback. + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_PASSPHRASE_CHANGED); + testUtil.runMainLoop(); + + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_PASSPHRASE_CHANGED, + resultFlags & SOFTAP_GTEST_RESULT_FLAG_PASSPHRASE_CHANGED); + EXPECT_EQ(SOFTAP_ERROR_NONE, + softap_unset_passphrase_changed_cb(handle)); +} + +TEST_F(SoftApAsyncTest, ClientConnectionStateChangedEventP) +{ + EXPECT_EQ(SOFTAP_ERROR_NONE, + softap_set_client_connection_state_changed_cb(handle, + clientConnectionChangedCallback, NULL)); + + softap_reload_settings(handle, reloadedCallback, NULL); + + // wait reloaded callback. + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_RELOAD); + testUtil.runMainLoop(); + resultFlags = false; + + // wait changed callback. + testUtil.setTestType(SOFTAP_TEST_UTIL_TYPE_CLIENT_CONNECTION_CHANGED); + testUtil.runMainLoop(); + + EXPECT_EQ(SOFTAP_GTEST_RESULT_FLAG_CLIENT_CONNECTION_STATE_CHANGED, + resultFlags & SOFTAP_GTEST_RESULT_FLAG_CLIENT_CONNECTION_STATE_CHANGED); + EXPECT_EQ(SOFTAP_ERROR_NONE, + softap_unset_client_connection_state_changed_cb(handle)); +} diff --git a/tests/softap-gtest-util.cpp b/tests/softap-gtest-util.cpp new file mode 100755 index 0000000..f61fe25 --- /dev/null +++ b/tests/softap-gtest-util.cpp @@ -0,0 +1,103 @@ +/* +* Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved +* +* 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 "softap-gtest-util.h" + +#include + +extern "C" { +#include "mocks/softap_gdbus.h" +}; + +SoftApTestUtil::SoftApTestUtil(void) : testType(SOFTAP_TEST_UTIL_MAX), mainLoop(NULL), timeoutId(0) +{ +} + +SoftApTestUtil::~SoftApTestUtil(void) +{ +} + +void SoftApTestUtil::setTestType(int type) +{ + testType = type; +} + +int SoftApTestUtil::getTestType(void) +{ + return testType; +} + +void SoftApTestUtil::runMainLoop(void) +{ + mainLoop = g_main_loop_new(NULL, false); + timeoutId = g_timeout_add(10, SoftApTestUtil::timeoutCallback, this); + g_main_loop_run(mainLoop); +} + +void SoftApTestUtil::stopMainLoop(void) +{ + if (mainLoop) + g_main_loop_quit(mainLoop); + + if (timeoutId) + g_source_remove(timeoutId); +} + +gboolean SoftApTestUtil::timeoutCallback(gpointer user_data) +{ + SoftApTestUtil *util = (SoftApTestUtil *)user_data; + int type = util->getTestType(); + + switch(type) { + case SOFTAP_TEST_UTIL_TYPE_ENABLE: + case SOFTAP_TEST_UTIL_TYPE_DISABLE: + case SOFTAP_TEST_UTIL_TYPE_RELOAD: + softap_mock_invoke_gdbus_async_callback(); + break; + case SOFTAP_TEST_UTIL_TYPE_ENABLE_EVENT: + softap_mock_emit_gdbus_signal(SOFTAP_MOCK_GDBUS_SIGNAL_ON); + break; + case SOFTAP_TEST_UTIL_TYPE_DISABLE_EVENT: + softap_mock_emit_gdbus_signal(SOFTAP_MOCK_GDBUS_SIGNAL_OFF); + break; + case SOFTAP_TEST_UTIL_TYPE_LOW_BATTERY_MODE: + softap_mock_emit_gdbus_signal(SOFTAP_MOCK_GDBUS_SIGNAL_LOW_BATTERY_MODE); + break; + case SOFTAP_TEST_UTIL_TYPE_FLIGHT_MODE: + softap_mock_emit_gdbus_signal(SOFTAP_MOCK_GDBUS_SIGNAL_FLIGHT_MODE); + break; + case SOFTAP_TEST_UTIL_TYPE_SECURITY_TYPE_CHANGED: + softap_mock_emit_gdbus_signal(SOFTAP_MOCK_GDBUS_SIGNAL_SECURITY_TYPE_CHANGED); + break; + case SOFTAP_TEST_UTIL_TYPE_SSID_VISIBILITY_CHANGED: + softap_mock_emit_gdbus_signal(SOFTAP_MOCK_GDBUS_SIGNAL_SSID_VISIBILITY_CHANGED); + break; + case SOFTAP_TEST_UTIL_TYPE_PASSPHRASE_CHANGED: + softap_mock_emit_gdbus_signal(SOFTAP_MOCK_GDBUS_SIGNAL_PASSPHRASE_CHANGED); + break; + case SOFTAP_TEST_UTIL_TYPE_CLIENT_CONNECTION_CHANGED: + softap_mock_emit_gdbus_signal(SOFTAP_MOCK_GDBUS_SIGNAL_DHCP_STATUS); + break; + case SOFTAP_TEST_UTIL_MAX: + default: + // Do Nothing. + break; + } + + util->stopMainLoop(); + + return FALSE; +} diff --git a/tests/softap-gtest-util.h b/tests/softap-gtest-util.h new file mode 100755 index 0000000..f31cf6f --- /dev/null +++ b/tests/softap-gtest-util.h @@ -0,0 +1,54 @@ +/* +* Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved +* +* 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. +*/ + +#pragma once + +#include + +enum { + SOFTAP_TEST_UTIL_TYPE_ENABLE = 0, + SOFTAP_TEST_UTIL_TYPE_DISABLE, + SOFTAP_TEST_UTIL_TYPE_RELOAD, + SOFTAP_TEST_UTIL_TYPE_ENABLE_EVENT, + SOFTAP_TEST_UTIL_TYPE_DISABLE_EVENT, + SOFTAP_TEST_UTIL_TYPE_LOW_BATTERY_MODE, + SOFTAP_TEST_UTIL_TYPE_FLIGHT_MODE, + SOFTAP_TEST_UTIL_TYPE_SECURITY_TYPE_CHANGED, + SOFTAP_TEST_UTIL_TYPE_SSID_VISIBILITY_CHANGED, + SOFTAP_TEST_UTIL_TYPE_PASSPHRASE_CHANGED, + SOFTAP_TEST_UTIL_TYPE_CLIENT_CONNECTION_CHANGED, + SOFTAP_TEST_UTIL_MAX +}; + +class SoftApTestUtil +{ +public: + SoftApTestUtil(void); + ~SoftApTestUtil(); + + void runMainLoop(void); + void setTestType(int type); + int getTestType(void); + +private: + int testType; + GMainLoop *mainLoop; + guint timeoutId; + + void stopMainLoop(void); + + static gboolean timeoutCallback(gpointer user_data); +};