gtest/unittest.cpp

   1 /*
   2  * Copyright (c) 2017 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 <sys/socket.h>
  24 #include <glib.h>
  25 #include <vpn_service.h>
  26
  27 #include "netconf.h"
  28 #include "netstat.h"
  29 #include "mptcp.h"
  30 #include "network_state.h"
  31 #include "vpn.h"
  32 #include "wifi.h"
  33
  34 using ::testing::InitGoogleTest;
  35 using ::testing::Test;
  36 using ::testing::TestCase;
  37 using namespace std;
  38
  39 char *mesh_id = (char *)"gtestnetwork";
  40
  41 TEST(NetworkStatistics, GetWifiTotalTxBytes_p)
  42 {
  43         error_e ret = ERROR_NONE;
  44         NetStat mgr;
  45
  46         ret = mgr.GetWifiTotalTxBytes();
  47         EXPECT_EQ(ERROR_NONE, ret);
  48 }
  49
  50 TEST(NetworkStatistics, GetWifiTotalRxBytes_p)
  51 {
  52         error_e ret = ERROR_NONE;
  53         NetStat mgr;
  54
  55         ret = mgr.GetWifiTotalRxBytes();
  56         EXPECT_EQ(ERROR_NONE, ret);
  57 }
  58
  59 TEST(NetworkStatistics, GetWifiLastTxBytes_p)
  60 {
  61         error_e ret = ERROR_NONE;
  62         NetStat mgr;
  63
  64         ret = mgr.GetWifiLastTxBytes();
  65         EXPECT_EQ(ERROR_NONE, ret);
  66 }
  67
  68 TEST(NetworkStatistics, GetWifiLastRxBytes_p)
  69 {
  70         error_e ret = ERROR_NONE;
  71         NetStat mgr;
  72
  73         ret = mgr.GetWifiLastRxBytes();
  74         EXPECT_EQ(ERROR_NONE, ret);
  75 }
  76
  77 TEST(NetworkStatistics, ResetCellularTotalTxBytes_p)
  78 {
  79         error_e ret = ERROR_NONE;
  80         NetStat mgr;
  81
  82         ret = mgr.ResetCellularTotalTxBytes();
  83         EXPECT_EQ(ERROR_NONE, ret);
  84 }
  85
  86 TEST(NetworkStatistics, ResetCellularTotalRxBytes_p)
  87 {
  88         error_e ret = ERROR_NONE;
  89         NetStat mgr;
  90
  91         ret = mgr.ResetCellularTotalRxBytes();
  92         EXPECT_EQ(ERROR_NONE, ret);
  93 }
  94
  95 TEST(NetworkStatistics, ResetCellularLastTxBytes_p)
  96 {
  97         error_e ret = ERROR_NONE;
  98         NetStat mgr;
  99
 100         ret = mgr.ResetCellularLastTxBytes();
 101         EXPECT_EQ(ERROR_NONE, ret);
 102 }
 103
 104 TEST(NetworkStatistics, ResetCellularLastRxBytes_p)
 105 {
 106         error_e ret = ERROR_NONE;
 107         NetStat mgr;
 108
 109         ret = mgr.ResetCellularLastRxBytes();
 110         EXPECT_EQ(ERROR_NONE, ret);
 111 }
 112
 113 TEST(NetworkStatistics, ResetWifiTotalTxBytes_p)
 114 {
 115         error_e ret = ERROR_NONE;
 116         NetStat mgr;
 117
 118         ret = mgr.ResetWifiTotalTxBytes();
 119         EXPECT_EQ(ERROR_NONE, ret);
 120 }
 121
 122 TEST(NetworkStatistics, ResetWifiTotalRxBytes_p)
 123 {
 124         error_e ret = ERROR_NONE;
 125         NetStat mgr;
 126
 127         ret = mgr.ResetWifiTotalRxBytes();
 128         EXPECT_EQ(ERROR_NONE, ret);
 129 }
 130
 131 TEST(NetworkStatistics, ResetWifiLastTxBytes_p)
 132 {
 133         error_e ret = ERROR_NONE;
 134         NetStat mgr;
 135
 136         ret = mgr.ResetWifiLastTxBytes();
 137         EXPECT_EQ(ERROR_NONE, ret);
 138 }
 139
 140 TEST(NetworkStatistics, ResetWifiLastRxBytes_p)
 141 {
 142         error_e ret = ERROR_NONE;
 143         NetStat mgr;
 144
 145         ret = mgr.ResetWifiLastRxBytes();
 146         EXPECT_EQ(ERROR_NONE, ret);
 147 }
 148
 149 TEST(NetworkState, AddRoute_p)
 150 {
 151         error_e ret = ERROR_NONE;
 152         NetworkState mgr;
 153         const char *ip = "192.168.11.55";
 154         const char *mask = "255.255.255.0";
 155         const char *interface = "lo";
 156         const char *gateway = "192.168.11.1";
 157         bool result;
 158
 159         ret = mgr.AddRoute(ip, mask, interface, gateway,
 160                         AF_INET, &result);
 161         EXPECT_EQ(ERROR_NONE, ret);
 162         EXPECT_EQ(true, result);
 163 }
 164
 165 TEST(NetworkState, RemoveRoute_p)
 166 {
 167         error_e ret = ERROR_NONE;
 168         NetworkState mgr;
 169         const char *ip = "192.168.11.55";
 170         const char *mask = "255.255.255.0";
 171         const char *interface = "lo";
 172         const char *gateway = "192.168.11.1";
 173         bool result;
 174
 175         ret = mgr.RemoveRoute(ip, mask, interface, gateway,
 176                         AF_INET, &result);
 177
 178         EXPECT_EQ(ERROR_NONE, ret);
 179         EXPECT_EQ(true, result);
 180 }
 181
 182 TEST(NetworkState, RemoveRoute_n)
 183 {
 184         error_e ret = ERROR_NONE;
 185         NetworkState mgr;
 186         bool result;
 187
 188         ret = mgr.RemoveRoute(NULL, NULL, NULL, NULL,
 189                         -1, &result);
 190
 191         EXPECT_NE(ERROR_NONE, ret);
 192 }
 193
 194 TEST(NetworkState, LaunchMdns_p)
 195 {
 196         error_e ret = ERROR_NONE;
 197         NetworkState mgr;
 198         const char *name = "gtest";
 199
 200         ret = mgr.LaunchMdns(name);
 201         EXPECT_EQ(ERROR_NONE, ret);
 202 }
 203
 204 TEST(NetworkState, LaunchMdns_n)
 205 {
 206         error_e ret = ERROR_NONE;
 207         NetworkState mgr;
 208         const char *name = "gtest";
 209
 210         ret = mgr.LaunchMdns(name);
 211         EXPECT_EQ(ERROR_NONE, ret);
 212 }
 213
 214 TEST(NetworkState, DevicePolicySetWifi_p1)
 215 {
 216         error_e ret = ERROR_NONE;
 217         NetworkState mgr;
 218         int state = 0;
 219
 220         ret = mgr.DevicePolicySetWifi(state);
 221         EXPECT_EQ(ERROR_NONE, ret);
 222         ret = mgr.DevicePolicyGetWifi(&state);
 223         EXPECT_EQ(ERROR_NONE, ret);
 224         EXPECT_EQ(state, 0);
 225 }
 226
 227 TEST(NetworkState, DevicePolicySetWifi_p2)
 228 {
 229         error_e ret = ERROR_NONE;
 230         NetworkState mgr;
 231         int state = 1;
 232
 233         ret = mgr.DevicePolicySetWifi(state);
 234         EXPECT_EQ(ERROR_NONE, ret);
 235         ret = mgr.DevicePolicyGetWifi(&state);
 236         EXPECT_EQ(ERROR_NONE, ret);
 237         EXPECT_EQ(state, 1);
 238 }
 239
 240 TEST(NetworkState, DevicePolicyGetWifi_p)
 241 {
 242         error_e ret = ERROR_NONE;
 243         NetworkState mgr;
 244         int state;
 245
 246         ret = mgr.DevicePolicyGetWifi(&state);
 247         EXPECT_EQ(ERROR_NONE, ret);
 248 }
 249
 250 TEST(NetworkState, DevicePolicyGetWifi_n)
 251 {
 252         error_e ret = ERROR_NONE;
 253         NetworkState mgr;
 254
 255         ret = mgr.DevicePolicyGetWifi(NULL);
 256         EXPECT_EQ(ERROR_NONE, ret);
 257 }
 258
 259 TEST(NetworkState, DevicePolicySetWifiProfile_p1)
 260 {
 261         error_e ret = ERROR_NONE;
 262         NetworkState mgr;
 263         int state = 0;
 264
 265         ret = mgr.DevicePolicySetWifiProfile(state);
 266         EXPECT_EQ(ERROR_NONE, ret);
 267         ret = mgr.DevicePolicyGetWifiProfile(&state);
 268         EXPECT_EQ(ERROR_NONE, ret);
 269         EXPECT_EQ(state, 0);
 270 }
 271
 272 TEST(NetworkState, DevicePolicySetWifiProfile_p2)
 273 {
 274         error_e ret = ERROR_NONE;
 275         NetworkState mgr;
 276         int state = 1;
 277
 278         ret = mgr.DevicePolicySetWifiProfile(state);
 279         EXPECT_EQ(ERROR_NONE, ret);
 280         ret = mgr.DevicePolicyGetWifiProfile(&state);
 281         EXPECT_EQ(ERROR_NONE, ret);
 282         EXPECT_EQ(state, 1);
 283 }
 284
 285 TEST(NetworkState, DevicePolicySetWifiProfile_n)
 286 {
 287         error_e ret = ERROR_NONE;
 288         NetworkState mgr;
 289         int state = -1;
 290
 291         ret = mgr.DevicePolicySetWifiProfile(state);
 292         EXPECT_EQ(ERROR_NONE, ret);
 293 }
 294
 295 TEST(NetworkState, DevicePolicyGetWifiProfile_p)
 296 {
 297         error_e ret = ERROR_NONE;
 298         NetworkState mgr;
 299         int state;
 300
 301         ret = mgr.DevicePolicyGetWifiProfile(&state);
 302         EXPECT_EQ(ERROR_NONE, ret);
 303 }
 304
 305 TEST(NetworkState, GetMeteredInfo_p)
 306 {
 307         error_e ret = ERROR_NONE;
 308         NetworkState mgr;
 309         bool state;
 310
 311         ret = mgr.GetMeteredInfo(&state);
 312         EXPECT_EQ(ERROR_NONE, ret);
 313 }
 314
 315 TEST(NetworkState, GetMeteredInfo_n)
 316 {
 317         error_e ret = ERROR_NONE;
 318         NetworkState mgr;
 319         bool state;
 320
 321         ret = mgr.GetMeteredInfo(&state);
 322         EXPECT_EQ(ERROR_NONE, ret);
 323 }
 324
 325 TEST(NetworkState, GetTCPDumpState_p)
 326 {
 327         error_e ret = ERROR_NONE;
 328         NetworkState mgr;
 329         bool state;
 330
 331         ret = mgr.GetTCPDumpState(&state);
 332         EXPECT_EQ(ERROR_NONE, ret);
 333 }
 334
 335 TEST(NetworkState, GetTCPDumpState_n)
 336 {
 337         error_e ret = ERROR_NONE;
 338         NetworkState mgr;
 339
 340         ret = mgr.GetTCPDumpState(NULL);
 341         EXPECT_EQ(ERROR_NONE, ret);
 342 }
 343
 344 TEST(NetworkState, StartTCPDump_p)
 345 {
 346         error_e ret = ERROR_NONE;
 347         NetworkState mgr;
 348         bool state;
 349
 350         ret = mgr.StartTCPDump();
 351         EXPECT_EQ(ERROR_NONE, ret);
 352
 353         sleep(1);
 354         ret = mgr.GetTCPDumpState(&state);
 355         EXPECT_EQ(ERROR_NONE, ret);
 356         EXPECT_EQ(state, true);
 357 }
 358
 359 TEST(NetworkState, StartTCPDump_n)
 360 {
 361         error_e ret = ERROR_NONE;
 362         NetworkState mgr;
 363         Wifi wifi_mgr;
 364         bool state;
 365
 366         ret = mgr.StartTCPDump();
 367         EXPECT_EQ(ERROR_NONE, ret);
 368
 369         sleep(1);
 370         ret = mgr.GetTCPDumpState(&state);
 371         EXPECT_EQ(ERROR_NONE, ret);
 372         EXPECT_NE(state, false);
 373
 374         wifi_mgr.LoadDriver(false);
 375 }
 376
 377 TEST(NetworkState, StopTCPDump_p)
 378 {
 379         error_e ret = ERROR_NONE;
 380         NetworkState mgr;
 381         bool state;
 382
 383         ret = mgr.StopTCPDump();
 384         EXPECT_EQ(ERROR_NONE, ret);
 385
 386         sleep(1);
 387         ret = mgr.GetTCPDumpState(&state);
 388         EXPECT_EQ(ERROR_NONE, ret);
 389         EXPECT_EQ(state, false);
 390 }
 391
 392 TEST(NetworkState, StopTCPDump_n)
 393 {
 394         error_e ret = ERROR_NONE;
 395         NetworkState mgr;
 396         bool state;
 397
 398         ret = mgr.StopTCPDump();
 399         EXPECT_EQ(ERROR_NONE, ret);
 400
 401         sleep(1);
 402         ret = mgr.GetTCPDumpState(&state);
 403         EXPECT_EQ(ERROR_NONE, ret);
 404         EXPECT_NE(state, true);
 405 }
 406 TEST(NetworkState, PreferredIpv6Address_n)
 407 {
 408         error_e ret = ERROR_NONE;
 409         NetworkState mgr;
 410         const char *profile = "gtest";
 411         char address[256];
 412
 413         ret = mgr.PreferredIpv6Address(profile, address);
 414         EXPECT_NE(ERROR_NONE, ret);
 415 }
 416
 417 TEST(VpnTest, vpn_init_p)
 418 {
 419         error_e ret = ERROR_NONE;
 420         Vpnsvc mgr;
 421         const char *iface_name = "tun0";
 422         int iface_name_len = 4;
 423         int result;
 424         int h_index;
 425         char h_name[256];
 426
 427         ret = mgr.vpn_init(iface_name, iface_name_len, &result, &h_index, h_name);
 428         EXPECT_EQ(ERROR_NONE, ret);
 429         EXPECT_EQ(result, VPNSVC_ERROR_NONE);
 430 }
 431
 432 TEST(VpnTest, vpn_init_n)
 433 {
 434         error_e ret = ERROR_NONE;
 435         Vpnsvc mgr;
 436         const char *iface_name = "gtest";
 437         int iface_name_len = 5;
 438         int result;
 439         int h_index;
 440         char h_name[256];
 441
 442         ret = mgr.vpn_init(iface_name, iface_name_len, &result, &h_index, h_name);
 443         EXPECT_EQ(ERROR_NONE, ret);
 444         EXPECT_EQ(result, false);
 445 }
 446
 447 TEST(VpnTest, vpn_deinit_p)
 448 {
 449         error_e ret = ERROR_NONE;
 450         Vpnsvc mgr;
 451         const char *dev_name = "tun0";
 452         int result;
 453
 454         ret = mgr.vpn_deinit(dev_name, &result);
 455         EXPECT_EQ(ERROR_NONE, ret);
 456 }
 457
 458 TEST(VpnTest, vpn_deinit_n)
 459 {
 460         error_e ret = ERROR_NONE;
 461         Vpnsvc mgr;
 462         const char *dev_name = "gtest";
 463         int result;
 464
 465         ret = mgr.vpn_deinit(dev_name, &result);
 466         EXPECT_EQ(ERROR_NONE, ret);
 467         EXPECT_EQ(result, false);
 468 }
 469
 470 TEST(VpnTest, vpn_protect_p)
 471 {
 472         error_e ret = ERROR_NONE;
 473         Vpnsvc mgr;
 474         const char *iface_name = "tun0";
 475         int iface_name_len = 5;
 476         int result;
 477         int h_index;
 478         char h_name[256];
 479
 480         ret = mgr.vpn_init(iface_name, iface_name_len, &result, &h_index, h_name);
 481         EXPECT_EQ(ERROR_NONE, ret);
 482         EXPECT_EQ(result, VPNSVC_ERROR_NONE);
 483
 484         const char *dev_name = "tun0";
 485
 486         ret = mgr.vpn_protect(dev_name, &result);
 487         EXPECT_EQ(ERROR_NONE, ret);
 488 }
 489
 490 TEST(VpnTest, vpn_protect_n)
 491 {
 492         error_e ret = ERROR_NONE;
 493         Vpnsvc mgr;
 494         const char *dev_name = "gtest";
 495         int result;
 496
 497         ret = mgr.vpn_deinit(dev_name, &result);
 498         EXPECT_EQ(ERROR_NONE, ret);
 499         EXPECT_NE(VPNSVC_ERROR_NONE, result);
 500 }
 501
 502 TEST(VpnTest, vpn_up_p)
 503 {
 504         error_e ret = ERROR_NONE;
 505         Vpnsvc mgr;
 506         const char *iface_name = "wlan0";
 507         int result;
 508
 509         ret = mgr.vpn_up(iface_name, &result);
 510         EXPECT_EQ(ERROR_NONE, ret);
 511 }
 512
 513 TEST(VpnTest, vpn_up_n)
 514 {
 515         error_e ret = ERROR_NONE;
 516         Vpnsvc mgr;
 517         const char *iface_name = "wlan0";
 518         int result;
 519
 520         ret = mgr.vpn_up(iface_name, &result);
 521         EXPECT_EQ(ERROR_NONE, ret);
 522         EXPECT_NE(VPNSVC_ERROR_NONE, result);
 523 }
 524
 525 TEST(VpnTest, vpn_down_p)
 526 {
 527         error_e ret = ERROR_NONE;
 528         Vpnsvc mgr;
 529         const char *iface_name = "wlan0";
 530         int result;
 531
 532         ret = mgr.vpn_up(iface_name, &result);
 533         EXPECT_EQ(ERROR_NONE, ret);
 534 }
 535
 536 TEST(VpnTest, vpn_down_n)
 537 {
 538         error_e ret = ERROR_NONE;
 539         Vpnsvc mgr;
 540         const char *iface_name = "wlan0";
 541         int result;
 542
 543         ret = mgr.vpn_up(iface_name, &result);
 544         EXPECT_EQ(ERROR_NONE, ret);
 545         EXPECT_NE(VPNSVC_ERROR_NONE, result);
 546 }
 547
 548 TEST(VpnTest, vpn_block_networks_p)
 549 {
 550         error_e ret = ERROR_NONE;
 551         Vpnsvc mgr;
 552         int result;
 553         GVariantBuilder nets_builder;
 554         GVariant *nets_param_vpn;
 555         GVariant *nets_param_orig;
 556
 557         g_variant_builder_init(&nets_builder, G_VARIANT_TYPE("a{si}"));
 558         g_variant_builder_add(&nets_builder, "{si}", "1.1.1.1", 24);
 559         nets_param_vpn = g_variant_builder_end(&nets_builder);
 560
 561         g_variant_builder_init(&nets_builder, G_VARIANT_TYPE("a{si}"));
 562         g_variant_builder_add(&nets_builder, "{si}", "2.2.2.2", 24);
 563         nets_param_orig = g_variant_builder_end(&nets_builder);
 564
 565         ret = mgr.vpn_block_networks(nets_param_vpn, 1, nets_param_orig, 1, &result);
 566         EXPECT_EQ(ERROR_NONE, ret);
 567 }
 568
 569 TEST(VpnTest, vpn_unblock_networks_p)
 570 {
 571         error_e ret = ERROR_NONE;
 572         Vpnsvc mgr;
 573         int result;
 574
 575         ret = mgr.vpn_unblock_networks(&result);
 576         EXPECT_EQ(ERROR_NONE, ret);
 577 }
 578
 579 TEST(VpnTest, vpn_update_settings_p)
 580 {
 581         error_e ret = ERROR_NONE;
 582         Vpnsvc mgr;
 583         int iface_index = 1;
 584         const char *local_ip = "192.168.0.2";
 585         const char *remote_ip  = "192.168.0.3";
 586         int mtu = 10;
 587         int result;
 588
 589         ret = mgr.vpn_update_settings(iface_index, local_ip,
 590                         remote_ip, mtu, &result);
 591         EXPECT_EQ(ERROR_NONE, ret);
 592 }
 593
 594 TEST(VpnTest, vpn_update_settings_n)
 595 {
 596         error_e ret = ERROR_NONE;
 597         Vpnsvc mgr;
 598         int result;
 599
 600         ret = mgr.vpn_update_settings(0, NULL, NULL, 0, &result);
 601         EXPECT_EQ(ERROR_NONE, ret);
 602         EXPECT_NE(VPNSVC_ERROR_NONE, result);
 603 }
 604
 605 TEST(VpnTest, vpn_add_route_p)
 606 {
 607         error_e ret = ERROR_NONE;
 608         Vpnsvc mgr;
 609         const char *iface_name = "wlan0";
 610         const char *route = "gtest";
 611         int prefix = 24;
 612         int result;
 613
 614         ret = mgr.vpn_add_route(iface_name, route, prefix, &result);
 615         EXPECT_EQ(ERROR_NONE, ret);
 616 }
 617
 618 TEST(VpnTest, vpn_add_route_n)
 619 {
 620         error_e ret = ERROR_NONE;
 621         Vpnsvc mgr;
 622         const char *iface_name = "wlan0";
 623         const char *route = "gtest";
 624         int prefix = 24;
 625         int result;
 626
 627         ret = mgr.vpn_add_route(iface_name, route, prefix, &result);
 628         EXPECT_EQ(ERROR_NONE, ret);
 629         EXPECT_NE(VPNSVC_ERROR_NONE, result);
 630 }
 631
 632 TEST(VpnTest, vpn_remove_route_p)
 633 {
 634         error_e ret = ERROR_NONE;
 635         Vpnsvc mgr;
 636         const char *iface_name = "wlan0";
 637         const char *route = "gtest";
 638         int prefix = 24;
 639         int result;
 640
 641         ret = mgr.vpn_add_route(iface_name, route, prefix, &result);
 642         EXPECT_EQ(ERROR_NONE, ret);
 643 }
 644
 645 TEST(VpnTest, vpn_remove_route_n)
 646 {
 647         error_e ret = ERROR_NONE;
 648         Vpnsvc mgr;
 649         const char *iface_name = "wlan0";
 650         const char *route = "gtest";
 651         int prefix = 24;
 652         int result;
 653
 654         ret = mgr.vpn_add_route(iface_name, route, prefix, &result);
 655         EXPECT_EQ(ERROR_NONE, ret);
 656         EXPECT_NE(VPNSVC_ERROR_NONE, result);
 657 }
 658
 659 TEST(VpnTest, vpn_add_dns_server_p)
 660 {
 661         error_e ret = ERROR_NONE;
 662         Vpnsvc mgr;
 663         const char *iface_name = "wlan0";
 664         const char *dns_server = "1.1.1.1";
 665         int result;
 666
 667         ret = mgr.vpn_add_dns_server(iface_name, dns_server, &result);
 668         EXPECT_EQ(ERROR_NONE, ret);
 669 }
 670
 671 TEST(VpnTest, vpn_add_dns_server_n)
 672 {
 673         error_e ret = ERROR_NONE;
 674         Vpnsvc mgr;
 675         const char *iface_name = "wlan0";
 676         const char *dns_server = "1.1.1.1";
 677         int result;
 678
 679         ret = mgr.vpn_add_dns_server(iface_name, dns_server, &result);
 680         EXPECT_EQ(ERROR_NONE, ret);
 681         EXPECT_NE(VPNSVC_ERROR_NONE, result);
 682 }
 683
 684 TEST(WifiTest, GetWifiState_p)
 685 {
 686         error_e ret = ERROR_NONE;
 687         Wifi mgr;
 688         char state[256];
 689
 690         ret = mgr.GetWifiState(state);
 691         EXPECT_EQ(ERROR_NONE, ret);
 692
 693 }
 694
 695 TEST(WifiTest, IsIpConflictDetectEnabled_p)
 696 {
 697         error_e ret = ERROR_NONE;
 698         Wifi mgr;
 699         bool state;
 700
 701         ret = mgr.IsIpConflictDetectEnabled(&state);
 702         EXPECT_EQ(ERROR_NONE, ret);
 703
 704 }
 705
 706 TEST(WifiTest, SetBgscan_p)
 707 {
 708         error_e ret = ERROR_NONE;
 709         Wifi mgr;
 710         int scan_mode = 1;
 711
 712         ret = mgr.SetBgscan(scan_mode);
 713         EXPECT_EQ(ERROR_NONE, ret);
 714
 715 }
 716
 717 TEST(WifiTest, GetAutoscan_p)
 718 {
 719         error_e ret = ERROR_NONE;
 720         Wifi mgr;
 721         bool state;
 722
 723         ret = mgr.GetAutoscan(&state);
 724         EXPECT_EQ(ERROR_NONE, ret);
 725
 726 }
 727
 728 TEST(WifiTest, GetIpConflictState_p)
 729 {
 730         error_e ret = ERROR_NONE;
 731         Wifi mgr;
 732         int state;
 733
 734         ret = mgr.GetIpConflictState(&state);
 735         EXPECT_EQ(ERROR_NONE, ret);
 736
 737 }
 738
 739 TEST(WifiTest, GetIpConflictPeriod_p)
 740 {
 741         error_e ret = ERROR_NONE;
 742         Wifi mgr;
 743         int period;
 744
 745         ret = mgr.GetIpConflictPeriod(&period);
 746         EXPECT_EQ(ERROR_NONE, ret);
 747
 748 }
 749
 750 TEST(WifiTest, GetAutoscanmode_p)
 751 {
 752         error_e ret = ERROR_NONE;
 753         Wifi mgr;
 754         int autoscanmode;
 755
 756         ret = mgr.GetAutoscanmode(&autoscanmode);
 757         EXPECT_EQ(ERROR_NONE, ret);
 758
 759 }
 760
 761 TEST(WifiTest, NetlinkScan_p)
 762 {
 763         error_e ret = ERROR_NONE;
 764         Wifi mgr;
 765         const char *ssid = "gtest";
 766
 767         ret = mgr.NetlinkScan(ssid);
 768         EXPECT_EQ(ERROR_NONE, ret);
 769
 770 }
 771
 772 TEST(WifiTest, RequestWpsConnect_p)
 773 {
 774         error_e ret = ERROR_NONE;
 775         Wifi mgr;
 776         const char *param = "PBC";
 777
 778         ret = mgr.RequestWpsConnect(param);
 779         EXPECT_EQ(ERROR_NONE, ret);
 780
 781 }
 782
 783 TEST(WifiTest, GetPasspoint_p)
 784 {
 785         error_e ret = ERROR_NONE;
 786         Wifi mgr;
 787         int enable;
 788
 789         ret = mgr.GetPasspoint(&enable);
 790         EXPECT_EQ(ERROR_NONE, ret);
 791
 792 }
 793
 794 TEST(WifiTest, SetPasspoint_p)
 795 {
 796         error_e ret = ERROR_NONE;
 797         Wifi mgr;
 798         int enable = 0;
 799
 800         ret = mgr.SetPasspoint(enable);
 801         EXPECT_EQ(ERROR_NONE, ret);
 802
 803 }
 804
 805 TEST(WifiTest, GetConfigIds_p)
 806 {
 807         error_e ret = ERROR_NONE;
 808         Wifi mgr;
 809
 810         ret = mgr.GetConfigIds();
 811         EXPECT_EQ(ERROR_NONE, ret);
 812
 813 }
 814
 815 TEST(WifiTest, SaveConfiguration_p)
 816 {
 817         error_e ret = ERROR_NONE;
 818         Wifi mgr;
 819         const char *config_id = "gtest";
 820         const char *name = "gtest";
 821         const char *ssid = "gtest";
 822
 823         ret = mgr.SaveConfiguration(config_id, name, ssid, NULL);
 824         EXPECT_EQ(ERROR_NONE, ret);
 825 }
 826
 827 TEST(WifiTest, SaveEapConfiguration_p)
 828 {
 829         error_e ret = ERROR_NONE;
 830         Wifi mgr;
 831         const char *config_id = "gtest";
 832         const char *name = "gtest";
 833         const char *ssid = "gtest";
 834
 835         ret = mgr.SaveEapConfiguration(config_id, name, ssid);
 836         EXPECT_EQ(ERROR_NONE, ret);
 837
 838 }
 839
 840 TEST(WifiTest, SetIpConflictPeriod_p)
 841 {
 842         error_e ret = ERROR_NONE;
 843         Wifi mgr;
 844         unsigned int period = 25000;
 845
 846         ret = mgr.SetIpConflictPeriod(period);
 847         EXPECT_EQ(ERROR_NONE, ret);
 848
 849 }
 850
 851 TEST(WifiTest, SetIpConflictPeriod_n)
 852 {
 853         error_e ret = ERROR_NONE;
 854         Wifi mgr;
 855         unsigned int period = 10;
 856
 857         ret = mgr.SetIpConflictPeriod(period);
 858         EXPECT_NE(ERROR_NONE, ret);
 859
 860 }
 861
 862 TEST(WifiTest, LoadConfiguration_p)
 863 {
 864         error_e ret = ERROR_NONE;
 865         Wifi mgr;
 866         const char *config_id = "gtest_managed_none";
 867         const char *name = "gtest";
 868         const char *ssid = "gtest";
 869
 870         ret = mgr.SaveConfiguration(config_id, name, ssid, NULL);
 871         EXPECT_EQ(ERROR_NONE, ret);
 872
 873         sleep(2);
 874
 875         ret = mgr.LoadConfiguration(config_id);
 876         EXPECT_EQ(ERROR_NONE, ret);
 877
 878 }
 879
 880 TEST(WifiTest, LoadConfiguration_n)
 881 {
 882         error_e ret = ERROR_NONE;
 883         Wifi mgr;
 884         const char *config_id = "\0";
 885
 886         ret = mgr.LoadConfiguration(config_id);
 887         EXPECT_NE(ERROR_NONE, ret);
 888 }
 889
 890 TEST(WifiTest, LoadEapConfiguration_p)
 891 {
 892         error_e ret = ERROR_NONE;
 893         Wifi mgr;
 894         const char *config_id = "gtest_managed_ieee8021x";
 895         const char *name = "gtest";
 896         const char *ssid = "gtest";
 897
 898         ret = mgr.SaveEapConfiguration(config_id, name, ssid);
 899         EXPECT_EQ(ERROR_NONE, ret);
 900
 901         sleep(2);
 902
 903         ret = mgr.LoadEapConfiguration(config_id);
 904         EXPECT_EQ(ERROR_NONE, ret);
 905
 906 }
 907
 908 TEST(WifiTest, LoadEapConfiguration_n)
 909 {
 910         error_e ret = ERROR_NONE;
 911         Wifi mgr;
 912         const char *config_id = "\0";
 913
 914         ret = mgr.LoadEapConfiguration(config_id);
 915         EXPECT_NE(ERROR_NONE, ret);
 916
 917 }
 918
 919 TEST(WifiTest, RemoveConfiguration_p)
 920 {
 921         error_e ret = ERROR_NONE;
 922         Wifi mgr;
 923         const char *config_id = "gtest";
 924
 925         ret = mgr.RemoveConfiguration(config_id);
 926         EXPECT_EQ(ERROR_NONE, ret);
 927
 928 }
 929
 930 TEST(WifiTest, RemoveConfiguration_n)
 931 {
 932         error_e ret = ERROR_NONE;
 933         Wifi mgr;
 934         const char *config_id = "\0";
 935
 936         ret = mgr.RemoveConfiguration(config_id);
 937         EXPECT_NE(ERROR_NONE, ret);
 938
 939 }
 940
 941 TEST(WifiTest, SetConfigField_p)
 942 {
 943         error_e ret = ERROR_NONE;
 944         Wifi mgr;
 945         const char *config_id = "gtest";
 946         const char *key = "Identity";
 947         const char *value = "gtest";
 948
 949         ret = mgr.SetConfigField(config_id, key, value);
 950         EXPECT_EQ(ERROR_NONE, ret);
 951
 952 }
 953
 954 TEST(WifiTest, SetConfigField_n)
 955 {
 956         error_e ret = ERROR_NONE;
 957         Wifi mgr;
 958         const char *config_id = "\0";
 959         const char *key = "\0";
 960         const char *value = "\0";
 961
 962         ret = mgr.SetConfigField(config_id, key, value);
 963         EXPECT_NE(ERROR_NONE, ret);
 964
 965 }
 966
 967 TEST(WifiTest, GetConfigPassphrase_p)
 968 {
 969         error_e ret = ERROR_NONE;
 970         Wifi mgr;
 971
 972         const char *config_id = "gtest";
 973         const char *name = "gtest";
 974         const char *ssid = "gtest";
 975         const char *passphrase = "gtest";
 976
 977         ret = mgr.SaveConfiguration(config_id, name, ssid, passphrase);
 978         EXPECT_EQ(ERROR_NONE, ret);
 979
 980         char password[256];
 981
 982         ret = mgr.GetConfigPassphrase(config_id, password);
 983         EXPECT_EQ(ERROR_NONE, ret);
 984 }
 985
 986 TEST(WifiTest, GetConfigPassphrase_n)
 987 {
 988         error_e ret = ERROR_NONE;
 989         Wifi mgr;
 990         const char *config_id = "\0";
 991         char password[256];
 992
 993         ret = mgr.GetConfigPassphrase(config_id, password);
 994         EXPECT_NE(ERROR_NONE, ret);
 995
 996 }
 997
 998 TEST(WifiTest, CreateEapConfig_p)
 999 {
1000         error_e ret = ERROR_NONE;
1001         Wifi mgr;
1002         const char *profile_name =
1003                 "/net/connman/service/wifi_e45d7553fd5b_gtest_managed_ieee8021x";
1004
1005         ret = mgr.CreateEapConfig(profile_name);
1006         EXPECT_EQ(ERROR_NONE, ret);
1007
1008 }
1009
1010 TEST(WifiTest, CreateEapConfig_n)
1011 {
1012         error_e ret = ERROR_NONE;
1013         Wifi mgr;
1014         const char *profile_name = "/gtest";
1015
1016         ret = mgr.CreateEapConfig(profile_name);
1017         EXPECT_NE(ERROR_NONE, ret);
1018 }
1019
1020 TEST(WifiTest, DeleteEapConfig_p)
1021 {
1022         error_e ret = ERROR_NONE;
1023         Wifi mgr;
1024         const char *profile_name =
1025                 "/net/connman/service/wifi_e45d7553fd5b_gtest_managed_ieee8021x";
1026
1027         ret = mgr.CreateEapConfig(profile_name);
1028         EXPECT_EQ(ERROR_NONE, ret);
1029
1030         ret = mgr.DeleteEapConfig(profile_name);
1031         EXPECT_EQ(ERROR_NONE, ret);
1032 }
1033
1034 TEST(WifiTest, IpConflictSetEnable_p)
1035 {
1036         error_e ret = ERROR_NONE;
1037         Wifi mgr;
1038         bool state;
1039
1040         ret = mgr.IsIpConflictDetectEnabled(&state);
1041         EXPECT_EQ(ERROR_NONE, ret);
1042
1043         ret = mgr.IpConflictSetEnable(!state);
1044         EXPECT_EQ(ERROR_NONE, ret);
1045 }
1046
1047 TEST(WifiTest, ReqSimAuth_p)
1048 {
1049         error_e ret = ERROR_NONE;
1050         Wifi mgr;
1051         const unsigned char *rand_data =  (unsigned char *)"0123456789012345";
1052         unsigned int length = 16;
1053         bool result;
1054
1055         ret = mgr.ReqSimAuth(rand_data, length, &result);
1056         EXPECT_EQ(ERROR_NONE, ret);
1057
1058 }
1059
1060 TEST(WifiTest, ReqSimAuth_n)
1061 {
1062         error_e ret = ERROR_NONE;
1063         Wifi mgr;
1064         unsigned char rand[5] = {0, };
1065         const unsigned char *rand_data =  (unsigned char *)rand;
1066         unsigned int length = 5;
1067         bool result;
1068
1069         ret = mgr.ReqSimAuth(rand_data, length, &result);
1070         EXPECT_NE(ERROR_NONE, ret);
1071
1072 }
1073
1074 TEST(WifiTest, ReqAkaAuth_p)
1075 {
1076         error_e ret = ERROR_NONE;
1077         Wifi mgr;
1078         unsigned char rand[] = {65, 61, 62, 63, 64, 65, 66, 67,
1079                 68, 69, 70, 71, 72, 73, 74, 75};
1080         unsigned char auth[] = {65, 61, 62, 63, 64, 65, 66, 67,
1081                 68, 69, 70, 71, 72, 73, 74, 75};
1082         const unsigned char *rand_data =  (unsigned char *)rand;
1083         const unsigned char *auth_data =  (unsigned char *)auth;
1084         int length = 16;
1085         bool result;
1086
1087         ret = mgr.ReqAkaAuth(rand_data, length, auth_data, length, &result);
1088         EXPECT_EQ(ERROR_NONE, ret);
1089
1090 }
1091
1092 TEST(WifiTest, ReqAkaAuth_n)
1093 {
1094         error_e ret = ERROR_NONE;
1095         Wifi mgr;
1096         unsigned char rand[5] = {0, };
1097         unsigned char auth[5] = {0, };
1098         const unsigned char *rand_data =  (unsigned char *)rand;
1099         const unsigned char *auth_data =  (unsigned char *)auth;
1100         int length = 5;
1101         bool result;
1102
1103         ret = mgr.ReqAkaAuth(rand_data, length, auth_data, length, &result);
1104         EXPECT_NE(ERROR_NONE, ret);
1105
1106 }
1107
1108 TEST(WifiTest, CheckBlackList_p)
1109 {
1110         error_e ret = ERROR_NONE;
1111         Wifi mgr;
1112         const char *name = "gtest";
1113         const char *sec_type = "gtest";
1114         const char *eap = "gtest";
1115         bool allowed;
1116
1117         ret = mgr.CheckBlackList(name, sec_type, eap, &allowed);
1118         EXPECT_EQ(ERROR_NONE, ret);
1119
1120 }
1121
1122 TEST(WifiTest, TdlsDisconnect_p)
1123 {
1124         error_e ret = ERROR_NONE;
1125         Wifi mgr;
1126         int result;
1127         const char *peer_mac_address = "00:00:00:00:00:00";
1128
1129         ret = mgr.TdlsDisconnect(peer_mac_address, &result);
1130         EXPECT_EQ(ERROR_NONE, ret);
1131
1132 }
1133
1134 TEST(WifiTest, TdlsConnectedPeer_p)
1135 {
1136         error_e ret = ERROR_NONE;
1137         Wifi mgr;
1138         char peer_mac_address[256];
1139
1140         ret = mgr.TdlsConnectedPeer(peer_mac_address);
1141         EXPECT_EQ(ERROR_NONE, ret);
1142
1143 }
1144
1145 TEST(WifiTest, TdlsDiscover_n)
1146 {
1147         error_e ret = ERROR_NONE;
1148         Wifi mgr;
1149         int result;
1150         const char *peer_mac_address = "\0";
1151
1152         ret = mgr.TdlsDiscover(peer_mac_address, &result);
1153         EXPECT_NE(ERROR_NONE, ret);
1154
1155 }
1156
1157 TEST(WifiTest, TdlsChannelSwitch_p)
1158 {
1159         error_e ret = ERROR_NONE;
1160         Wifi mgr;
1161         int result;
1162         const char *peer_mac_address = "00:00:00:00:00:00";
1163         int freq = 2600;
1164
1165         ret = mgr.TdlsChannelSwitch(peer_mac_address, freq, &result);
1166         EXPECT_EQ(ERROR_NONE, ret);
1167         EXPECT_NE(result, 0);
1168 }
1169
1170 TEST(WifiTest, TdlsChannelSwitch_n)
1171 {
1172         error_e ret = ERROR_NONE;
1173         Wifi mgr;
1174         int result;
1175         const char *peer_mac_address = "\0";
1176         int freq = -1;
1177
1178         ret = mgr.TdlsChannelSwitch(peer_mac_address, freq, &result);
1179         EXPECT_EQ(ERROR_NONE, ret);
1180         EXPECT_NE(result, 0);
1181 }
1182
1183 TEST(WifiTest, TdlsCancelChannelSwitch_p)
1184 {
1185         error_e ret = ERROR_NONE;
1186         Wifi mgr;
1187         int result;
1188         const char *peer_mac_address = "00:00:00:00:00:00";
1189
1190         ret = mgr.TdlsCancelChannelSwitch(peer_mac_address, &result);
1191         EXPECT_EQ(ERROR_NONE, ret);
1192 }
1193
1194 TEST(WifiTest, TdlsCancelChannelSwitch_n)
1195 {
1196         error_e ret = ERROR_NONE;
1197         Wifi mgr;
1198         int result;
1199         const char *peer_mac_address = "\0";
1200
1201         ret = mgr.TdlsCancelChannelSwitch(peer_mac_address, &result);
1202         EXPECT_EQ(ERROR_NONE, ret);
1203         EXPECT_NE(result, 0);
1204 }
1205
1206 TEST(WifiTest, AddVsie_p)
1207 {
1208         error_e ret = ERROR_NONE;
1209         Wifi mgr;
1210         int frame_id = 1;
1211         const char *vsie = "dd050016328000";
1212
1213         ret = mgr.AddVsie(frame_id, vsie);
1214         EXPECT_EQ(ERROR_NONE, ret);
1215
1216 }
1217
1218 TEST(WifiTest, AddVsie_n)
1219 {
1220         error_e ret = ERROR_NONE;
1221         Wifi mgr;
1222         int frame_id = -1;
1223         const char *vsie = "\0";
1224
1225         ret = mgr.AddVsie(frame_id, vsie);
1226         EXPECT_NE(ERROR_NONE, ret);
1227 }
1228
1229 TEST(WifiTest, GetVsie_p)
1230 {
1231         error_e ret = ERROR_NONE;
1232         Wifi mgr;
1233         int frame_id = 1;
1234         char vsie[256];
1235
1236         ret = mgr.GetVsie(frame_id, vsie);
1237         EXPECT_EQ(ERROR_NONE, ret);
1238
1239 }
1240
1241 TEST(WifiTest, GetVsie_n)
1242 {
1243         error_e ret = ERROR_NONE;
1244         Wifi mgr;
1245         int frame_id = -1;
1246         char vsie[256];
1247
1248         ret = mgr.GetVsie(frame_id, vsie);
1249         EXPECT_NE(ERROR_NONE, ret);
1250
1251 }
1252
1253 TEST(WifiTest, RemoveVsie_p)
1254 {
1255         error_e ret = ERROR_NONE;
1256         Wifi mgr;
1257         int frame_id = 1;
1258         const char *vsie = "dd050016328000";
1259
1260         ret = mgr.RemoveVsie(frame_id, vsie);
1261         EXPECT_EQ(ERROR_NONE, ret);
1262
1263 }
1264
1265 TEST(WifiTest, RemoveVsie_n)
1266 {
1267         error_e ret = ERROR_NONE;
1268         Wifi mgr;
1269         int frame_id = -1;
1270         const char *vsie = "\0";
1271
1272         ret = mgr.RemoveVsie(frame_id, vsie);
1273         EXPECT_NE(ERROR_NONE, ret);
1274
1275 }
1276
1277 TEST(WifiTest, EncryptPassphrase_p)
1278 {
1279         error_e ret = ERROR_NONE;
1280         Wifi mgr;
1281         const char *passphrase = "gtest";
1282         char *enc_data = NULL;
1283
1284         ret = mgr.EncryptPassphrase(&enc_data, passphrase);
1285         free(enc_data);
1286         EXPECT_EQ(ERROR_NONE, ret);
1287 }
1288
1289 TEST(WifiTest, EncryptPassphrase_n)
1290 {
1291         error_e ret = ERROR_NONE;
1292         Wifi mgr;
1293         const char *passphrase = "\0";
1294         char *enc_data = NULL;
1295
1296         ret = mgr.EncryptPassphrase(&enc_data, passphrase);
1297         free(enc_data);
1298         EXPECT_EQ(ERROR_NONE, ret);
1299 }
1300
1301 TEST(WifiTest, DecryptPassphrase_p)
1302 {
1303         error_e ret = ERROR_NONE;
1304         Wifi mgr;
1305
1306         const char *passphrase = "0123456789";
1307         char *enc_data = NULL;
1308         char *passphrase1 = NULL;
1309
1310         ret = mgr.EncryptPassphrase(&enc_data, passphrase);
1311         EXPECT_EQ(ERROR_NONE, ret);
1312         ret = mgr.DecryptPassphrase(enc_data, &passphrase1);
1313         std::cerr << "decrypted password = " << passphrase1;
1314         std::cerr << " " << "expected = " << passphrase << endl;
1315         EXPECT_EQ(!strcmp(passphrase1, passphrase), true);
1316
1317         free(enc_data);
1318         free(passphrase1);
1319         EXPECT_EQ(ERROR_NONE, ret);
1320 }
1321
1322 TEST(WifiTest, DecryptPassphrase_n)
1323 {
1324         error_e ret = ERROR_NONE;
1325         Wifi mgr;
1326         char *passphrase = NULL;
1327         const char enc_data[] = "\0";
1328
1329         ret = mgr.DecryptPassphrase(enc_data, &passphrase);
1330         free(passphrase);
1331         EXPECT_NE(ERROR_NONE, ret);
1332 }
1333
1334 TEST(WifiTest, Stop_n)
1335 {
1336         error_e ret = ERROR_NONE;
1337         Wifi mgr;
1338
1339         ret = mgr.RemoveDriver();
1340         EXPECT_EQ(ERROR_NONE, ret);
1341
1342         sleep(5);
1343
1344         ret = mgr.Stop("gtest");
1345         EXPECT_NE(ERROR_NONE, ret);
1346 }
1347
1348 TEST(WifiTest, Start_p)
1349 {
1350         error_e ret = ERROR_NONE;
1351         Wifi mgr;
1352
1353         ret = mgr.Start("softap");
1354         EXPECT_EQ(ERROR_NONE, ret);
1355 }
1356
1357 TEST(WifiTest, Stop_p)
1358 {
1359         error_e ret = ERROR_NONE;
1360         Wifi mgr;
1361
1362         sleep(2);
1363         ret = mgr.Stop("softap");
1364         EXPECT_EQ(ERROR_NONE, ret);
1365 }
1366
1367 TEST(WifiTest, Start_n)
1368 {
1369         error_e ret = ERROR_NONE;
1370         Wifi mgr;
1371
1372         ret = mgr.Start("gtest");
1373         EXPECT_NE(ERROR_NONE, ret);
1374 }
1375
1376 int main(int argc, char **argv)
1377 {
1378         InitGoogleTest(&argc, argv);
1379         return RUN_ALL_TESTS();
1380 }