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
 195 TEST_F(TetheringTest, GetIpAddressN)
 196 {
 197         char *ip = NULL;
 198
 199         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 200                         tethering_get_ip_address(NULL,
 201                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 202         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 203                         tethering_get_ip_address(handle,
 204                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 205         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 206                         tethering_get_ip_address(NULL,
 207                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 208
 209         tethering_mock_set_enabled_state(false, false, false, false);
 210         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 211                         tethering_get_ip_address(handle, TETHERING_TYPE_USB,
 212                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 213         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 214                         tethering_get_ip_address(handle, TETHERING_TYPE_WIFI,
 215                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 216         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 217                         tethering_get_ip_address(handle, TETHERING_TYPE_BT,
 218                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 219         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 220                         tethering_get_ip_address(handle, TETHERING_TYPE_P2P,
 221                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 222 }
 223
 224 TEST_F(TetheringTest, GetIpAddressP)
 225 {
 226         char *ip = NULL;
 227
 228         EXPECT_EQ(TETHERING_ERROR_NONE,
 229                         tethering_get_ip_address(handle, TETHERING_TYPE_USB,
 230                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 231         free(ip);
 232
 233         EXPECT_EQ(TETHERING_ERROR_NONE,
 234                         tethering_get_ip_address(handle, TETHERING_TYPE_WIFI,
 235                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 236         free(ip);
 237
 238         EXPECT_EQ(TETHERING_ERROR_NONE,
 239                         tethering_get_ip_address(handle, TETHERING_TYPE_BT,
 240                                 TETHERING_ADDRESS_FAMILY_IPV4, &ip));
 241         free(ip);
 242 }
 243
 244 TEST_F(TetheringTest, GetGatewayAddressN)
 245 {
 246         char *gateway = NULL;
 247
 248         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 249                         tethering_get_gateway_address(NULL,
 250                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 251         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 252                         tethering_get_gateway_address(handle,
 253                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 254         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 255                         tethering_get_gateway_address(NULL,
 256                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 257
 258         tethering_mock_set_enabled_state(false, false, false, false);
 259         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 260                         tethering_get_gateway_address(handle, TETHERING_TYPE_USB,
 261                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 262         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 263                         tethering_get_gateway_address(handle, TETHERING_TYPE_WIFI,
 264                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 265         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 266                         tethering_get_gateway_address(handle, TETHERING_TYPE_BT,
 267                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 268         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 269                         tethering_get_gateway_address(handle, TETHERING_TYPE_P2P,
 270                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 271 }
 272
 273 TEST_F(TetheringTest, GetGatewayAddressP)
 274 {
 275         char *gateway = NULL;
 276
 277         EXPECT_EQ(TETHERING_ERROR_NONE,
 278                         tethering_get_gateway_address(handle, TETHERING_TYPE_USB,
 279                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 280         free(gateway);
 281
 282         EXPECT_EQ(TETHERING_ERROR_NONE,
 283                         tethering_get_gateway_address(handle, TETHERING_TYPE_WIFI,
 284                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 285         free(gateway);
 286
 287         EXPECT_EQ(TETHERING_ERROR_NONE,
 288                         tethering_get_gateway_address(handle, TETHERING_TYPE_BT,
 289                                 TETHERING_ADDRESS_FAMILY_IPV4, &gateway));
 290         free(gateway);
 291 }
 292
 293 TEST_F(TetheringTest, GetSubnetMaskN)
 294 {
 295         char *subnetmask = NULL;
 296
 297         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 298                         tethering_get_subnet_mask(NULL,
 299                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 300         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 301                         tethering_get_subnet_mask(handle,
 302                                 TETHERING_TYPE_USB, TETHERING_ADDRESS_FAMILY_IPV4, NULL));
 303         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 304                         tethering_get_subnet_mask(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_subnet_mask(handle, TETHERING_TYPE_USB,
 310                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 311         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 312                         tethering_get_subnet_mask(handle, TETHERING_TYPE_WIFI,
 313                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 314         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 315                         tethering_get_subnet_mask(handle, TETHERING_TYPE_BT,
 316                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 317         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 318                         tethering_get_subnet_mask(handle, TETHERING_TYPE_P2P,
 319                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 320 }
 321
 322 TEST_F(TetheringTest, GetSubnetMaskP)
 323 {
 324         char *subnetmask = NULL;
 325
 326         EXPECT_EQ(TETHERING_ERROR_NONE,
 327                         tethering_get_subnet_mask(handle, TETHERING_TYPE_USB,
 328                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 329         free(subnetmask);
 330
 331         EXPECT_EQ(TETHERING_ERROR_NONE,
 332                         tethering_get_subnet_mask(handle, TETHERING_TYPE_WIFI,
 333                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 334         free(subnetmask);
 335
 336         EXPECT_EQ(TETHERING_ERROR_NONE,
 337                         tethering_get_subnet_mask(handle, TETHERING_TYPE_BT,
 338                                 TETHERING_ADDRESS_FAMILY_IPV4, &subnetmask));
 339         free(subnetmask);
 340 }
 341
 342 TEST_F(TetheringTest, ForeachConnectedClientsN)
 343 {
 344         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 345                         tethering_foreach_connected_clients(NULL, TETHERING_TYPE_USB,
 346                                 ConnectedClientsCallbackN, NULL));
 347         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 348                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_USB, NULL, NULL));
 349         EXPECT_EQ(TETHERING_ERROR_INVALID_PARAMETER,
 350                         tethering_foreach_connected_clients(NULL, TETHERING_TYPE_USB, NULL, NULL));
 351
 352         tethering_mock_set_gdbus_result(false);
 353         EXPECT_EQ(TETHERING_ERROR_OPERATION_FAILED,
 354                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_USB,
 355                                 ConnectedClientsCallbackN, NULL));
 356
 357         tethering_mock_set_gdbus_result(true);
 358         tethering_mock_set_enabled_state(false, false, false, false);
 359         EXPECT_EQ(TETHERING_ERROR_NOT_ENABLED,
 360                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_USB,
 361                                 ConnectedClientsCallbackN, NULL));
 362 }
 363
 364 TEST_F(TetheringTest, ForeachConnectedClientsP)
 365 {
 366         EXPECT_EQ(TETHERING_ERROR_NONE,
 367                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_USB,
 368                                 ConnectedClientsCallbackP, NULL));
 369         EXPECT_EQ(TETHERING_ERROR_NONE,
 370                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_WIFI,
 371                                 ConnectedClientsCallbackP, NULL));
 372         EXPECT_EQ(TETHERING_ERROR_NONE,
 373                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_BT,
 374                                 ConnectedClientsCallbackP, NULL));
 375         EXPECT_EQ(TETHERING_ERROR_NONE,
 376                         tethering_foreach_connected_clients(handle, TETHERING_TYPE_P2P,
 377                                 ConnectedClientsCallbackP, NULL));
 378 }