#include <glib.h>
#include <gio/gio.h>
+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)
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);
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;
}
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},
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));
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;
+}
--- /dev/null
+/*
+* 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 <gtest/gtest.h>
+
+#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));
+}
--- /dev/null
+/*
+* 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 <glib.h>
+
+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;
+}
projects / platform / core / api / softap.git / commitdiff