tests/tethering-gtest-wifi.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_file.h"
  23 #include "mocks/tethering_gdbus.h"
  24 #include "mocks/tethering_memory.h"
  25 #include "mocks/tethering_system_info.h"
  26 #include "mocks/tethering_vconf.h"
  27 }
  28
  29 class WiFiTetheringTest: public ::testing::Test {
  30         protected:
  31                 tethering_h handle;
  32
  33                 void SetUp() override
  34                 {
  35                         tethering_mock_set_gdbus_result(true);
  36                         tethering_mock_set_memory_result(true);
  37                         tethering_mock_set_sysinfo_result(true);
  38                         tethering_mock_set_vconf_result(true);
  39                         tethering_mock_set_file_result(true);
  40
  41                         tethering_create(&handle);
  42                         tethering_mock_set_enabled_state(true, true, true, true);
  43                 }
  44
  45                 void TearDown() override
  46                 {
  47                         tethering_mock_set_enabled_state(false, false, false, false);
  48                         tethering_destroy(handle);
  49
  50                         tethering_mock_set_file_result(true);
  51                         tethering_mock_set_vconf_result(false);
  52                         tethering_mock_set_sysinfo_result(false);
  53                         tethering_mock_set_memory_result(true);
  54                         tethering_mock_set_gdbus_result(false);
  55                 }
  56 };
  57
  58 TEST_F(WiFiTetheringTest, SetSecurityTypeN)
  59 {
  60         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
  61                         tethering_wifi_set_security_type(NULL, TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK));
  62         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
  63                         tethering_wifi_set_security_type(handle, (tethering_wifi_security_type_e)-1));
  64 }
  65
  66 TEST_F(WiFiTetheringTest, SetSecurityTypeP)
  67 {
  68         EXPECT_EQ(TETHERING_ERROR_NONE,
  69                         tethering_wifi_set_security_type(handle, TETHERING_WIFI_SECURITY_TYPE_NONE));
  70         EXPECT_EQ(TETHERING_ERROR_NONE,
  71                         tethering_wifi_set_security_type(handle, TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK));
  72         EXPECT_EQ(TETHERING_ERROR_NONE,
  73                         tethering_wifi_set_security_type(handle, TETHERING_WIFI_SECURITY_TYPE_WPS));
  74         EXPECT_EQ(TETHERING_ERROR_NONE,
  75                         tethering_wifi_set_security_type(handle, TETHERING_WIFI_SECURITY_TYPE_SAE));
  76 }
  77
  78 TEST_F(WiFiTetheringTest, GetSecurityTypeN)
  79 {
  80         tethering_wifi_security_type_e type;
  81
  82         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_security_type(NULL, &type));
  83         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_security_type(handle, NULL));
  84         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_security_type(NULL, NULL));
  85 }
  86
  87 TEST_F(WiFiTetheringTest, GetSecurityTypeP)
  88 {
  89         tethering_wifi_security_type_e type;
  90
  91         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_get_security_type(handle, &type));
  92 }
  93
  94 TEST_F(WiFiTetheringTest, SetSsidN)
  95 {
  96         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_ssid(NULL, "tethering-gtest"));
  97         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_ssid(handle, NULL));
  98         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_ssid(NULL, NULL));
  99 }
 100
 101 TEST_F(WiFiTetheringTest, SetSsidP)
 102 {
 103         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_set_ssid(handle, "tethering-gtest"));
 104 }
 105
 106 TEST_F(WiFiTetheringTest, GetSsidN)
 107 {
 108         char *ssid = NULL;
 109
 110         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_ssid(NULL, &ssid));
 111         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_ssid(handle, NULL));
 112         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_ssid(NULL, NULL));
 113 }
 114
 115 TEST_F(WiFiTetheringTest, GetSsidP)
 116 {
 117         char *ssid = NULL;
 118
 119         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_get_ssid(handle, &ssid));
 120
 121         free(ssid);
 122 }
 123
 124 TEST_F(WiFiTetheringTest, SetSsidVisibilityN)
 125 {
 126         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_ssid_visibility(NULL, true));
 127 }
 128
 129 TEST_F(WiFiTetheringTest, SetSsidVisibilityP)
 130 {
 131         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_set_ssid_visibility(handle, true));
 132 }
 133
 134 TEST_F(WiFiTetheringTest, GetSsidVisibilityN)
 135 {
 136         bool visible;
 137
 138         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_ssid_visibility(NULL, &visible));
 139         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_ssid_visibility(handle, NULL));
 140         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_ssid_visibility(NULL, NULL));
 141
 142         tethering_mock_set_vconf_result(false);
 143         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED, tethering_wifi_get_ssid_visibility(handle, &visible));
 144 }
 145
 146 TEST_F(WiFiTetheringTest, GetSsidVisibilityP)
 147 {
 148         bool visible;
 149
 150         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_get_ssid_visibility(handle, &visible));
 151 }
 152
 153 TEST_F(WiFiTetheringTest, SetPassphraseN)
 154 {
 155         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_passphrase(NULL, "P@s$w0rd!"));
 156         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_passphrase(handle, NULL));
 157         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_passphrase(NULL, NULL));
 158
 159         // Too short passphrase
 160         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_passphrase(handle, "123"));
 161
 162         // Too long passphrase
 163         char passphrase[70] = {0, };
 164         for (int i = 0; i < 69; i++)
 165                 passphrase[i] = 'a';
 166         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_passphrase(handle, passphrase));
 167 }
 168
 169 TEST_F(WiFiTetheringTest, SetPassphraseP)
 170 {
 171         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_set_passphrase(handle, "P@s$w0rd!"));
 172 }
 173
 174 TEST_F(WiFiTetheringTest, GetPassphraseN)
 175 {
 176         char *passphrase;
 177
 178         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_passphrase(NULL, &passphrase));
 179         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_passphrase(handle, NULL));
 180         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_passphrase(NULL, NULL));
 181
 182         tethering_mock_set_gdbus_result(false);
 183         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED, tethering_wifi_get_passphrase(handle, &passphrase));
 184 }
 185
 186 TEST_F(WiFiTetheringTest, GetPassphraseP)
 187 {
 188         char *passphrase;
 189
 190         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_get_passphrase(handle, &passphrase));
 191
 192         free(passphrase);
 193 }
 194
 195 TEST_F(WiFiTetheringTest, SetMacFilterN)
 196 {
 197         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_mac_filter(NULL, true));
 198 }
 199
 200 TEST_F(WiFiTetheringTest, SetMacFilterP)
 201 {
 202         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_set_mac_filter(handle, true));
 203 }
 204
 205 TEST_F(WiFiTetheringTest, GetMacFilterN)
 206 {
 207         bool mac_filter;
 208
 209         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_mac_filter(NULL, &mac_filter));
 210         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_mac_filter(handle, NULL));
 211         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_mac_filter(NULL, NULL));
 212 }
 213
 214 TEST_F(WiFiTetheringTest, GetMacFilterP)
 215 {
 216         bool mac_filter;
 217
 218         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_get_mac_filter(handle, &mac_filter));
 219 }
 220
 221 TEST_F(WiFiTetheringTest, AddAllowedMacListN)
 222 {
 223         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 224                         tethering_wifi_add_allowed_mac_list(NULL, "aa:bb:cc:aa:bb:cc"));
 225         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_add_allowed_mac_list(handle, NULL));
 226         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_add_allowed_mac_list(NULL, NULL));
 227 }
 228
 229 TEST_F(WiFiTetheringTest, AddAllowedMacListP)
 230 {
 231         EXPECT_EQ(TETHERING_ERROR_NONE,
 232                         tethering_wifi_add_allowed_mac_list(handle, "aa:bb:cc:aa:bb:cc"));
 233 }
 234
 235 TEST_F(WiFiTetheringTest, RemoveAllowedMacListN)
 236 {
 237         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 238                         tethering_wifi_remove_allowed_mac_list(NULL, "aa:bb:cc:aa:bb:cc"));
 239         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 240                         tethering_wifi_remove_allowed_mac_list(handle, NULL));
 241         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 242                         tethering_wifi_remove_allowed_mac_list(NULL, NULL));
 243 }
 244
 245 TEST_F(WiFiTetheringTest, RemoveAllowedMacListP)
 246 {
 247         EXPECT_EQ(TETHERING_ERROR_NONE,
 248                         tethering_wifi_remove_allowed_mac_list(handle, "aa:bb:cc:aa:bb:cc"));
 249 }
 250
 251 TEST_F(WiFiTetheringTest, GetAllowedMacListN)
 252 {
 253         void *list;
 254
 255         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_allowed_mac_list(NULL, &list));
 256         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_allowed_mac_list(handle, NULL));
 257         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_allowed_mac_list(NULL, NULL));
 258 }
 259
 260 TEST_F(WiFiTetheringTest, GetAllowedMacListP)
 261 {
 262         void *list;
 263
 264         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_get_allowed_mac_list(handle, &list));
 265 }
 266
 267 TEST_F(WiFiTetheringTest, AddBlockedMacListN)
 268 {
 269         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 270                         tethering_wifi_add_blocked_mac_list(NULL, "aa:bb:cc:aa:bb:cc"));
 271         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_add_blocked_mac_list(handle, NULL));
 272         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_add_blocked_mac_list(NULL, NULL));
 273 }
 274
 275 TEST_F(WiFiTetheringTest, AddBlockedMacListP)
 276 {
 277         EXPECT_EQ(TETHERING_ERROR_NONE,
 278                         tethering_wifi_add_blocked_mac_list(handle, "aa:bb:cc:aa:bb:cc"));
 279 }
 280
 281 TEST_F(WiFiTetheringTest, RemoveBlockedMacListN)
 282 {
 283         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 284                         tethering_wifi_remove_blocked_mac_list(NULL, "aa:bb:cc:aa:bb:cc"));
 285         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 286                         tethering_wifi_remove_blocked_mac_list(handle, NULL));
 287         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 288                         tethering_wifi_remove_blocked_mac_list(NULL, NULL));
 289 }
 290
 291 TEST_F(WiFiTetheringTest, RemoveBlockedMacListP)
 292 {
 293         EXPECT_EQ(TETHERING_ERROR_NONE,
 294                         tethering_wifi_remove_blocked_mac_list(handle, "aa:bb:cc:aa:bb:cc"));
 295 }
 296
 297 TEST_F(WiFiTetheringTest, GetBlockedMacListN)
 298 {
 299         void *list;
 300
 301         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_blocked_mac_list(NULL, &list));
 302         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_blocked_mac_list(handle, NULL));
 303         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_blocked_mac_list(NULL, NULL));
 304 }
 305
 306 TEST_F(WiFiTetheringTest, GetBlockedMacListP)
 307 {
 308         void *list;
 309
 310         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_get_blocked_mac_list(handle, &list));
 311 }
 312
 313 TEST_F(WiFiTetheringTest, EnableDhcpN)
 314 {
 315         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_enable_dhcp(NULL, true));
 316
 317         tethering_mock_set_gdbus_result(false);
 318         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED, tethering_wifi_enable_dhcp(handle, true));
 319 }
 320
 321 TEST_F(WiFiTetheringTest, EnableDhcpP)
 322 {
 323         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_enable_dhcp(handle, true));
 324         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_enable_dhcp(handle, false));
 325 }
 326
 327
 328 TEST_F(WiFiTetheringTest, SetDhcpRangeN)
 329 {
 330         char start_ip[16] = "192.168.43.2";
 331         char end_ip[16] = "192.168.43.100";
 332
 333         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 334                         tethering_wifi_set_dhcp_range(NULL, start_ip, end_ip));
 335         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 336                         tethering_wifi_set_dhcp_range(handle, NULL, end_ip));
 337         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 338                         tethering_wifi_set_dhcp_range(handle, start_ip, NULL));
 339         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 340                         tethering_wifi_set_dhcp_range(NULL, NULL, NULL));
 341
 342         tethering_mock_set_gdbus_result(false);
 343         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED,
 344                         tethering_wifi_set_dhcp_range(handle, start_ip, end_ip));
 345 }
 346
 347 TEST_F(WiFiTetheringTest, EnableDhcpWithRangeP)
 348 {
 349         char start_ip[16] = "192.168.43.2";
 350         char end_ip[16] = "192.168.43.100";
 351
 352         EXPECT_EQ(TETHERING_ERROR_NONE,
 353                         tethering_wifi_set_dhcp_range(handle, start_ip, end_ip));
 354 }
 355
 356 TEST_F(WiFiTetheringTest, IsDhcpEnabledN)
 357 {
 358         bool dhcp_enabled;
 359
 360         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_is_dhcp_enabled(NULL, &dhcp_enabled));
 361         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_is_dhcp_enabled(handle, NULL));
 362         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_is_dhcp_enabled(NULL, NULL));
 363 }
 364
 365 TEST_F(WiFiTetheringTest, IsDhcpEnabledP)
 366 {
 367         bool dhcp_enabled;
 368
 369         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_is_dhcp_enabled(handle, &dhcp_enabled));
 370 }
 371
 372 TEST_F(WiFiTetheringTest, SetChannelN)
 373 {
 374         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_channel(NULL, 6));
 375 }
 376
 377 TEST_F(WiFiTetheringTest, SetChannelP)
 378 {
 379         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_set_channel(handle, 6));
 380 }
 381
 382 TEST_F(WiFiTetheringTest, GetChannelN)
 383 {
 384         int channel;
 385
 386         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_channel(NULL, &channel));
 387         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_channel(handle, NULL));
 388         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_channel(NULL, NULL));
 389 }
 390
 391 TEST_F(WiFiTetheringTest, GetChannelP)
 392 {
 393         int channel;
 394
 395         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_get_channel(handle, &channel));
 396 }
 397
 398 TEST_F(WiFiTetheringTest, SetModeN)
 399 {
 400         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_mode(NULL, TETHERING_WIFI_MODE_TYPE_B));
 401 }
 402
 403 TEST_F(WiFiTetheringTest, SetModeP)
 404 {
 405         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_set_mode(handle, TETHERING_WIFI_MODE_TYPE_B));
 406 }
 407
 408 TEST_F(WiFiTetheringTest, GetModeN)
 409 {
 410         tethering_wifi_mode_type_e mode;
 411
 412         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_mode(NULL, &mode));
 413         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_mode(handle, NULL));
 414         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_mode(NULL, NULL));
 415 }
 416
 417 TEST_F(WiFiTetheringTest, GetModeP)
 418 {
 419         tethering_wifi_mode_type_e mode;
 420
 421         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_get_mode(handle, &mode));
 422 }
 423
 424 TEST_F(WiFiTetheringTest, SetTxPowerN)
 425 {
 426         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_txpower(NULL, 100));
 427
 428         tethering_mock_set_gdbus_result(false);
 429         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED, tethering_wifi_set_txpower(handle, 100));
 430
 431         tethering_mock_set_enabled_state(false, false, false, false);
 432         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED, tethering_wifi_set_txpower(handle, 100));
 433 }
 434
 435 TEST_F(WiFiTetheringTest, SetTxPowerP)
 436 {
 437         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_set_txpower(handle, 100));
 438 }
 439
 440 TEST_F(WiFiTetheringTest, GetTxPowerN)
 441 {
 442         unsigned int txpower = 0;
 443
 444         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_txpower(NULL, &txpower));
 445         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_txpower(handle, NULL));
 446         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_txpower(NULL, NULL));
 447
 448         tethering_mock_set_gdbus_result(false);
 449         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED, tethering_wifi_get_txpower(handle, &txpower));
 450
 451         tethering_mock_set_enabled_state(false, false, false, false);
 452         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED, tethering_wifi_get_txpower(handle, &txpower));
 453 }
 454
 455 TEST_F(WiFiTetheringTest, GetTxPowerP)
 456 {
 457         unsigned int txpower = 0;
 458
 459         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_get_txpower(handle, &txpower));
 460 }
 461
 462 TEST_F(WiFiTetheringTest, SetMtuN)
 463 {
 464         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_mtu(NULL, 100));
 465
 466         tethering_mock_set_gdbus_result(false);
 467         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED, tethering_wifi_set_mtu(handle, 100));
 468 }
 469
 470 TEST_F(WiFiTetheringTest, SetMtuP)
 471 {
 472         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_set_mtu(handle, 100));
 473 }
 474
 475 TEST_F(WiFiTetheringTest, ChangeMacN)
 476 {
 477         char mac[18] = "aa:bb:cc:aa:bb:cc";
 478
 479         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_change_mac(NULL, mac));
 480         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_change_mac(handle, NULL));
 481         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_change_mac(NULL, NULL));
 482
 483         tethering_mock_set_gdbus_result(false);
 484         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED,     tethering_wifi_change_mac(handle, mac));
 485 }
 486
 487 TEST_F(WiFiTetheringTest, ChangeMacP)
 488 {
 489         char mac[18] = "aa:bb:cc:aa:bb:cc";
 490
 491         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_change_mac(handle, mac));
 492 }
 493
 494 TEST_F(WiFiTetheringTest, SetMaxConnectedDeviceN)
 495 {
 496         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_max_connected_device(NULL, 10));
 497 }
 498
 499 TEST_F(WiFiTetheringTest, SetMaxConnectedDeviceP)
 500 {
 501         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_set_max_connected_device(handle, 10));
 502 }
 503
 504 TEST_F(WiFiTetheringTest, GetMaxConnectedDeviceN)
 505 {
 506         int num;
 507
 508         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 509                         tethering_wifi_get_max_connected_device(NULL, &num));
 510         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 511                         tethering_wifi_get_max_connected_device(handle, NULL));
 512         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 513                         tethering_wifi_get_max_connected_device(NULL, NULL));
 514 }
 515
 516 TEST_F(WiFiTetheringTest, GetMaxConnectedDeviceP)
 517 {
 518         int num;
 519
 520         EXPECT_EQ(TETHERING_ERROR_NONE,
 521                         tethering_wifi_get_max_connected_device(handle, &num));
 522 }
 523
 524 TEST_F(WiFiTetheringTest, EnablePortForwardingN)
 525 {
 526         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 527                         tethering_wifi_enable_port_forwarding(NULL, true));
 528
 529         tethering_mock_set_gdbus_result(false);
 530         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED,
 531                         tethering_wifi_enable_port_forwarding(handle, true));
 532 }
 533
 534 TEST_F(WiFiTetheringTest, EnablePortForwardingP)
 535 {
 536         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_enable_port_forwarding(handle, true));
 537 }
 538
 539 TEST_F(WiFiTetheringTest, AddPortForwardingRuleN)
 540 {
 541         char ifname[6] = "wlan0";
 542         char protocol[16] = "tcp";
 543         char org_ip[18] = "192.168.43.2";
 544         char final_ip[18] = "192.168.43.123";
 545         int org_port = 1234;
 546         int final_port = 2341;
 547
 548         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 549                         tethering_wifi_add_port_forwarding_rule(NULL,
 550                                 ifname, protocol, org_ip, org_port, final_ip, final_port));
 551         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 552                         tethering_wifi_add_port_forwarding_rule(handle,
 553                                 NULL, protocol, org_ip, org_port, final_ip, final_port));
 554         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 555                         tethering_wifi_add_port_forwarding_rule(handle,
 556                                 ifname, NULL, org_ip, org_port, final_ip, final_port));
 557         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 558                         tethering_wifi_add_port_forwarding_rule(handle,
 559                                 ifname, protocol, NULL, org_port, final_ip, final_port));
 560         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 561                         tethering_wifi_add_port_forwarding_rule(handle,
 562                                 ifname, protocol, org_ip, org_port, NULL, final_port));
 563
 564         tethering_mock_set_gdbus_result(false);
 565         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED,
 566                         tethering_wifi_add_port_forwarding_rule(handle,
 567                                 ifname, protocol, org_ip, org_port, final_ip, final_port));
 568 }
 569
 570 TEST_F(WiFiTetheringTest, AddPortForwardingRuleP)
 571 {
 572         char ifname[6] = "wlan0";
 573         char protocol[16] = "tcp";
 574         char org_ip[18] = "192.168.43.2";
 575         char final_ip[18] = "192.168.43.123";
 576         int org_port = 1234;
 577         int final_port = 2341;
 578
 579         EXPECT_EQ(TETHERING_ERROR_NONE,
 580                         tethering_wifi_add_port_forwarding_rule(handle,
 581                                 ifname, protocol, org_ip, org_port, final_ip, final_port));
 582 }
 583
 584 TEST_F(WiFiTetheringTest, ResetPortForwardingRuleN)
 585 {
 586         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_reset_port_forwarding_rule(NULL));
 587
 588         tethering_mock_set_gdbus_result(false);
 589         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED,
 590                         tethering_wifi_reset_port_forwarding_rule(handle));
 591 }
 592
 593 TEST_F(WiFiTetheringTest, ResetPortForwardingRuleP)
 594 {
 595         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_reset_port_forwarding_rule(handle));
 596 }
 597
 598 TEST_F(WiFiTetheringTest, IsPortForwardingEnabledN)
 599 {
 600         bool enabled;
 601
 602         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 603                         tethering_wifi_is_port_forwarding_enabled(NULL, &enabled));
 604         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 605                         tethering_wifi_is_port_forwarding_enabled(handle, NULL));
 606         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 607                         tethering_wifi_is_port_forwarding_enabled(NULL, NULL));
 608 }
 609
 610 TEST_F(WiFiTetheringTest, IsPortForwardingEnabledP)
 611 {
 612         bool enabled;
 613
 614         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_is_port_forwarding_enabled(handle, &enabled));
 615 }
 616
 617 TEST_F(WiFiTetheringTest, GetPortForwardingRuleN)
 618 {
 619         void *list;
 620
 621         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 622                         tethering_wifi_get_port_forwarding_rule(NULL, &list));
 623         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 624                         tethering_wifi_get_port_forwarding_rule(handle, NULL));
 625         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 626                         tethering_wifi_get_port_forwarding_rule(NULL, NULL));
 627 }
 628
 629 TEST_F(WiFiTetheringTest, GetPortForwardingRuleP)
 630 {
 631         void *list;
 632
 633         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_get_port_forwarding_rule(handle, &list));
 634 }
 635
 636 TEST_F(WiFiTetheringTest, EnablePortFilteringN)
 637 {
 638         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_enable_port_filtering(NULL, true));
 639
 640         tethering_mock_set_gdbus_result(false);
 641         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED,
 642                         tethering_wifi_enable_port_filtering(handle, true));
 643 }
 644
 645 TEST_F(WiFiTetheringTest, EnablePortFilteringP)
 646 {
 647         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_enable_port_filtering(handle, true));
 648 }
 649
 650 TEST_F(WiFiTetheringTest, AddPortFilteringRuleN)
 651 {
 652         char protocol[4] = "tcp";
 653
 654         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 655                         tethering_wifi_add_port_filtering_rule(NULL, 1234, protocol, true));
 656         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 657                         tethering_wifi_add_port_filtering_rule(handle, 1234, NULL, true));
 658
 659         tethering_mock_set_gdbus_result(false);
 660         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED,
 661                         tethering_wifi_add_port_filtering_rule(handle, 1234, protocol, true));
 662 }
 663
 664 TEST_F(WiFiTetheringTest, AddPortFilteringRuleP)
 665 {
 666         char protocol[4] = "tcp";
 667
 668         EXPECT_EQ(TETHERING_ERROR_NONE,
 669                         tethering_wifi_add_port_filtering_rule(handle, 1234, protocol, true));
 670         EXPECT_EQ(TETHERING_ERROR_NONE,
 671                         tethering_wifi_add_port_filtering_rule(handle, 1234, protocol, false));
 672 }
 673
 674 TEST_F(WiFiTetheringTest, AddCustomPortFilteringRuleN)
 675 {
 676         char protocol[4] = "tcp";
 677
 678         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 679                         tethering_wifi_add_custom_port_filtering_rule(NULL, 1234, 2341, protocol, true));
 680         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 681                         tethering_wifi_add_custom_port_filtering_rule(handle, 1234, 2341, NULL, true));
 682
 683
 684         tethering_mock_set_gdbus_result(false);
 685         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED,
 686                         tethering_wifi_add_custom_port_filtering_rule(handle, 1234, 2341, protocol, true));
 687 }
 688
 689 TEST_F(WiFiTetheringTest, AddCustomPortFilteringRuleP)
 690 {
 691         char protocol[4] = "tcp";
 692
 693         EXPECT_EQ(TETHERING_ERROR_NONE,
 694                         tethering_wifi_add_custom_port_filtering_rule(handle, 1234, 2341, protocol, true));
 695         EXPECT_EQ(TETHERING_ERROR_NONE,
 696                         tethering_wifi_add_custom_port_filtering_rule(handle, 1234, 2341, protocol, false));
 697
 698 }
 699
 700 TEST_F(WiFiTetheringTest, GetPortFilteringRuleN)
 701 {
 702         void *list;
 703
 704         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 705                         tethering_wifi_get_port_filtering_rule(NULL, &list));
 706         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 707                         tethering_wifi_get_port_filtering_rule(handle, NULL));
 708         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 709                         tethering_wifi_get_port_filtering_rule(NULL, NULL));
 710 }
 711
 712 TEST_F(WiFiTetheringTest, GetPortFilteringRuleP)
 713 {
 714         void *list;
 715
 716         EXPECT_EQ(TETHERING_ERROR_NONE,
 717                         tethering_wifi_get_port_filtering_rule(handle, &list));
 718 }
 719
 720 TEST_F(WiFiTetheringTest, GetCustomPortFilteringRuleN)
 721 {
 722         void *list;
 723
 724         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 725                         tethering_wifi_get_custom_port_filtering_rule(NULL, &list));
 726         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 727                         tethering_wifi_get_custom_port_filtering_rule(handle, NULL));
 728         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 729                         tethering_wifi_get_custom_port_filtering_rule(NULL, NULL));
 730 }
 731
 732 TEST_F(WiFiTetheringTest, GetCustomPortFilteringRuleP)
 733 {
 734         void *list;
 735
 736         EXPECT_EQ(TETHERING_ERROR_NONE,
 737                         tethering_wifi_get_custom_port_filtering_rule(handle, &list));
 738 }
 739
 740 TEST_F(WiFiTetheringTest, IsPortFilteringEnabledN)
 741 {
 742         bool enabled;
 743
 744         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 745                         tethering_wifi_is_port_filtering_enabled(NULL, &enabled));
 746         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 747                         tethering_wifi_is_port_filtering_enabled(handle, NULL));
 748         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 749                         tethering_wifi_is_port_filtering_enabled(NULL, NULL));
 750 }
 751
 752 TEST_F(WiFiTetheringTest, IsPortFilteringEnabledP)
 753 {
 754         bool enabled;
 755
 756         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_is_port_filtering_enabled(handle, &enabled));
 757 }
 758
 759 TEST_F(WiFiTetheringTest, SetVpnPassthroughRuleN)
 760 {
 761         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 762                         tethering_wifi_set_vpn_passthrough_rule(NULL, TETHERING_TYPE_IPSEC_PASSTHROUGH, true));
 763
 764         tethering_mock_set_gdbus_result(false);
 765         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED,
 766                         tethering_wifi_set_vpn_passthrough_rule(handle, TETHERING_TYPE_IPSEC_PASSTHROUGH, true));
 767
 768 }
 769
 770 TEST_F(WiFiTetheringTest, SetVpnPassthroughRuleP)
 771 {
 772         EXPECT_EQ(TETHERING_ERROR_NONE,
 773                         tethering_wifi_set_vpn_passthrough_rule(handle, TETHERING_TYPE_IPSEC_PASSTHROUGH, true));
 774 }
 775
 776 TEST_F(WiFiTetheringTest, PushWpsButtonN)
 777 {
 778         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_push_wps_button(NULL));
 779
 780         tethering_mock_set_gdbus_result(false);
 781         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED, tethering_wifi_push_wps_button(handle));
 782 }
 783
 784 TEST_F(WiFiTetheringTest, PushWpsButtonP)
 785 {
 786         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_push_wps_button(handle));
 787 }
 788
 789 TEST_F(WiFiTetheringTest, SetWpsPinN)
 790 {
 791         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_wps_pin(NULL, "1234567"));
 792         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_wps_pin(handle, NULL));
 793         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_wps_pin(NULL, NULL));
 794
 795         tethering_mock_set_gdbus_result(false);
 796         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED, tethering_wifi_set_wps_pin(handle, "1234567"));
 797 }
 798
 799 TEST_F(WiFiTetheringTest, SetWpsPinP)
 800 {
 801         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_set_wps_pin(handle, "1234567"));
 802 }
 803
 804 TEST_F(WiFiTetheringTest, SetSharingN)
 805 {
 806         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_set_sharing(NULL, true));
 807 }
 808
 809 TEST_F(WiFiTetheringTest, SetSharingP)
 810 {
 811         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_set_sharing(handle, true));
 812 }
 813
 814 TEST_F(WiFiTetheringTest, GetSharingN)
 815 {
 816         bool sharing;
 817
 818         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_sharing(NULL, &sharing));
 819         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_sharing(handle, NULL));
 820         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_wifi_get_sharing(NULL, NULL));
 821 }
 822
 823 TEST_F(WiFiTetheringTest, GetSharingP)
 824 {
 825         bool sharing;
 826
 827         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_wifi_get_ssid_visibility(handle, &sharing));
 828 }