tests/tethering-gtest-common.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 TetheringTest: 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                         tethering_create(&handle);
  41                         tethering_mock_set_enabled_state(true, true, true, true);
  42                 }
  43
  44                 void TearDown() override
  45                 {
  46                         tethering_mock_set_enabled_state(false, false, false, false);
  47                         tethering_destroy(handle);
  48                         tethering_mock_set_file_result(true);
  49                         tethering_mock_set_vconf_result(false);
  50                         tethering_mock_set_sysinfo_result(false);
  51                         tethering_mock_set_memory_result(true);
  52                         tethering_mock_set_gdbus_result(false);
  53                 }
  54 };
  55
  56 bool ConnectedClientsCallbackP(tethering_client_h client, void *data)
  57 {
  58         return true;
  59 }
  60
  61 bool ConnectedClientsCallbackN(tethering_client_h client, void *data)
  62 {
  63         return false;
  64 }
  65
  66 TEST_F(TetheringTest, CreateHandleN)
  67 {
  68         tethering_h test_handle = NULL;
  69
  70         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_create(NULL));
  71
  72         tethering_mock_set_memory_result(false);
  73         EXPECT_EQ(TETHERING_ERROR_OUT_OF_MEMORY, tethering_create(&test_handle));
  74 }
  75
  76 TEST_F(TetheringTest, CreateHandleP)
  77 {
  78         tethering_h test_handle = NULL;
  79
  80         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_create(&test_handle));
  81
  82         tethering_destroy(test_handle);
  83 }
  84
  85 TEST_F(TetheringTest, DestroyHandleN)
  86 {
  87         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER, tethering_destroy(NULL));
  88 }
  89
  90 TEST_F(TetheringTest, DestroyHandleP)
  91 {
  92         tethering_h test_handle = NULL;
  93
  94         tethering_create(&test_handle);
  95         EXPECT_EQ(TETHERING_ERROR_NONE, tethering_destroy(test_handle));
  96 }
  97
  98 TEST_F(TetheringTest, IsEnabledN)
  99 {
 100         EXPECT_EQ(false, tethering_is_enabled(handle, TETHERING_TYPE_ALL));
 101
 102         tethering_mock_set_vconf_result(false);
 103         EXPECT_EQ(false, tethering_is_enabled(handle, TETHERING_TYPE_USB));
 104 }
 105
 106 TEST_F(TetheringTest, IsEnabledP)
 107 {
 108         tethering_mock_set_enabled_state(true, true, true, true);
 109         EXPECT_EQ(true, tethering_is_enabled(handle, TETHERING_TYPE_USB));
 110         EXPECT_EQ(true, tethering_is_enabled(handle, TETHERING_TYPE_WIFI));
 111         EXPECT_EQ(true, tethering_is_enabled(handle, TETHERING_TYPE_BT));
 112         EXPECT_EQ(true, tethering_is_enabled(handle, TETHERING_TYPE_P2P));
 113
 114         tethering_mock_set_enabled_state(false, false, false, false);
 115         EXPECT_EQ(false, tethering_is_enabled(handle, TETHERING_TYPE_USB));
 116         EXPECT_EQ(false, tethering_is_enabled(handle, TETHERING_TYPE_WIFI));
 117         EXPECT_EQ(false, tethering_is_enabled(handle, TETHERING_TYPE_BT));
 118         EXPECT_EQ(false, tethering_is_enabled(handle, TETHERING_TYPE_P2P));
 119 }
 120
 121 TEST_F(TetheringTest, GetMacAddressN)
 122 {
 123         char *mac = NULL;
 124
 125         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 126                         tethering_get_mac_address(NULL, TETHERING_TYPE_USB, &mac));
 127         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 128                         tethering_get_mac_address(handle, TETHERING_TYPE_USB, NULL));
 129
 130         tethering_mock_set_enabled_state(false, false, false, false);
 131         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 132                         tethering_get_mac_address(handle, TETHERING_TYPE_USB, &mac));
 133         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 134                         tethering_get_mac_address(handle, TETHERING_TYPE_WIFI, &mac));
 135         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 136                         tethering_get_mac_address(handle, TETHERING_TYPE_BT, &mac));
 137         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 138                         tethering_get_mac_address(handle, TETHERING_TYPE_P2P, &mac));
 139 }
 140
 141 TEST_F(TetheringTest, GetMacAddressP)
 142 {
 143         char *mac = NULL;
 144
 145         EXPECT_EQ(TETHERING_ERROR_NONE,
 146                         tethering_get_mac_address(handle, TETHERING_TYPE_USB, &mac));
 147         free(mac);
 148
 149         EXPECT_EQ(TETHERING_ERROR_NONE,
 150                         tethering_get_mac_address(handle, TETHERING_TYPE_WIFI, &mac));
 151         free(mac);
 152
 153         EXPECT_EQ(TETHERING_ERROR_NONE,
 154                         tethering_get_mac_address(handle, TETHERING_TYPE_BT, &mac));
 155         free(mac);
 156 }
 157
 158 TEST_F(TetheringTest, GetNetworkInterfaceNameN)
 159 {
 160         char *interface_name = NULL;
 161
 162         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 163                         tethering_get_network_interface_name(NULL, TETHERING_TYPE_USB, &interface_name));
 164         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 165                         tethering_get_network_interface_name(handle, TETHERING_TYPE_USB, NULL));
 166
 167         tethering_mock_set_enabled_state(false, false, false, false);
 168         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 169                         tethering_get_network_interface_name(handle, TETHERING_TYPE_USB, &interface_name));
 170         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 171                         tethering_get_network_interface_name(handle, TETHERING_TYPE_WIFI, &interface_name));
 172         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 173                         tethering_get_network_interface_name(handle, TETHERING_TYPE_BT, &interface_name));
 174         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 175                         tethering_get_network_interface_name(handle, TETHERING_TYPE_P2P, &interface_name));
 176 }
 177
 178 TEST_F(TetheringTest, GetNetworkInterfaceNameP)
 179 {
 180         char *interface_name = NULL;
 181
 182         EXPECT_EQ(TETHERING_ERROR_NONE,
 183                         tethering_get_network_interface_name(handle, TETHERING_TYPE_USB, &interface_name));
 184         free(interface_name);
 185
 186         EXPECT_EQ(TETHERING_ERROR_NONE,
 187                         tethering_get_network_interface_name(handle, TETHERING_TYPE_WIFI, &interface_name));
 188         free(interface_name);
 189
 190         EXPECT_EQ(TETHERING_ERROR_NONE,
 191                         tethering_get_network_interface_name(handle, TETHERING_TYPE_BT, &interface_name));
 192         free(interface_name);
 193
 194         EXPECT_EQ(TETHERING_ERROR_NONE,
 195                         tethering_get_network_interface_name(handle, TETHERING_TYPE_P2P, &interface_name));
 196         free(interface_name);
 197 }
 198
 199 TEST_F(TetheringTest, GetIpAddressN)
 200 {
 201         char *ip = NULL;
 202
 203         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 204                         tethering_get_ip_address(NULL,
 205                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 206         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 207                         tethering_get_ip_address(handle,
 208                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 209         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 210                         tethering_get_ip_address(NULL,
 211                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 212
 213         tethering_mock_set_enabled_state(false, false, false, false);
 214         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 215                         tethering_get_ip_address(handle, TETHERING_TYPE_USB,
 216                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 217         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 218                         tethering_get_ip_address(handle, TETHERING_TYPE_WIFI,
 219                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 220         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 221                         tethering_get_ip_address(handle, TETHERING_TYPE_BT,
 222                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 223         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 224                         tethering_get_ip_address(handle, TETHERING_TYPE_P2P,
 225                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 226 }
 227
 228 TEST_F(TetheringTest, GetIpAddressP)
 229 {
 230         char *ip = NULL;
 231
 232         EXPECT_EQ(TETHERING_ERROR_NONE,
 233                         tethering_get_ip_address(handle, TETHERING_TYPE_USB,
 234                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 235         free(ip);
 236
 237         EXPECT_EQ(TETHERING_ERROR_NONE,
 238                         tethering_get_ip_address(handle, TETHERING_TYPE_WIFI,
 239                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 240         free(ip);
 241
 242         EXPECT_EQ(TETHERING_ERROR_NONE,
 243                         tethering_get_ip_address(handle, TETHERING_TYPE_BT,
 244                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 245         free(ip);
 246
 247         EXPECT_EQ(TETHERING_ERROR_NONE,
 248                         tethering_get_ip_address(handle, TETHERING_TYPE_P2P,
 249                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 250         free(ip);
 251 }
 252
 253 TEST_F(TetheringTest, SetIpAddressN)
 254 {
 255         const char *ip = "192.168.0.1";
 256
 257         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 258                         tethering_set_ip_address(NULL,
 259                                 TETHERING_TYPE_WIFI, TETHERING_ADDRESS_FAMILY_IPV4, ip));
 260         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 261                         tethering_set_ip_address(handle,
 262                                 TETHERING_TYPE_WIFI, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 263         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 264                         tethering_set_ip_address(NULL,
 265                                 TETHERING_TYPE_WIFI, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 266
 267         tethering_mock_set_enabled_state(false, false, false, false);
 268         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 269                         tethering_set_ip_address(handle, TETHERING_TYPE_USB,
 270                                 TETHERING_ADDRESS_FAMILY_IPV4, ip));
 271         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 272                         tethering_set_ip_address(handle, TETHERING_TYPE_BT,
 273                                 TETHERING_ADDRESS_FAMILY_IPV4, ip));
 274         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 275                         tethering_set_ip_address(handle, TETHERING_TYPE_P2P,
 276                                 TETHERING_ADDRESS_FAMILY_IPV4, ip));
 277 }
 278
 279 TEST_F(TetheringTest, SetIpAddressP)
 280 {
 281         const char *ip = "192.168.0.1";
 282
 283         EXPECT_EQ(TETHERING_ERROR_NONE,
 284                         tethering_set_ip_address(handle, TETHERING_TYPE_WIFI,
 285                                 TETHERING_ADDRESS_FAMILY_IPV4, ip));
 286
 287         tethering_mock_set_enabled_state(false, false, false, false);
 288         EXPECT_EQ(TETHERING_ERROR_NONE,
 289                         tethering_set_ip_address(handle, TETHERING_TYPE_WIFI,
 290                                 TETHERING_ADDRESS_FAMILY_IPV4, ip));
 291 }
 292
 293 TEST_F(TetheringTest, GetGatewayAddressN)
 294 {
 295         char *gateway = NULL;
 296
 297         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 298                         tethering_get_gateway_address(NULL,
 299                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 300         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 301                         tethering_get_gateway_address(handle,
 302                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 303         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 304                         tethering_get_gateway_address(NULL,
 305                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 306
 307         tethering_mock_set_enabled_state(false, false, false, false);
 308         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 309                         tethering_get_gateway_address(handle, TETHERING_TYPE_USB,
 310                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 311         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 312                         tethering_get_gateway_address(handle, TETHERING_TYPE_WIFI,
 313                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 314         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 315                         tethering_get_gateway_address(handle, TETHERING_TYPE_BT,
 316                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 317         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 318                         tethering_get_gateway_address(handle, TETHERING_TYPE_P2P,
 319                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 320 }
 321
 322 TEST_F(TetheringTest, GetGatewayAddressP)
 323 {
 324         char *gateway = NULL;
 325
 326         EXPECT_EQ(TETHERING_ERROR_NONE,
 327                         tethering_get_gateway_address(handle, TETHERING_TYPE_USB,
 328                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 329         free(gateway);
 330
 331         EXPECT_EQ(TETHERING_ERROR_NONE,
 332                         tethering_get_gateway_address(handle, TETHERING_TYPE_WIFI,
 333                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 334         free(gateway);
 335
 336         EXPECT_EQ(TETHERING_ERROR_NONE,
 337                         tethering_get_gateway_address(handle, TETHERING_TYPE_BT,
 338                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 339         free(gateway);
 340
 341         EXPECT_EQ(TETHERING_ERROR_NONE,
 342                         tethering_get_gateway_address(handle, TETHERING_TYPE_P2P,
 343                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 344         free(gateway);
 345 }
 346
 347 TEST_F(TetheringTest, GetSubnetMaskN)
 348 {
 349         char *subnetmask = NULL;
 350
 351         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 352                         tethering_get_subnet_mask(NULL,
 353                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 354         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 355                         tethering_get_subnet_mask(handle,
 356                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 357         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 358                         tethering_get_subnet_mask(NULL,
 359                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 360
 361         tethering_mock_set_enabled_state(false, false, false, false);
 362         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 363                         tethering_get_subnet_mask(handle, TETHERING_TYPE_USB,
 364                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 365         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 366                         tethering_get_subnet_mask(handle, TETHERING_TYPE_WIFI,
 367                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 368         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 369                         tethering_get_subnet_mask(handle, TETHERING_TYPE_BT,
 370                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 371         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 372                         tethering_get_subnet_mask(handle, TETHERING_TYPE_P2P,
 373                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 374 }
 375
 376 TEST_F(TetheringTest, GetSubnetMaskP)
 377 {
 378         char *subnetmask = NULL;
 379
 380         EXPECT_EQ(TETHERING_ERROR_NONE,
 381                         tethering_get_subnet_mask(handle, TETHERING_TYPE_USB,
 382                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 383         free(subnetmask);
 384
 385         EXPECT_EQ(TETHERING_ERROR_NONE,
 386                         tethering_get_subnet_mask(handle, TETHERING_TYPE_WIFI,
 387                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 388         free(subnetmask);
 389
 390         EXPECT_EQ(TETHERING_ERROR_NONE,
 391                         tethering_get_subnet_mask(handle, TETHERING_TYPE_BT,
 392                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 393         free(subnetmask);
 394
 395         EXPECT_EQ(TETHERING_ERROR_NONE,
 396                         tethering_get_subnet_mask(handle, TETHERING_TYPE_P2P,
 397                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 398         free(subnetmask);
 399 }
 400
 401 TEST_F(TetheringTest, ForeachConnectedClientsN)
 402 {
 403         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 404                         tethering_foreach_connected_clients(NULL, TETHERING_TYPE_USB,
 405                                 ConnectedClientsCallbackN, NULL));
 406         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 407                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_USB, NULL, NULL));
 408         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 409                         tethering_foreach_connected_clients(NULL, TETHERING_TYPE_USB, NULL, NULL));
 410
 411         tethering_mock_set_gdbus_result(false);
 412         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED,
 413                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_USB,
 414                                 ConnectedClientsCallbackN, NULL));
 415
 416         tethering_mock_set_gdbus_result(true);
 417         tethering_mock_set_enabled_state(false, false, false, false);
 418         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 419                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_USB,
 420                                 ConnectedClientsCallbackN, NULL));
 421 }
 422
 423 TEST_F(TetheringTest, ForeachConnectedClientsP)
 424 {
 425         EXPECT_EQ(TETHERING_ERROR_NONE,
 426                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_USB,
 427                                 ConnectedClientsCallbackP, NULL));
 428         EXPECT_EQ(TETHERING_ERROR_NONE,
 429                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_WIFI,
 430                                 ConnectedClientsCallbackP, NULL));
 431         EXPECT_EQ(TETHERING_ERROR_NONE,
 432                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_BT,
 433                                 ConnectedClientsCallbackP, NULL));
 434         EXPECT_EQ(TETHERING_ERROR_NONE,
 435                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_P2P,
 436                                 ConnectedClientsCallbackP, NULL));
 437 }