typedef struct {
GAsyncReadyCallback callback;
gpointer user_data;
+ const char *method_name;
} gdbus_async_callback_info_s;
typedef struct {
} gdbus_signal_callback_info_s;
static const char *gdbus_signal_list[TETHERING_MOCK_GDBUS_SIGNAL_MAX] = {
- [TETHERING_MOCK_GDBUS_SIGNAL_ON] = "soft_ap_on",
- [TETHERING_MOCK_GDBUS_SIGNAL_OFF] = "soft_ap_off",
+ [TETHERING_MOCK_GDBUS_SIGNAL_NET_CLOSED] = "net_closed",
+ [TETHERING_MOCK_GDBUS_SIGNAL_WIFI_TETHER_ON] = "wifi_on",
+ [TETHERING_MOCK_GDBUS_SIGNAL_WIFI_TETHER_OFF] = "wifi_off",
+ [TETHERING_MOCK_GDBUS_SIGNAL_USB_TETHER_ON] = "usb_on",
+ [TETHERING_MOCK_GDBUS_SIGNAL_USB_TETHER_OFF] = "usb_off",
+ [TETHERING_MOCK_GDBUS_SIGNAL_BT_TETHER_ON] = "bluetooth_on",
+ [TETHERING_MOCK_GDBUS_SIGNAL_BT_TETHER_OFF] = "bluetooth_off",
+ [TETHERING_MOCK_GDBUS_SIGNAL_NO_DATA_TIMEOUT] = "no_data_timeout",
[TETHERING_MOCK_GDBUS_SIGNAL_LOW_BATTERY_MODE] = "low_batt_mode",
[TETHERING_MOCK_GDBUS_SIGNAL_FLIGHT_MODE] = "flight_mode",
[TETHERING_MOCK_GDBUS_SIGNAL_SECURITY_TYPE_CHANGED] = "security_type_changed",
[TETHERING_MOCK_GDBUS_SIGNAL_SSID_VISIBILITY_CHANGED] = "ssid_visibility_changed",
[TETHERING_MOCK_GDBUS_SIGNAL_PASSPHRASE_CHANGED] = "passphrase_changed",
- [TETHERING_MOCK_GDBUS_SIGNAL_DHCP_STATUS] = "dhcp_status",
+ [TETHERING_MOCK_GDBUS_SIGNAL_DHCP_STATUS] = "dhcp_status"
+};
+
+static const char *gdbus_method_list[TETHERING_MOCK_GDBUS_METHOD_MAX] = {
+ [TETHERING_MOCK_GDBUS_METHOD_DISABLE_USB] = "disable_usb_tethering",
+ [TETHERING_MOCK_GDBUS_METHOD_DISABLE_WIFI] = "disable_wifi_tethering",
+ [TETHERING_MOCK_GDBUS_METHOD_DISABLE_BT] = "disable_bt_tethering",
+ [TETHERING_MOCK_GDBUS_METHOD_DISABLE_P2P] = "disable_p2p_tethering",
+ [TETHERING_MOCK_GDBUS_METHOD_GET_DATA_PACKET_USAGE] = "get_data_packet_usage",
};
static gdbus_async_callback_info_s gdbus_async_callback = {NULL, NULL};
return;
gdbus_async_callback.callback(NULL, NULL, gdbus_async_callback.user_data);
- gdbus_async_callback.callback = NULL;
- gdbus_async_callback.user_data = NULL;
}
void tethering_mock_emit_gdbus_signal(int signo)
{
- if (signo < TETHERING_MOCK_GDBUS_SIGNAL_ON || signo >= TETHERING_MOCK_GDBUS_SIGNAL_MAX)
+ if (signo < TETHERING_MOCK_GDBUS_SIGNAL_NET_CLOSED || signo >= TETHERING_MOCK_GDBUS_SIGNAL_MAX)
return;
if (!gdbus_signal_callbacks[signo].callback)
GVariant *params = NULL;
switch (signo) {
- case TETHERING_MOCK_GDBUS_SIGNAL_ON:
+ case TETHERING_MOCK_GDBUS_SIGNAL_NET_CLOSED:
+ break;
+ case TETHERING_MOCK_GDBUS_SIGNAL_WIFI_TETHER_ON:
+ break;
+ case TETHERING_MOCK_GDBUS_SIGNAL_WIFI_TETHER_OFF:
+ params = g_variant_new("(s)", "There is no connection for a while");
+ break;
+ case TETHERING_MOCK_GDBUS_SIGNAL_USB_TETHER_ON:
+ break;
+ case TETHERING_MOCK_GDBUS_SIGNAL_USB_TETHER_OFF:
+ params = g_variant_new("(s)", "Interface is not available");
+ break;
+ case TETHERING_MOCK_GDBUS_SIGNAL_BT_TETHER_ON:
break;
- case TETHERING_MOCK_GDBUS_SIGNAL_OFF:
+ case TETHERING_MOCK_GDBUS_SIGNAL_BT_TETHER_OFF:
params = g_variant_new("(s)", "There is no connection for a while");
break;
+ case TETHERING_MOCK_GDBUS_SIGNAL_NO_DATA_TIMEOUT:
case TETHERING_MOCK_GDBUS_SIGNAL_LOW_BATTERY_MODE:
case TETHERING_MOCK_GDBUS_SIGNAL_FLIGHT_MODE:
break;
case TETHERING_MOCK_GDBUS_SIGNAL_SECURITY_TYPE_CHANGED:
+ params = g_variant_new("(s)", "wpa2-psk");
+ break;
case TETHERING_MOCK_GDBUS_SIGNAL_SSID_VISIBILITY_CHANGED:
- params = g_variant_new("(i)", 1);
+ params = g_variant_new("(s)", "ssid_visible");
break;
case TETHERING_MOCK_GDBUS_SIGNAL_PASSPHRASE_CHANGED:
break;
case TETHERING_MOCK_GDBUS_SIGNAL_DHCP_STATUS:
- params = g_variant_new("(ssssu)", "DhcpConnected",
+ params = g_variant_new("(susssu)", "DhcpConnected", 1,
"192.168.43.24", "ab:cd:ef:ab:cd:ef",
"client", 1592460260);
break;
gpointer user_data,
GDestroyNotify user_data_free_func)
{
- for (int i = 1; i < TETHERING_MOCK_GDBUS_SIGNAL_MAX; i++) {
+ for (int i = TETHERING_MOCK_GDBUS_SIGNAL_NET_CLOSED; i < TETHERING_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;
void __wrap_g_dbus_connection_signal_unsubscribe(GDBusConnection *connection,
guint subscription_id)
{
- if (subscription_id >= TETHERING_MOCK_GDBUS_SIGNAL_ON
+ if (subscription_id >= TETHERING_MOCK_GDBUS_SIGNAL_NET_CLOSED
&& subscription_id < TETHERING_MOCK_GDBUS_SIGNAL_MAX) {
gdbus_signal_callbacks[subscription_id].callback = NULL;
gdbus_signal_callbacks[subscription_id].user_data = NULL;
{
gdbus_async_callback.callback = callback;
gdbus_async_callback.user_data = user_data;
+ gdbus_async_callback.method_name = method_name;
}
GVariant *__wrap_g_dbus_proxy_call_finish(GDBusProxy *proxy,
GAsyncResult *res, GError **error)
{
- return g_variant_new("(u)", 0);
+ GVariant *params = NULL;
+ const char *method_name = gdbus_async_callback.method_name;
+
+ if (strcmp(method_name, gdbus_method_list[TETHERING_MOCK_GDBUS_METHOD_DISABLE_USB]) == 0)
+ params = g_variant_new("(uu)", TETHERING_MOCK_GDBUS_EVENT_DISABLE_USB, 0);
+ else if (strcmp(method_name, gdbus_method_list[TETHERING_MOCK_GDBUS_METHOD_DISABLE_WIFI]) == 0)
+ params = g_variant_new("(uu)", TETHERING_MOCK_GDBUS_EVENT_DISABLE_WIFI, 0);
+ else if (strcmp(method_name, gdbus_method_list[TETHERING_MOCK_GDBUS_METHOD_DISABLE_BT]) == 0)
+ params = g_variant_new("(uu)", TETHERING_MOCK_GDBUS_EVENT_DISABLE_BT, 0);
+ else if (strcmp(method_name, gdbus_method_list[TETHERING_MOCK_GDBUS_METHOD_DISABLE_P2P]) == 0)
+ params = g_variant_new("(uu)", TETHERING_MOCK_GDBUS_EVENT_DISABLE_P2P, 0);
+ else if (strcmp(method_name,
+ gdbus_method_list[TETHERING_MOCK_GDBUS_METHOD_GET_DATA_PACKET_USAGE]) == 0)
+ params = g_variant_new("(utt)", 1, 123456, 2312412);
+ else
+ params = g_variant_new("(u)", 0);
+
+ gdbus_async_callback.callback = NULL;
+ gdbus_async_callback.user_data = NULL;
+ gdbus_async_callback.method_name = NULL;
+
+ return params;
}
void __wrap_g_dbus_proxy_set_default_timeout(GDBusProxy *proxy, gint timeout_msec)
--- /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 "tethering.h"
+
+extern "C" {
+#include "mocks/tethering_gdbus.h"
+#include "mocks/tethering_memory.h"
+#include "mocks/tethering_system_info.h"
+#include "mocks/tethering_vconf.h"
+}
+
+#include "tethering-gtest-util.h"
+
+static int resultFlags;
+static void enabledCallback(tethering_error_e result, tethering_type_e type,
+ bool requested, void *data);
+static void disabledCallback(tethering_error_e result, tethering_type_e type,
+ tethering_disabled_cause_e cause, void *data);
+
+class TetheringAsyncTest: public ::testing::Test {
+ protected:
+ tethering_h handle;
+ TetheringTestUtil testUtil;
+
+ void SetUp() override
+ {
+ tethering_mock_set_gdbus_result(true);
+ tethering_mock_set_memory_result(true);
+ tethering_mock_set_sysinfo_result(true);
+ tethering_mock_set_vconf_result(true);
+
+ tethering_create(&handle);
+
+ tethering_set_enabled_cb(handle, TETHERING_TYPE_USB, enabledCallback, NULL);
+ tethering_set_enabled_cb(handle, TETHERING_TYPE_WIFI, enabledCallback, NULL);
+ tethering_set_enabled_cb(handle, TETHERING_TYPE_BT, enabledCallback, NULL);
+ tethering_set_enabled_cb(handle, TETHERING_TYPE_P2P, enabledCallback, NULL);
+
+ tethering_set_disabled_cb(handle, TETHERING_TYPE_USB, disabledCallback, NULL);
+ tethering_set_disabled_cb(handle, TETHERING_TYPE_WIFI, disabledCallback, NULL);
+ tethering_set_disabled_cb(handle, TETHERING_TYPE_BT, disabledCallback, NULL);
+ tethering_set_disabled_cb(handle, TETHERING_TYPE_P2P, disabledCallback, NULL);
+
+ resultFlags = 0;
+ }
+
+ void TearDown() override
+ {
+ tethering_unset_enabled_cb(handle, TETHERING_TYPE_USB);
+ tethering_unset_enabled_cb(handle, TETHERING_TYPE_WIFI);
+ tethering_unset_enabled_cb(handle, TETHERING_TYPE_BT);
+
+ tethering_unset_disabled_cb(handle, TETHERING_TYPE_USB);
+ tethering_unset_disabled_cb(handle, TETHERING_TYPE_WIFI);
+ tethering_unset_disabled_cb(handle, TETHERING_TYPE_BT);
+
+ tethering_destroy(handle);
+
+ tethering_mock_set_vconf_result(false);
+ tethering_mock_set_sysinfo_result(false);
+ tethering_mock_set_memory_result(true);
+ tethering_mock_set_gdbus_result(false);
+ }
+};
+
+enum {
+ TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST = 1 << 0,
+ TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS = 1 << 1,
+ TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST = 1 << 2,
+ TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_OTHERS = 1 << 3,
+ TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_FLIGHT_MODE = 1 << 4,
+ TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_LOW_BATTERY = 1 << 5,
+ TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT = 1 << 6,
+ TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_USB_DISCONNECTION = 1 >> 7,
+ TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_NET_CLOSED = 1 << 8,
+ TETHERING_GTEST_RESULT_FLAG_RELOADED = 1 << 9,
+ TETHERING_GTEST_RESULT_FLAG_CONNECTION_STATE_CHANGED = 1 << 10,
+ TETHERING_GTEST_RESULT_FLAG_SECURITY_TYPE_CHANGED = 1 << 11,
+ TETHERING_GTEST_RESULT_FLAG_SSID_VISIBILITY_CHANGED = 1 << 12,
+ TETHERING_GTEST_RESULT_FLAG_PASSPHRASE_CHANGED = 1 << 13,
+ TETHERING_GTEST_RESULT_FLAG_DATA_USAGE = 1 << 14,
+ TETHERING_GTEST_RESULT_FLAG_SUCCESS = 1 << 15,
+ TETHERING_GTEST_RESULT_FLAG_FAILURE = 1 << 16,
+};
+
+static void enabledCallback(tethering_error_e error,
+ tethering_type_e type, bool requested, void *user_data)
+{
+ resultFlags |= (error == TETHERING_ERROR_NONE)
+ ? TETHERING_GTEST_RESULT_FLAG_SUCCESS : TETHERING_GTEST_RESULT_FLAG_FAILURE;
+
+ resultFlags |= requested
+ ? TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST : TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS;
+}
+
+static void disabledCallback(tethering_error_e error,
+ tethering_type_e type, tethering_disabled_cause_e cause, void *user_data)
+{
+ resultFlags |= (error == TETHERING_ERROR_NONE)
+ ? TETHERING_GTEST_RESULT_FLAG_SUCCESS : TETHERING_GTEST_RESULT_FLAG_FAILURE;
+
+ if (cause == TETHERING_DISABLED_BY_FLIGHT_MODE)
+ resultFlags |= TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_FLIGHT_MODE;
+ else if (cause == TETHERING_DISABLED_BY_LOW_BATTERY)
+ resultFlags |= TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_LOW_BATTERY;
+ else if (cause == TETHERING_DISABLED_BY_TIMEOUT)
+ resultFlags |= TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT;
+ else if (cause == TETHERING_DISABLED_BY_NETWORK_CLOSE)
+ resultFlags |= TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_NET_CLOSED;
+ else if (cause == TETHERING_DISABLED_BY_OTHERS)
+ resultFlags |= TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_OTHERS;
+ else if (cause == TETHERING_DISABLED_BY_REQUEST)
+ resultFlags |= TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST;
+}
+
+static void dataUsageCallback(tethering_error_e result,
+ unsigned long long received_data, unsigned long long sent_data, void *user_data)
+{
+ resultFlags |= TETHERING_GTEST_RESULT_FLAG_DATA_USAGE;
+ resultFlags |= (result == TETHERING_ERROR_NONE)
+ ? TETHERING_GTEST_RESULT_FLAG_SUCCESS : TETHERING_GTEST_RESULT_FLAG_FAILURE;
+}
+
+static void reloadedCallback(tethering_error_e result, void *user_data)
+{
+ resultFlags |= TETHERING_GTEST_RESULT_FLAG_RELOADED;
+ resultFlags |= (result == TETHERING_ERROR_NONE)
+ ? TETHERING_GTEST_RESULT_FLAG_SUCCESS : TETHERING_GTEST_RESULT_FLAG_FAILURE;
+}
+
+static void connectionChangedCallback(tethering_client_h client, bool opened, void *user_data)
+{
+ resultFlags |= TETHERING_GTEST_RESULT_FLAG_CONNECTION_STATE_CHANGED;
+}
+
+static void securityTypeChangedCallback(tethering_wifi_security_type_e changed_type, void *user_data)
+{
+ resultFlags |= TETHERING_GTEST_RESULT_FLAG_SECURITY_TYPE_CHANGED;
+}
+
+static void ssidVisibilityChangedCallback(bool changed_visibile, void *user_data)
+{
+ resultFlags |= TETHERING_GTEST_RESULT_FLAG_SSID_VISIBILITY_CHANGED;
+}
+
+static void passphraseChangedCallback(void *user_data)
+{
+ resultFlags |= TETHERING_GTEST_RESULT_FLAG_PASSPHRASE_CHANGED;
+}
+
+TEST_F(TetheringAsyncTest, EnableN)
+{
+ EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_enable(NULL, TETHERING_TYPE_USB));
+ EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_enable(handle, (tethering_type_e)-1));
+}
+
+TEST_F(TetheringAsyncTest, EnableP1)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_enable(handle, TETHERING_TYPE_USB));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, EnableP2)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_enable(handle, TETHERING_TYPE_WIFI));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, EnableP3)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_enable(handle, TETHERING_TYPE_BT));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, EnableP4)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_enable(handle, TETHERING_TYPE_P2P));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, EnableP5)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_enable(handle, TETHERING_TYPE_ALL));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, DisableN)
+{
+ EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_disable(NULL, TETHERING_TYPE_USB));
+ EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_disable(handle, (tethering_type_e)-1));
+}
+
+TEST_F(TetheringAsyncTest, DisableP1)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_disable(handle, TETHERING_TYPE_USB));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, DisableP2)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_disable(handle, TETHERING_TYPE_WIFI));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, DisableP3)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_disable(handle, TETHERING_TYPE_BT));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, DisableP4)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_disable(handle, TETHERING_TYPE_P2P));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, DisableP5)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_disable(handle, TETHERING_TYPE_ALL));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, Ipv6EnableN)
+{
+ EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_ipv6_enable(NULL, TETHERING_TYPE_USB));
+ EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_ipv6_enable(handle, (tethering_type_e)-1));
+}
+
+TEST_F(TetheringAsyncTest, Ipv6EnableP1)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_ipv6_enable(handle, TETHERING_TYPE_USB));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, Ipv6EnableP2)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_ipv6_enable(handle, TETHERING_TYPE_WIFI));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, Ipv6EnableP3)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_ipv6_enable(handle, TETHERING_TYPE_BT));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, Ipv6DisableN)
+{
+ EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_ipv6_disable(NULL, TETHERING_TYPE_USB));
+ EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_ipv6_disable(handle, (tethering_type_e)-1));
+}
+
+TEST_F(TetheringAsyncTest, Ipv6DisableP1)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_ipv6_disable(handle, TETHERING_TYPE_USB));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, Ipv6DisableP2)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_ipv6_disable(handle, TETHERING_TYPE_WIFI));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, Ipv6DisableP3)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_ipv6_disable(handle, TETHERING_TYPE_BT));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, GetDataUsageN)
+{
+ EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
+ tethering_get_data_usage(NULL, dataUsageCallback, NULL));
+ EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
+ tethering_get_data_usage(handle, NULL, NULL));
+
+ tethering_mock_set_enabled_state(false, false, false, false);
+ EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
+ tethering_get_data_usage(handle, dataUsageCallback, NULL));
+}
+
+TEST_F(TetheringAsyncTest, GetDataUsageP)
+{
+ tethering_mock_set_enabled_state(true, true, true, true);
+
+ EXPECT_EQ(TETHERING_ERROR_NONE,
+ tethering_get_data_usage(handle, dataUsageCallback, NULL));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DATA_USAGE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DATA_USAGE,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DATA_USAGE);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, ReloadSettingsN)
+{
+ EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_reload_settings(NULL, reloadedCallback, NULL));
+ EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_reload_settings(handle, NULL, NULL));
+ EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_reload_settings(NULL, NULL, NULL));
+}
+
+TEST_F(TetheringAsyncTest, ReloadSettingsP)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_reload_settings(handle, reloadedCallback, NULL));
+
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_RELOAD);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_RELOADED, resultFlags & TETHERING_GTEST_RESULT_FLAG_RELOADED);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+// Positive only.
+// In case of an error, signals aren't emitted.
+TEST_F(TetheringAsyncTest, EnableEventP1)
+{
+ // wait changed callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_WIFI_ENABLE_EVENT);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, EnableEventP2)
+{
+ // wait changed callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_USB_ENABLE_EVENT);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, EnableEventP3)
+{
+ // wait changed callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_BT_ENABLE_EVENT);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, DisableEventP1)
+{
+ // wait changed callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_WIFI_DISABLE_EVENT);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, DisableEventP2)
+{
+ // wait changed callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_USB_DISABLE_EVENT);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_USB_DISCONNECTION,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_USB_DISCONNECTION);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, DisableEventP3)
+{
+ // wait changed callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_BT_DISABLE_EVENT);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, ConnectionStateChangedEventP)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE,
+ tethering_set_connection_state_changed_cb(handle,
+ TETHERING_TYPE_USB, connectionChangedCallback, NULL));
+
+ // wait changed callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_CONNECTION_CHANGED);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_CONNECTION_STATE_CHANGED,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_CONNECTION_STATE_CHANGED);
+ EXPECT_EQ(TETHERING_ERROR_NONE,
+ tethering_unset_connection_state_changed_cb(handle, TETHERING_TYPE_USB));
+}
+
+TEST_F(TetheringAsyncTest, SecurityTypeChangedEventP)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE,
+ tethering_wifi_set_security_type_changed_cb(handle, securityTypeChangedCallback, NULL));
+
+ tethering_wifi_reload_settings(handle, reloadedCallback, NULL);
+
+ // wait reloaded callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_RELOAD);
+ testUtil.runMainLoop();
+ resultFlags = false;
+
+ // wait changed callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_SECURITY_TYPE_CHANGED);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SECURITY_TYPE_CHANGED,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_SECURITY_TYPE_CHANGED);
+ EXPECT_EQ(TETHERING_ERROR_NONE,
+ tethering_wifi_unset_security_type_changed_cb(handle));
+}
+
+TEST_F(TetheringAsyncTest, SsidVisibilityChangedEventP)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE,
+ tethering_wifi_set_ssid_visibility_changed_cb(handle,
+ ssidVisibilityChangedCallback, NULL));
+
+ tethering_wifi_reload_settings(handle, reloadedCallback, NULL);
+
+ // wait reloaded callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_RELOAD);
+ testUtil.runMainLoop();
+ resultFlags = false;
+
+ // wait changed callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_SSID_VISIBILITY_CHANGED);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SSID_VISIBILITY_CHANGED,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_SSID_VISIBILITY_CHANGED);
+ EXPECT_EQ(TETHERING_ERROR_NONE,
+ tethering_wifi_unset_ssid_visibility_changed_cb(handle));
+}
+
+TEST_F(TetheringAsyncTest, PassphraseChangedEventP)
+{
+ EXPECT_EQ(TETHERING_ERROR_NONE,
+ tethering_wifi_set_passphrase_changed_cb(handle, passphraseChangedCallback, NULL));
+
+ tethering_wifi_reload_settings(handle, reloadedCallback, NULL);
+
+ // wait reloaded callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_RELOAD);
+ testUtil.runMainLoop();
+ resultFlags = false;
+
+ // wait changed callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_PASSPHRASE_CHANGED);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_PASSPHRASE_CHANGED,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_PASSPHRASE_CHANGED);
+ EXPECT_EQ(TETHERING_ERROR_NONE,
+ tethering_wifi_unset_passphrase_changed_cb(handle));
+}
+
+TEST_F(TetheringAsyncTest, NoDataTimeoutEventP)
+{
+ // wait changed callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_NO_DATA_TIMEOUT);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, LowBatterModeEventP)
+{
+ // wait changed callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_LOW_BATTERY_MODE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_LOW_BATTERY,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_LOW_BATTERY);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, FlightModeEventP)
+{
+ // wait changed callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_FLIGHT_MODE);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_FLIGHT_MODE,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_FLIGHT_MODE);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
+
+TEST_F(TetheringAsyncTest, NetClosedEventP)
+{
+ // wait changed callback.
+ testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_NET_CLOSED);
+ testUtil.runMainLoop();
+
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_NET_CLOSED,
+ resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_NET_CLOSED);
+ EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
+}
projects / platform / core / api / tethering.git / commitdiff