tests/tethering-gtest-async.cpp

   1 /*
   2 * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <gtest/gtest.h>
  18
  19 #include "tethering.h"
  20
  21 extern "C" {
  22 #include "mocks/tethering_gdbus.h"
  23 #include "mocks/tethering_memory.h"
  24 #include "mocks/tethering_system_info.h"
  25 #include "mocks/tethering_vconf.h"
  26 }
  27
  28 #include "tethering-gtest-util.h"
  29
  30 static int resultFlags;
  31 static void enabledCallback(tethering_error_e result, tethering_type_e type,
  32                 bool requested, void *data);
  33 static void disabledCallback(tethering_error_e result, tethering_type_e type,
  34                 tethering_disabled_cause_e cause, void *data);
  35
  36 class TetheringAsyncTest: public ::testing::Test {
  37         protected:
  38                 tethering_h handle;
  39                 TetheringTestUtil testUtil;
  40
  41                 void SetUp() override
  42                 {
  43                         tethering_mock_set_gdbus_result(true);
  44                         tethering_mock_set_memory_result(true);
  45                         tethering_mock_set_sysinfo_result(true);
  46                         tethering_mock_set_vconf_result(true);
  47
  48                         tethering_create(&handle);
  49
  50                         tethering_set_enabled_cb(handle, TETHERING_TYPE_USB, enabledCallback, NULL);
  51                         tethering_set_enabled_cb(handle, TETHERING_TYPE_WIFI, enabledCallback, NULL);
  52                         tethering_set_enabled_cb(handle, TETHERING_TYPE_BT, enabledCallback, NULL);
  53                         tethering_set_enabled_cb(handle, TETHERING_TYPE_P2P, enabledCallback, NULL);
  54
  55                         tethering_set_disabled_cb(handle, TETHERING_TYPE_USB, disabledCallback, NULL);
  56                         tethering_set_disabled_cb(handle, TETHERING_TYPE_WIFI, disabledCallback, NULL);
  57                         tethering_set_disabled_cb(handle, TETHERING_TYPE_BT, disabledCallback, NULL);
  58                         tethering_set_disabled_cb(handle, TETHERING_TYPE_P2P, disabledCallback, NULL);
  59
  60                         resultFlags = 0;
  61                 }
  62
  63                 void TearDown() override
  64                 {
  65                         tethering_unset_enabled_cb(handle, TETHERING_TYPE_USB);
  66                         tethering_unset_enabled_cb(handle, TETHERING_TYPE_WIFI);
  67                         tethering_unset_enabled_cb(handle, TETHERING_TYPE_BT);
  68
  69                         tethering_unset_disabled_cb(handle, TETHERING_TYPE_USB);
  70                         tethering_unset_disabled_cb(handle, TETHERING_TYPE_WIFI);
  71                         tethering_unset_disabled_cb(handle, TETHERING_TYPE_BT);
  72
  73                         tethering_destroy(handle);
  74
  75                         tethering_mock_set_vconf_result(false);
  76                         tethering_mock_set_sysinfo_result(false);
  77                         tethering_mock_set_memory_result(true);
  78                         tethering_mock_set_gdbus_result(false);
  79                 }
  80 };
  81
  82 enum {
  83         TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST = 1 << 0,
  84         TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS = 1 << 1,
  85         TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST = 1 << 2,
  86         TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_OTHERS = 1 << 3,
  87         TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_FLIGHT_MODE = 1 << 4,
  88         TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_LOW_BATTERY = 1 << 5,
  89         TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT = 1 << 6,
  90         TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_USB_DISCONNECTION = 1 >> 7,
  91         TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_NET_CLOSED = 1 << 8,
  92         TETHERING_GTEST_RESULT_FLAG_RELOADED = 1 << 9,
  93         TETHERING_GTEST_RESULT_FLAG_CONNECTION_STATE_CHANGED = 1 << 10,
  94         TETHERING_GTEST_RESULT_FLAG_SECURITY_TYPE_CHANGED = 1 << 11,
  95         TETHERING_GTEST_RESULT_FLAG_SSID_VISIBILITY_CHANGED = 1 << 12,
  96         TETHERING_GTEST_RESULT_FLAG_PASSPHRASE_CHANGED = 1 << 13,
  97         TETHERING_GTEST_RESULT_FLAG_DATA_USAGE = 1 << 14,
  98         TETHERING_GTEST_RESULT_FLAG_SUCCESS = 1 << 15,
  99         TETHERING_GTEST_RESULT_FLAG_FAILURE = 1 << 16,
 100 };
 101
 102 static void enabledCallback(tethering_error_e error,
 103                 tethering_type_e type, bool requested, void *user_data)
 104 {
 105         resultFlags |= (error == TETHERING_ERROR_NONE)
 106                 ? TETHERING_GTEST_RESULT_FLAG_SUCCESS : TETHERING_GTEST_RESULT_FLAG_FAILURE;
 107
 108         resultFlags |= requested
 109                 ? TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST : TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS;
 110 }
 111
 112 static void disabledCallback(tethering_error_e error,
 113                 tethering_type_e type, tethering_disabled_cause_e cause, void *user_data)
 114 {
 115         resultFlags |= (error == TETHERING_ERROR_NONE)
 116                 ? TETHERING_GTEST_RESULT_FLAG_SUCCESS : TETHERING_GTEST_RESULT_FLAG_FAILURE;
 117
 118         if (cause == TETHERING_DISABLED_BY_FLIGHT_MODE)
 119                 resultFlags |= TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_FLIGHT_MODE;
 120         else if (cause == TETHERING_DISABLED_BY_LOW_BATTERY)
 121                 resultFlags |= TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_LOW_BATTERY;
 122         else if (cause == TETHERING_DISABLED_BY_TIMEOUT)
 123                 resultFlags |= TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT;
 124         else if (cause == TETHERING_DISABLED_BY_NETWORK_CLOSE)
 125                 resultFlags |= TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_NET_CLOSED;
 126         else if (cause == TETHERING_DISABLED_BY_OTHERS)
 127                 resultFlags |= TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_OTHERS;
 128         else if (cause == TETHERING_DISABLED_BY_REQUEST)
 129                 resultFlags |= TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST;
 130 }
 131
 132 static void dataUsageCallback(tethering_error_e result,
 133                 unsigned long long received_data, unsigned long long sent_data, void *user_data)
 134 {
 135         resultFlags |= TETHERING_GTEST_RESULT_FLAG_DATA_USAGE;
 136         resultFlags |= (result == TETHERING_ERROR_NONE)
 137                 ? TETHERING_GTEST_RESULT_FLAG_SUCCESS : TETHERING_GTEST_RESULT_FLAG_FAILURE;
 138 }
 139
 140 static void reloadedCallback(tethering_error_e result, void *user_data)
 141 {
 142         resultFlags |= TETHERING_GTEST_RESULT_FLAG_RELOADED;
 143         resultFlags |= (result == TETHERING_ERROR_NONE)
 144                 ? TETHERING_GTEST_RESULT_FLAG_SUCCESS : TETHERING_GTEST_RESULT_FLAG_FAILURE;
 145 }
 146
 147 static void connectionChangedCallback(tethering_client_h client, bool opened, void *user_data)
 148 {
 149         resultFlags |= TETHERING_GTEST_RESULT_FLAG_CONNECTION_STATE_CHANGED;
 150 }
 151
 152 static void securityTypeChangedCallback(tethering_wifi_security_type_e changed_type, void *user_data)
 153 {
 154         resultFlags |= TETHERING_GTEST_RESULT_FLAG_SECURITY_TYPE_CHANGED;
 155 }
 156
 157 static void ssidVisibilityChangedCallback(bool changed_visibile, void *user_data)
 158 {
 159         resultFlags |= TETHERING_GTEST_RESULT_FLAG_SSID_VISIBILITY_CHANGED;
 160 }
 161
 162 static void passphraseChangedCallback(void *user_data)
 163 {
 164         resultFlags |= TETHERING_GTEST_RESULT_FLAG_PASSPHRASE_CHANGED;
 165 }
 166
 167 TEST_F(TetheringAsyncTest, EnableN)
 168 {
 169         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_enable(NULL, TETHERING_TYPE_USB));
 170         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_enable(handle, (tethering_type_e)-1));
 171 }
 172
 173 TEST_F(TetheringAsyncTest, EnableP1)
 174 {
 175         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_enable(handle, TETHERING_TYPE_USB));
 176
 177         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
 178         testUtil.runMainLoop();
 179
 180         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
 181                         resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
 182         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 183 }
 184
 185 TEST_F(TetheringAsyncTest, EnableP2)
 186 {
 187         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_enable(handle, TETHERING_TYPE_WIFI));
 188
 189         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
 190         testUtil.runMainLoop();
 191
 192         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
 193                         resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
 194         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 195 }
 196
 197 TEST_F(TetheringAsyncTest, EnableP3)
 198 {
 199         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_enable(handle, TETHERING_TYPE_BT));
 200
 201         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
 202         testUtil.runMainLoop();
 203
 204         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
 205                         resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
 206         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 207 }
 208
 209 TEST_F(TetheringAsyncTest, EnableP4)
 210 {
 211         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_enable(handle, TETHERING_TYPE_P2P));
 212
 213         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
 214         testUtil.runMainLoop();
 215
 216         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
 217                         resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
 218         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 219 }
 220
 221 TEST_F(TetheringAsyncTest, EnableP5)
 222 {
 223         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_enable(handle, TETHERING_TYPE_ALL));
 224
 225         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
 226         testUtil.runMainLoop();
 227
 228         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
 229                         resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
 230         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 231 }
 232
 233 TEST_F(TetheringAsyncTest, DisableN)
 234 {
 235         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_disable(NULL, TETHERING_TYPE_USB));
 236         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_disable(handle, (tethering_type_e)-1));
 237 }
 238
 239 TEST_F(TetheringAsyncTest, DisableP1)
 240 {
 241         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_disable(handle, TETHERING_TYPE_USB));
 242
 243         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
 244         testUtil.runMainLoop();
 245
 246         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
 247                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
 248         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 249 }
 250
 251 TEST_F(TetheringAsyncTest, DisableP2)
 252 {
 253         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_disable(handle, TETHERING_TYPE_WIFI));
 254
 255         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
 256         testUtil.runMainLoop();
 257
 258         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
 259                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
 260         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 261 }
 262
 263 TEST_F(TetheringAsyncTest, DisableP3)
 264 {
 265         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_disable(handle, TETHERING_TYPE_BT));
 266
 267         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
 268         testUtil.runMainLoop();
 269
 270         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
 271                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
 272         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 273 }
 274
 275 TEST_F(TetheringAsyncTest, DisableP4)
 276 {
 277         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_disable(handle, TETHERING_TYPE_P2P));
 278
 279         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
 280         testUtil.runMainLoop();
 281
 282         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
 283                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
 284         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 285 }
 286
 287 TEST_F(TetheringAsyncTest, DisableP5)
 288 {
 289         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_disable(handle, TETHERING_TYPE_ALL));
 290
 291         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
 292         testUtil.runMainLoop();
 293
 294         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
 295                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
 296         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 297 }
 298
 299 TEST_F(TetheringAsyncTest, Ipv6EnableN)
 300 {
 301         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_ipv6_enable(NULL, TETHERING_TYPE_USB));
 302         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_ipv6_enable(handle, (tethering_type_e)-1));
 303 }
 304
 305 TEST_F(TetheringAsyncTest, Ipv6EnableP1)
 306 {
 307         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_ipv6_enable(handle, TETHERING_TYPE_USB));
 308
 309         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
 310         testUtil.runMainLoop();
 311
 312         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
 313                         resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
 314         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 315 }
 316
 317 TEST_F(TetheringAsyncTest, Ipv6EnableP2)
 318 {
 319         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_ipv6_enable(handle, TETHERING_TYPE_WIFI));
 320
 321         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
 322         testUtil.runMainLoop();
 323
 324         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
 325                         resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
 326         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 327 }
 328
 329 TEST_F(TetheringAsyncTest, Ipv6EnableP3)
 330 {
 331         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_ipv6_enable(handle, TETHERING_TYPE_BT));
 332
 333         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_ENABLE);
 334         testUtil.runMainLoop();
 335
 336         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST,
 337                         resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_REQUEST);
 338         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 339 }
 340
 341 TEST_F(TetheringAsyncTest, Ipv6DisableN)
 342 {
 343         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_ipv6_disable(NULL, TETHERING_TYPE_USB));
 344         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_ipv6_disable(handle, (tethering_type_e)-1));
 345 }
 346
 347 TEST_F(TetheringAsyncTest, Ipv6DisableP1)
 348 {
 349         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_ipv6_disable(handle, TETHERING_TYPE_USB));
 350
 351         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
 352         testUtil.runMainLoop();
 353
 354         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
 355                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
 356         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 357 }
 358
 359 TEST_F(TetheringAsyncTest, Ipv6DisableP2)
 360 {
 361         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_ipv6_disable(handle, TETHERING_TYPE_WIFI));
 362
 363         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
 364         testUtil.runMainLoop();
 365
 366         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
 367                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
 368         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 369 }
 370
 371 TEST_F(TetheringAsyncTest, Ipv6DisableP3)
 372 {
 373         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_ipv6_disable(handle, TETHERING_TYPE_BT));
 374
 375         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DISABLE);
 376         testUtil.runMainLoop();
 377
 378         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST,
 379                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_REQUEST);
 380         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 381 }
 382
 383 TEST_F(TetheringAsyncTest, GetDataUsageN)
 384 {
 385         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 386                         tethering_get_data_usage(NULL, dataUsageCallback, NULL));
 387         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 388                         tethering_get_data_usage(handle, NULL, NULL));
 389
 390         tethering_mock_set_enabled_state(false, false, false, false);
 391         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 392                         tethering_get_data_usage(handle, dataUsageCallback, NULL));
 393 }
 394
 395 TEST_F(TetheringAsyncTest, GetDataUsageP)
 396 {
 397         tethering_mock_set_enabled_state(true, true, true, true);
 398
 399         EXPECT_EQ(TETHERING_ERROR_NONE,
 400                         tethering_get_data_usage(handle, dataUsageCallback, NULL));
 401
 402         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_DATA_USAGE);
 403         testUtil.runMainLoop();
 404
 405         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DATA_USAGE,
 406                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DATA_USAGE);
 407         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 408 }
 409
 410 TEST_F(TetheringAsyncTest, ReloadSettingsN)
 411 {
 412         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_reload_settings(NULL, reloadedCallback, NULL));
 413         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_reload_settings(handle, NULL, NULL));
 414         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_reload_settings(NULL, NULL, NULL));
 415 }
 416
 417 TEST_F(TetheringAsyncTest, ReloadSettingsP)
 418 {
 419         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_reload_settings(handle, reloadedCallback, NULL));
 420
 421         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_RELOAD);
 422         testUtil.runMainLoop();
 423
 424         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_RELOADED, resultFlags & TETHERING_GTEST_RESULT_FLAG_RELOADED);
 425         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 426 }
 427
 428 // Positive only.
 429 // In case of an error, signals aren't emitted.
 430 TEST_F(TetheringAsyncTest, EnableEventP1)
 431 {
 432         // wait changed callback.
 433         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_WIFI_ENABLE_EVENT);
 434         testUtil.runMainLoop();
 435
 436         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS,
 437                         resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS);
 438         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 439 }
 440
 441 TEST_F(TetheringAsyncTest, EnableEventP2)
 442 {
 443         // wait changed callback.
 444         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_USB_ENABLE_EVENT);
 445         testUtil.runMainLoop();
 446
 447         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS,
 448                         resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS);
 449         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 450 }
 451
 452 TEST_F(TetheringAsyncTest, EnableEventP3)
 453 {
 454         // wait changed callback.
 455         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_BT_ENABLE_EVENT);
 456         testUtil.runMainLoop();
 457
 458         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS,
 459                         resultFlags & TETHERING_GTEST_RESULT_FLAG_ENABLED_BY_OTHERS);
 460         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 461 }
 462
 463 TEST_F(TetheringAsyncTest, DisableEventP1)
 464 {
 465         // wait changed callback.
 466         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_WIFI_DISABLE_EVENT);
 467         testUtil.runMainLoop();
 468
 469         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT,
 470                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT);
 471         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 472 }
 473
 474 TEST_F(TetheringAsyncTest, DisableEventP2)
 475 {
 476         // wait changed callback.
 477         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_USB_DISABLE_EVENT);
 478         testUtil.runMainLoop();
 479
 480         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_USB_DISCONNECTION,
 481                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_USB_DISCONNECTION);
 482         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 483 }
 484
 485 TEST_F(TetheringAsyncTest, DisableEventP3)
 486 {
 487         // wait changed callback.
 488         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_BT_DISABLE_EVENT);
 489         testUtil.runMainLoop();
 490
 491         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT,
 492                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT);
 493         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 494 }
 495
 496 TEST_F(TetheringAsyncTest, ConnectionStateChangedEventP)
 497 {
 498         EXPECT_EQ(TETHERING_ERROR_NONE,
 499                         tethering_set_connection_state_changed_cb(handle,
 500                                 TETHERING_TYPE_USB, connectionChangedCallback, NULL));
 501
 502         // wait changed callback.
 503         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_CONNECTION_CHANGED);
 504         testUtil.runMainLoop();
 505
 506         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_CONNECTION_STATE_CHANGED,
 507                         resultFlags & TETHERING_GTEST_RESULT_FLAG_CONNECTION_STATE_CHANGED);
 508         EXPECT_EQ(TETHERING_ERROR_NONE,
 509                         tethering_unset_connection_state_changed_cb(handle, TETHERING_TYPE_USB));
 510 }
 511
 512 TEST_F(TetheringAsyncTest, SecurityTypeChangedEventP)
 513 {
 514         EXPECT_EQ(TETHERING_ERROR_NONE,
 515                         tethering_wifi_set_security_type_changed_cb(handle, securityTypeChangedCallback, NULL));
 516
 517         tethering_wifi_reload_settings(handle, reloadedCallback, NULL);
 518
 519         // wait reloaded callback.
 520         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_RELOAD);
 521         testUtil.runMainLoop();
 522         resultFlags = false;
 523
 524         // wait changed callback.
 525         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_SECURITY_TYPE_CHANGED);
 526         testUtil.runMainLoop();
 527
 528         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SECURITY_TYPE_CHANGED,
 529                         resultFlags & TETHERING_GTEST_RESULT_FLAG_SECURITY_TYPE_CHANGED);
 530         EXPECT_EQ(TETHERING_ERROR_NONE,
 531                         tethering_wifi_unset_security_type_changed_cb(handle));
 532 }
 533
 534 TEST_F(TetheringAsyncTest, SsidVisibilityChangedEventP)
 535 {
 536         EXPECT_EQ(TETHERING_ERROR_NONE,
 537                         tethering_wifi_set_ssid_visibility_changed_cb(handle,
 538                                 ssidVisibilityChangedCallback, NULL));
 539
 540         tethering_wifi_reload_settings(handle, reloadedCallback, NULL);
 541
 542         // wait reloaded callback.
 543         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_RELOAD);
 544         testUtil.runMainLoop();
 545         resultFlags = false;
 546
 547         // wait changed callback.
 548         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_SSID_VISIBILITY_CHANGED);
 549         testUtil.runMainLoop();
 550
 551         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SSID_VISIBILITY_CHANGED,
 552                         resultFlags & TETHERING_GTEST_RESULT_FLAG_SSID_VISIBILITY_CHANGED);
 553         EXPECT_EQ(TETHERING_ERROR_NONE,
 554                         tethering_wifi_unset_ssid_visibility_changed_cb(handle));
 555 }
 556
 557 TEST_F(TetheringAsyncTest, PassphraseChangedEventP)
 558 {
 559         EXPECT_EQ(TETHERING_ERROR_NONE,
 560                         tethering_wifi_set_passphrase_changed_cb(handle, passphraseChangedCallback, NULL));
 561
 562         tethering_wifi_reload_settings(handle, reloadedCallback, NULL);
 563
 564         // wait reloaded callback.
 565         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_RELOAD);
 566         testUtil.runMainLoop();
 567         resultFlags = false;
 568
 569         // wait changed callback.
 570         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_PASSPHRASE_CHANGED);
 571         testUtil.runMainLoop();
 572
 573         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_PASSPHRASE_CHANGED,
 574                         resultFlags & TETHERING_GTEST_RESULT_FLAG_PASSPHRASE_CHANGED);
 575         EXPECT_EQ(TETHERING_ERROR_NONE,
 576                         tethering_wifi_unset_passphrase_changed_cb(handle));
 577 }
 578
 579 TEST_F(TetheringAsyncTest, NoDataTimeoutEventP)
 580 {
 581         // wait changed callback.
 582         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_NO_DATA_TIMEOUT);
 583         testUtil.runMainLoop();
 584
 585         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT,
 586                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_TIMEOUT);
 587         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 588 }
 589
 590 TEST_F(TetheringAsyncTest, LowBatterModeEventP)
 591 {
 592         // wait changed callback.
 593         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_LOW_BATTERY_MODE);
 594         testUtil.runMainLoop();
 595
 596         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_LOW_BATTERY,
 597                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_LOW_BATTERY);
 598         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 599 }
 600
 601 TEST_F(TetheringAsyncTest, FlightModeEventP)
 602 {
 603         // wait changed callback.
 604         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_FLIGHT_MODE);
 605         testUtil.runMainLoop();
 606
 607         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_FLIGHT_MODE,
 608                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_FLIGHT_MODE);
 609         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 610 }
 611
 612 TEST_F(TetheringAsyncTest, NetClosedEventP)
 613 {
 614         // wait changed callback.
 615         testUtil.setTestType(TETHERING_TEST_UTIL_TYPE_NET_CLOSED);
 616         testUtil.runMainLoop();
 617
 618         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_NET_CLOSED,
 619                         resultFlags & TETHERING_GTEST_RESULT_FLAG_DISABLED_BY_NET_CLOSED);
 620         EXPECT_EQ(TETHERING_GTEST_RESULT_FLAG_SUCCESS, resultFlags & TETHERING_GTEST_RESULT_FLAG_SUCCESS);
 621 }