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, GetGatewayAddressN)
 254 {
 255         char *gateway = NULL;
 256
 257         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 258                         tethering_get_gateway_address(NULL,
 259                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 260         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 261                         tethering_get_gateway_address(handle,
 262                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 263         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 264                         tethering_get_gateway_address(NULL,
 265                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 266
 267         tethering_mock_set_enabled_state(false, false, false, false);
 268         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 269                         tethering_get_gateway_address(handle, TETHERING_TYPE_USB,
 270                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 271         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 272                         tethering_get_gateway_address(handle, TETHERING_TYPE_WIFI,
 273                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 274         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 275                         tethering_get_gateway_address(handle, TETHERING_TYPE_BT,
 276                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 277         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 278                         tethering_get_gateway_address(handle, TETHERING_TYPE_P2P,
 279                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 280 }
 281
 282 TEST_F(TetheringTest, GetGatewayAddressP)
 283 {
 284         char *gateway = NULL;
 285
 286         EXPECT_EQ(TETHERING_ERROR_NONE,
 287                         tethering_get_gateway_address(handle, TETHERING_TYPE_USB,
 288                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 289         free(gateway);
 290
 291         EXPECT_EQ(TETHERING_ERROR_NONE,
 292                         tethering_get_gateway_address(handle, TETHERING_TYPE_WIFI,
 293                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 294         free(gateway);
 295
 296         EXPECT_EQ(TETHERING_ERROR_NONE,
 297                         tethering_get_gateway_address(handle, TETHERING_TYPE_BT,
 298                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 299         free(gateway);
 300
 301         EXPECT_EQ(TETHERING_ERROR_NONE,
 302                         tethering_get_gateway_address(handle, TETHERING_TYPE_P2P,
 303                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 304         free(gateway);
 305 }
 306
 307 TEST_F(TetheringTest, GetSubnetMaskN)
 308 {
 309         char *subnetmask = NULL;
 310
 311         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 312                         tethering_get_subnet_mask(NULL,
 313                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 314         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 315                         tethering_get_subnet_mask(handle,
 316                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 317         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 318                         tethering_get_subnet_mask(NULL,
 319                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 320
 321         tethering_mock_set_enabled_state(false, false, false, false);
 322         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 323                         tethering_get_subnet_mask(handle, TETHERING_TYPE_USB,
 324                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 325         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 326                         tethering_get_subnet_mask(handle, TETHERING_TYPE_WIFI,
 327                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 328         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 329                         tethering_get_subnet_mask(handle, TETHERING_TYPE_BT,
 330                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 331         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 332                         tethering_get_subnet_mask(handle, TETHERING_TYPE_P2P,
 333                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 334 }
 335
 336 TEST_F(TetheringTest, GetSubnetMaskP)
 337 {
 338         char *subnetmask = NULL;
 339
 340         EXPECT_EQ(TETHERING_ERROR_NONE,
 341                         tethering_get_subnet_mask(handle, TETHERING_TYPE_USB,
 342                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 343         free(subnetmask);
 344
 345         EXPECT_EQ(TETHERING_ERROR_NONE,
 346                         tethering_get_subnet_mask(handle, TETHERING_TYPE_WIFI,
 347                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 348         free(subnetmask);
 349
 350         EXPECT_EQ(TETHERING_ERROR_NONE,
 351                         tethering_get_subnet_mask(handle, TETHERING_TYPE_BT,
 352                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 353         free(subnetmask);
 354
 355         EXPECT_EQ(TETHERING_ERROR_NONE,
 356                         tethering_get_subnet_mask(handle, TETHERING_TYPE_P2P,
 357                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 358         free(subnetmask);
 359 }
 360
 361 TEST_F(TetheringTest, ForeachConnectedClientsN)
 362 {
 363         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 364                         tethering_foreach_connected_clients(NULL, TETHERING_TYPE_USB,
 365                                 ConnectedClientsCallbackN, NULL));
 366         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 367                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_USB, NULL, NULL));
 368         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 369                         tethering_foreach_connected_clients(NULL, TETHERING_TYPE_USB, NULL, NULL));
 370
 371         tethering_mock_set_gdbus_result(false);
 372         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED,
 373                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_USB,
 374                                 ConnectedClientsCallbackN, NULL));
 375
 376         tethering_mock_set_gdbus_result(true);
 377         tethering_mock_set_enabled_state(false, false, false, false);
 378         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 379                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_USB,
 380                                 ConnectedClientsCallbackN, NULL));
 381 }
 382
 383 TEST_F(TetheringTest, ForeachConnectedClientsP)
 384 {
 385         EXPECT_EQ(TETHERING_ERROR_NONE,
 386                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_USB,
 387                                 ConnectedClientsCallbackP, NULL));
 388         EXPECT_EQ(TETHERING_ERROR_NONE,
 389                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_WIFI,
 390                                 ConnectedClientsCallbackP, NULL));
 391         EXPECT_EQ(TETHERING_ERROR_NONE,
 392                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_BT,
 393                                 ConnectedClientsCallbackP, NULL));
 394         EXPECT_EQ(TETHERING_ERROR_NONE,
 395                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_P2P,
 396                                 ConnectedClientsCallbackP, NULL));
 397 }