haltests/net-config-haltests.cpp

   1 /*
   2  * Copyright (c) 2018 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 <stdio.h>
  18 #include <stdlib.h>
  19 #include <iostream>
  20 #include <gmock/gmock.h>
  21 #include <gtest/gtest.h>
  22 #include <unistd.h>
  23 #include <wifi-manager.h>
  24 #include <wifi-direct.h>
  25 #include <softap.h>
  26 #include <system_info.h>
  27 #include "haltests.h"
  28
  29 using ::testing::InitGoogleTest;
  30 using ::testing::Test;
  31 using ::testing::TestCase;
  32
  33 static char ap_name[MAX_AP_LENGTH];
  34 static wifi_manager_h wifi = NULL;
  35 static wifi_manager_error_e rst = WIFI_MANAGER_ERROR_NOT_SUPPORTED;
  36 wifi_manager_ap_h g_hWifiAP;
  37
  38 static int rst_p2p = WIFI_DIRECT_ERROR_OPERATION_FAILED;
  39 static wifi_direct_device_state_e dev_state = WIFI_DIRECT_DEVICE_STATE_DEACTIVATED;
  40 static char p2p_ifname[MAX_PATH_LENGTH];
  41
  42 static softap_h sa = NULL;
  43 static bool g_is_requested;
  44 static softap_error_e g_error;
  45 static softap_disabled_cause_e g_code;
  46
  47 static bool __check_feature_supported(char *key)
  48 {
  49         bool value = false;
  50         int ret = system_info_get_platform_bool(key, &value);
  51
  52         EXPECT_EQ(SYSTEM_INFO_ERROR_NONE, ret) << "system_info_get_platform_bool failed";
  53         EXPECT_EQ(true, value) << key << " feature is not supported";
  54
  55         return value;
  56 }
  57
  58 static void __test_callback(wifi_manager_error_e result, void* user_data)
  59 {
  60         rst = result;
  61         QUIT_GMAIN_LOOP;
  62 }
  63
  64 static gboolean __timeout_callback(gpointer data)
  65 {
  66         EXPECT_TRUE(0) << "Wi-Fi TC callback timeout!";
  67         QUIT_GMAIN_LOOP;
  68         return FALSE;
  69 }
  70
  71 static void __device_state_changed_cb(int error_code,
  72                 wifi_direct_device_state_e device_state, void *user_data)
  73 {
  74         rst_p2p = error_code;
  75         dev_state = device_state;
  76         QUIT_GMAIN_LOOP;
  77 }
  78
  79 static void __enabled_cb(softap_error_e error, bool is_requested, void *data)
  80 {
  81         g_error = error;
  82         g_is_requested = is_requested;
  83         QUIT_GMAIN_LOOP;
  84 }
  85
  86 static void __disabled_cb(softap_error_e error, softap_disabled_cause_e code, void *data)
  87 {
  88         g_error = error;
  89         g_code = code;
  90         QUIT_GMAIN_LOOP;
  91 }
  92
  93 static void __set_p2p_ifname(void)
  94 {
  95         GKeyFile *key_file = NULL;
  96         GError *error = NULL;
  97         char *ifn = NULL;
  98
  99         key_file = g_key_file_new();
 100         if (!g_key_file_load_from_file(key_file, WIFI_P2P_CONFIG_PATH, G_KEY_FILE_NONE, &error)) {
 101                 g_clear_error(&error);
 102                 g_key_file_free(key_file);
 103                 key_file = NULL;
 104                 return;
 105         }
 106
 107         ifn = g_key_file_get_string(key_file, WFD_CONF_GROUP_NAME, "p2p_interface", &error);
 108         if (ifn)
 109                 g_snprintf(p2p_ifname, MAX_PATH_LENGTH, "/sys/class/net/%s/address", ifn);
 110
 111         if (error)
 112                 g_clear_error(&error);
 113         g_key_file_free(key_file);
 114 }
 115
 116 static bool __found_ap_callback(wifi_manager_ap_h ap, void *user_data)
 117 {
 118         char *ap_name = NULL;
 119         char *ap_name_part = (char *)user_data;
 120         size_t ap_name_len = strlen(ap_name_part);
 121         int ret = WIFI_MANAGER_ERROR_NONE;
 122
 123         if (ap) {
 124                 ret = wifi_manager_ap_get_essid(ap, &ap_name);
 125                 EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, ret) << "Unable to get essid";
 126
 127                 if (!ap_name)
 128                         return true;
 129
 130                 if (!strncmp(ap_name, ap_name_part, ap_name_len)) {
 131                         g_free(ap_name);
 132                         ret = wifi_manager_ap_clone(&g_hWifiAP, ap);
 133                         EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, ret) << "Unable to clone the AP handle";
 134                         if (g_hWifiAP) {
 135                                 rst = WIFI_MANAGER_ERROR_NONE;
 136                                 return false;
 137                         }
 138                 }
 139         }
 140
 141         return true;
 142 }
 143
 144 TEST(Hal_wifi, Init_p)
 145 {
 146         g_bFeatureWifi = __check_feature_supported((char*)FEATURE_WIFI);
 147         ASSERT_EQ(true, g_bFeatureWifi) << FEATURE_WIFI << " feature is not supported";
 148
 149         int rv = wifi_manager_initialize(&wifi);
 150         EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, rv) << "Initialization failure";
 151 }
 152
 153 TEST(Hal_wifi, Activate_p)
 154 {
 155         ASSERT_EQ(true, g_bFeatureWifi) << FEATURE_WIFI << " feature is not supported";
 156
 157         int rv;
 158         bool activated;
 159
 160         rv = wifi_manager_is_activated(wifi, &activated);
 161         ASSERT_EQ(WIFI_MANAGER_ERROR_NONE, rv) << "Failed to get Wi-Fi device state";
 162
 163         if (activated)
 164                 goto done;
 165
 166         rv = wifi_manager_activate(wifi, __test_callback, NULL);
 167         ASSERT_EQ(WIFI_MANAGER_ERROR_NONE, rv) << "Failed to activate Wi-Fi device";
 168
 169         RUN_GMAIN_LOOP(__timeout_callback);
 170
 171         EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, rst) << "Activetion failure";
 172         rst = WIFI_MANAGER_ERROR_NOT_SUPPORTED;
 173
 174 done:
 175         rv = access(WIFI_ADDRESS_PATH, F_OK);
 176         EXPECT_EQ(0, rv) << "Could not access " << WIFI_ADDRESS_PATH;
 177 }
 178
 179 TEST(Hal_wifi, Scan_p)
 180 {
 181         ASSERT_EQ(true, g_bFeatureWifi) << FEATURE_WIFI << " feature is not supported";
 182
 183         int rv = wifi_manager_scan(wifi, __test_callback, NULL);
 184         ASSERT_EQ(WIFI_MANAGER_ERROR_NONE, rv) << "Failed to scan";
 185
 186         RUN_GMAIN_LOOP(__timeout_callback);
 187
 188         EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, rst) << "Scan failure";
 189         rst = WIFI_MANAGER_ERROR_NOT_SUPPORTED;
 190 }
 191
 192 TEST(Hal_wifi, Connect_p)
 193 {
 194         ASSERT_EQ(true, g_bFeatureWifi) << FEATURE_WIFI << " feature is not supported";
 195
 196         wifi_manager_connection_state_e connection_state;
 197         int ret = WIFI_MANAGER_ERROR_NONE;
 198
 199         ret = wifi_manager_get_connection_state(wifi, &connection_state);
 200         ASSERT_EQ(WIFI_MANAGER_ERROR_NONE, ret) << "Failed to get connection state";
 201
 202         if (connection_state == WIFI_MANAGER_CONNECTION_STATE_CONNECTED)
 203                 return;
 204
 205         if (!ap_name[0])
 206                 return;
 207
 208         ret = wifi_manager_foreach_found_ap(wifi, __found_ap_callback, (char *)ap_name);
 209         ASSERT_EQ(WIFI_MANAGER_ERROR_NONE, rst) << "Failed to find the AP";
 210         rst = WIFI_MANAGER_ERROR_NOT_SUPPORTED;
 211
 212         ret = wifi_manager_connect(wifi, g_hWifiAP, __test_callback, NULL);
 213         ASSERT_EQ(WIFI_MANAGER_ERROR_NONE, ret) << "Failed to connect";
 214
 215         RUN_GMAIN_LOOP(__timeout_callback);
 216
 217         EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, rst) << "Connection failure";
 218         rst = WIFI_MANAGER_ERROR_NOT_SUPPORTED;
 219 }
 220
 221 TEST(Hal_wifi, Disconnect_p)
 222 {
 223         ASSERT_EQ(true, g_bFeatureWifi) << FEATURE_WIFI << " feature is not supported";
 224
 225         int ret = WIFI_MANAGER_ERROR_NONE;
 226         wifi_manager_ap_h hAP = NULL;
 227
 228         ret = wifi_manager_get_connected_ap(wifi, &hAP);
 229         if (ret == WIFI_MANAGER_ERROR_NO_CONNECTION)
 230                 return;
 231         ASSERT_EQ(WIFI_MANAGER_ERROR_NONE, ret) << "Failed to get connected AP";
 232
 233         ret = wifi_manager_disconnect(wifi, hAP, __test_callback, NULL);
 234         ASSERT_EQ(WIFI_MANAGER_ERROR_NONE, ret) << "Failed to disconnect";
 235
 236         RUN_GMAIN_LOOP(__timeout_callback);
 237
 238         EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, rst) << "Disconnection failure";
 239         rst = WIFI_MANAGER_ERROR_NOT_SUPPORTED;
 240
 241         ret = wifi_manager_forget_ap(wifi, hAP);
 242         EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, ret) << "Failed to forget AP";
 243 }
 244
 245 TEST(Hal_wifi, Deactivate_p)
 246 {
 247         ASSERT_EQ(true, g_bFeatureWifi) << FEATURE_WIFI << " feature is not supported";
 248
 249         int rv = wifi_manager_deactivate(wifi, __test_callback, NULL);
 250         ASSERT_EQ(WIFI_MANAGER_ERROR_NONE, rv) << "Failed to deactivate Wi-Fi device";
 251
 252         RUN_GMAIN_LOOP(__timeout_callback);
 253
 254         EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, rst) << "Deactivation failure";
 255         rst = WIFI_MANAGER_ERROR_NOT_SUPPORTED;
 256
 257         rv = access(WIFI_ADDRESS_PATH, F_OK);
 258         EXPECT_EQ(-1, rv) << WIFI_ADDRESS_PATH << " is exist";
 259 }
 260
 261 TEST(Hal_wifi, Deinit_p)
 262 {
 263         ASSERT_EQ(true, g_bFeatureWifi) << FEATURE_WIFI << " feature is not supported";
 264
 265         int rv = wifi_manager_deinitialize(wifi);
 266         EXPECT_EQ(WIFI_MANAGER_ERROR_NONE, rv) << "Deinitialization failure";
 267 }
 268
 269 TEST(Hal_wifi_direct, Init_p)
 270 {
 271         g_bFeatureP2P = __check_feature_supported((char*)WIFIDIRECT_FEATURE);
 272         ASSERT_EQ(true, g_bFeatureP2P) << WIFIDIRECT_FEATURE << " feature is not supported";
 273
 274         int rv = wifi_direct_initialize();
 275         EXPECT_EQ(WIFI_DIRECT_ERROR_NONE, rv) << "Initialization failure";
 276 }
 277
 278 TEST(Hal_wifi_direct, Activate_p)
 279 {
 280         ASSERT_EQ(true, g_bFeatureP2P) << WIFIDIRECT_FEATURE << " feature is not supported";
 281
 282         int rv;
 283         wifi_direct_state_e state = WIFI_DIRECT_STATE_ACTIVATED;
 284
 285         rv = wifi_direct_get_state(&state);
 286         ASSERT_EQ(0, rv) << "Failed to get Wi-Fi Direct device state";
 287
 288         if (state != WIFI_DIRECT_STATE_DEACTIVATED)
 289                 goto done;
 290
 291         rv = wifi_direct_set_device_state_changed_cb(__device_state_changed_cb, NULL);
 292         ASSERT_EQ(WIFI_DIRECT_ERROR_NONE, rv) << "Failed to set activation callback";
 293
 294         rv = wifi_direct_activate();
 295         ASSERT_EQ(WIFI_DIRECT_ERROR_NONE, rv) << "Failed to activate Wi-Fi Direct device";
 296
 297         RUN_GMAIN_LOOP(__timeout_callback);
 298
 299         EXPECT_EQ(WIFI_DIRECT_ERROR_NONE, rst_p2p) << "Activetion failure";
 300         rst_p2p = WIFI_DIRECT_ERROR_OPERATION_FAILED;
 301
 302         rv = wifi_direct_get_state(&state);
 303         EXPECT_EQ(0, rv) << "Failed to get Wi-Fi Direct device state";
 304         EXPECT_EQ(WIFI_DIRECT_STATE_ACTIVATED, state) << "Activetion failure";
 305
 306 done:
 307         if (p2p_ifname[0])
 308                 rv = access(p2p_ifname, F_OK);
 309         else
 310                 rv = access(WIFI_P2P_PATH, F_OK);
 311         EXPECT_EQ(0, rv) << "Could not access " << WIFI_ADDRESS_PATH;
 312 }
 313
 314 TEST(Hal_wifi_direct, Deactivate_p)
 315 {
 316         ASSERT_EQ(true, g_bFeatureP2P) << WIFIDIRECT_FEATURE << " feature is not supported";
 317
 318         int rv;
 319
 320         rv = wifi_direct_deactivate();
 321         ASSERT_EQ(WIFI_DIRECT_ERROR_NONE, rv) << "Failed to deactivate Wi-Fi Direct";
 322
 323         RUN_GMAIN_LOOP(__timeout_callback);
 324
 325         EXPECT_EQ(WIFI_DIRECT_ERROR_NONE, rst_p2p) << "Deactivation failure";
 326         rst_p2p = WIFI_DIRECT_ERROR_OPERATION_FAILED;
 327
 328         wifi_direct_state_e state = WIFI_DIRECT_STATE_ACTIVATED;
 329         rv = wifi_direct_get_state(&state);
 330         EXPECT_EQ(0, rv) << "Failed to get Wi-Fi Direct device state";
 331
 332         EXPECT_EQ(WIFI_DIRECT_STATE_DEACTIVATED, state) << "Deactivetion failure";
 333
 334         if (p2p_ifname[0])
 335                 rv = access(p2p_ifname, F_OK);
 336         else
 337                 rv = access(WIFI_P2P_PATH, F_OK);
 338         EXPECT_EQ(-1, rv) << WIFI_P2P_PATH << " is exist";
 339
 340         rv = wifi_direct_unset_device_state_changed_cb();
 341         EXPECT_EQ(WIFI_DIRECT_ERROR_NONE, rv) << "Failed to unset activation callback";
 342 }
 343
 344 TEST(Hal_wifi_direct, Deinit_p)
 345 {
 346         ASSERT_EQ(true, g_bFeatureP2P) << WIFIDIRECT_FEATURE << " feature is not supported";
 347
 348         int rv = wifi_direct_deinitialize();
 349         EXPECT_EQ(WIFI_DIRECT_ERROR_NONE, rv) << "Deinitialization failure";
 350 }
 351
 352 TEST(Hal_softap, Init_p)
 353 {
 354         g_bFeatureWifi = __check_feature_supported((char*)FEATURE_WIFI);
 355         ASSERT_EQ(true, g_bFeatureWifi) << FEATURE_WIFI << " feature is not supported";
 356
 357         int ret = SOFTAP_ERROR_NONE;
 358
 359         ret = softap_create(&sa);
 360         ASSERT_EQ(SOFTAP_ERROR_NONE, ret) << "Initialization failure";
 361
 362         ret = softap_set_enabled_cb(sa, __enabled_cb, NULL);
 363         EXPECT_EQ(SOFTAP_ERROR_NONE, ret) << "Fail to set enabled callback!!";
 364
 365         ret = softap_set_disabled_cb(sa, __disabled_cb, NULL);
 366         EXPECT_EQ(SOFTAP_ERROR_NONE, ret) << "Fail to set disabled callback!!";
 367 }
 368
 369 TEST(Hal_softap, Activate_p)
 370 {
 371         ASSERT_EQ(true, g_bFeatureWifi) << FEATURE_WIFI << " feature is not supported";
 372
 373         int ret = SOFTAP_ERROR_NONE;
 374         bool enabled = false;
 375
 376         ret = softap_is_enabled(sa, &enabled);
 377         ASSERT_EQ(SOFTAP_ERROR_NONE, ret) << "Failed to get SoftAP state";
 378
 379         if (enabled)
 380                 goto done;
 381
 382         ret = softap_enable(sa);
 383         ASSERT_EQ(SOFTAP_ERROR_NONE, ret) << "Failed to enable SoftAP";
 384
 385         RUN_GMAIN_LOOP(__timeout_callback);
 386
 387         EXPECT_EQ(SOFTAP_ERROR_NONE, g_error) << "Failed to enable SoftAP";
 388         EXPECT_EQ(true, g_is_requested) << "Failed to enable SoftAP";
 389
 390 done:
 391         ret = access(WIFI_ADDRESS_PATH, F_OK);
 392         EXPECT_EQ(0, ret) << "Could not access " << WIFI_ADDRESS_PATH;
 393 }
 394
 395 TEST(Hal_softap, Deactivate_p)
 396 {
 397         ASSERT_EQ(true, g_bFeatureWifi) << FEATURE_WIFI << " feature is not supported";
 398
 399         int ret = SOFTAP_ERROR_NONE;
 400
 401         ret = softap_disable(sa);
 402         ASSERT_EQ(SOFTAP_ERROR_NONE, ret) << "Failed to disable SoftAP";
 403
 404         RUN_GMAIN_LOOP(__timeout_callback);
 405
 406         EXPECT_EQ(SOFTAP_ERROR_NONE, g_error) << "Failed to disable SoftAP" << g_code;
 407
 408         ret = access(WIFI_ADDRESS_PATH, F_OK);
 409         EXPECT_EQ(-1, ret) << WIFI_ADDRESS_PATH << " is exist";
 410 }
 411
 412 TEST(Hal_softap, Deinit_p)
 413 {
 414         ASSERT_EQ(true, g_bFeatureWifi) << FEATURE_WIFI << " feature is not supported";
 415
 416         int ret = SOFTAP_ERROR_NONE;
 417
 418         ret = softap_unset_enabled_cb(sa);
 419         EXPECT_EQ(SOFTAP_ERROR_NONE, ret) << "Fail to unset enabled callback!!";
 420
 421         ret = softap_unset_disabled_cb(sa);
 422         EXPECT_EQ(SOFTAP_ERROR_NONE, ret) << "Fail to unset disabled callback!!";
 423
 424         ret = softap_destroy(sa);
 425         EXPECT_EQ(SOFTAP_ERROR_NONE, ret) << "Deinitialization failure";
 426 }
 427
 428 int main(int argc, char **argv)
 429 {
 430         if (argc > 1 && argv[argc - 1][0] != '-') {
 431                 g_strlcpy(ap_name, argv[argc - 1], MAX_AP_LENGTH);
 432                 argc--;
 433         }
 434
 435         __set_p2p_ifname();
 436         InitGoogleTest(&argc, argv);
 437         return RUN_ALL_TESTS();
 438 }