gtest/gtest-vpn-settings-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 //LCOV_EXCL_START
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <iostream>
  22 #include <gmock/gmock.h>
  23 #include <gtest/gtest.h>
  24 #include <unistd.h>
  25
  26 #include "gtest-vpn-settings.h"
  27
  28 #ifdef TIZEN_TEST_GCOV
  29 extern "C" void __gcov_flush(void);
  30 #endif
  31
  32 using ::testing::InitGoogleTest;
  33 using ::testing::Test;
  34 using ::testing::TestCase;
  35
  36 TEST(VpnSetting, vpnInitialize_p)
  37 {
  38         int ret;
  39         VpnSetting vpn;
  40
  41         ret = vpn.vpnInitialize_p();
  42         EXPECT_EQ(VPN_ERROR_NONE, ret);
  43 }
  44
  45 TEST(VpnSetting, vpnInitialize_n)
  46 {
  47         int ret;
  48         VpnSetting vpn;
  49
  50         ret = vpn.vpnInitialize_n();
  51         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
  52 }
  53
  54 TEST(VpnSetting, vpnDeinitialize_p)
  55 {
  56         int ret;
  57         VpnSetting vpn;
  58
  59         ret = vpn.vpnDeinitialize_p();
  60         EXPECT_EQ(VPN_ERROR_NONE, ret);
  61 }
  62
  63 TEST(VpnSetting, vpnDeinitialize_n)
  64 {
  65         int ret;
  66         VpnSetting vpn;
  67
  68         ret = vpn.vpnDeinitialize_n();
  69         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
  70 }
  71
  72 TEST(VpnSetting, vpnSettingsInit_p)
  73 {
  74         int ret;
  75         VpnSetting vpn;
  76
  77         ret = vpn.vpnSettingsInit_p();
  78         EXPECT_EQ(VPN_ERROR_NONE, ret);
  79 }
  80
  81 TEST(VpnSetting, vpnSettingsInit_n)
  82 {
  83         int ret;
  84         VpnSetting vpn;
  85
  86         ret = vpn.vpnSettingsInit_n();
  87         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
  88 }
  89
  90 TEST(VpnSetting, vpnSettingsDeinit_p)
  91 {
  92         int ret;
  93         VpnSetting vpn;
  94
  95         ret = vpn.vpnSettingsDeinit_p();
  96         EXPECT_EQ(VPN_ERROR_NONE, ret);
  97 }
  98
  99 TEST(VpnSetting, vpnSettingsDeinit_n1)
 100 {
 101         int ret;
 102         VpnSetting vpn;
 103
 104         ret = vpn.vpnSettingsDeinit_n1();
 105         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 106 }
 107
 108 TEST(VpnSetting, vpnSettingsDeinit_n2)
 109 {
 110         int ret;
 111         VpnSetting vpn;
 112
 113         ret = vpn.vpnSettingsDeinit_n2();
 114         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 115 }
 116
 117 TEST(VpnSetting, vpnSettingsSetSpecific_p1)
 118 {
 119         int ret;
 120         VpnSetting vpn;
 121
 122         ret = vpn.vpnSettingsSetSpecific_p1();
 123         EXPECT_EQ(VPN_ERROR_NONE, ret);
 124 }
 125
 126 TEST(VpnSetting, vpnSettingsSetSpecific_p2)
 127 {
 128         int ret;
 129         VpnSetting vpn;
 130
 131         ret = vpn.vpnSettingsSetSpecific_p2();
 132         EXPECT_EQ(VPN_ERROR_NONE, ret);
 133 }
 134
 135 TEST(VpnSetting, vpnSettingsSetSpecific_n1)
 136 {
 137         int ret;
 138         VpnSetting vpn;
 139
 140         ret = vpn.vpnSettingsSetSpecific_n1();
 141         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 142 }
 143
 144 TEST(VpnSetting, vpnSettingsSetSpecific_n2)
 145 {
 146         int ret;
 147         VpnSetting vpn;
 148
 149         ret = vpn.vpnSettingsSetSpecific_n2();
 150         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 151 }
 152
 153 TEST(VpnSetting, vpnSettingsSetSpecific_n3)
 154 {
 155         int ret;
 156         VpnSetting vpn;
 157
 158         ret = vpn.vpnSettingsSetSpecific_n3();
 159         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 160 }
 161
 162 TEST(VpnSetting, vpnSettingsSetType_p)
 163 {
 164         int ret;
 165         VpnSetting vpn;
 166
 167         ret = vpn.vpnSettingsSetType_p();
 168         EXPECT_EQ(VPN_ERROR_NONE, ret);
 169 }
 170
 171 TEST(VpnSetting, vpnSettingsSetType_n1)
 172 {
 173         int ret;
 174         VpnSetting vpn;
 175
 176         ret = vpn.vpnSettingsSetType_n1();
 177         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 178 }
 179
 180 TEST(VpnSetting, vpnSettingsSetType_n2)
 181 {
 182         int ret;
 183         VpnSetting vpn;
 184
 185         ret = vpn.vpnSettingsSetType_n2();
 186         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 187 }
 188
 189 TEST(VpnSetting, vpnSettingsSetName_p)
 190 {
 191         int ret;
 192         VpnSetting vpn;
 193
 194         ret = vpn.vpnSettingsSetName_p();
 195         EXPECT_EQ(VPN_ERROR_NONE, ret);
 196 }
 197
 198 TEST(VpnSetting, vpnSettingsSetName_n1)
 199 {
 200         int ret;
 201         VpnSetting vpn;
 202
 203         ret = vpn.vpnSettingsSetName_n1();
 204         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 205 }
 206
 207 TEST(VpnSetting, vpnSettingsSetName_n2)
 208 {
 209         int ret;
 210         VpnSetting vpn;
 211
 212         ret = vpn.vpnSettingsSetName_n2();
 213         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 214 }
 215
 216 TEST(VpnSetting, vpnSettingsSetHost_p)
 217 {
 218         int ret;
 219         VpnSetting vpn;
 220
 221         ret = vpn.vpnSettingsSetHost_p();
 222         EXPECT_EQ(VPN_ERROR_NONE, ret);
 223 }
 224
 225 TEST(VpnSetting, vpnSettingsSetHost_n1)
 226 {
 227         int ret;
 228         VpnSetting vpn;
 229
 230         ret = vpn.vpnSettingsSetHost_n1();
 231         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 232 }
 233
 234 TEST(VpnSetting, vpnSettingsSetHost_n2)
 235 {
 236         int ret;
 237         VpnSetting vpn;
 238
 239         ret = vpn.vpnSettingsSetHost_n2();
 240         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 241 }
 242
 243 TEST(VpnSetting, vpnSettingsSetDomain_p)
 244 {
 245         int ret;
 246         VpnSetting vpn;
 247
 248         ret = vpn.vpnSettingsSetDomain_p();
 249         EXPECT_EQ(VPN_ERROR_NONE, ret);
 250 }
 251
 252 TEST(VpnSetting, vpnSettingsSetDomain_n1)
 253 {
 254         int ret;
 255         VpnSetting vpn;
 256
 257         ret = vpn.vpnSettingsSetDomain_n1();
 258         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 259 }
 260
 261 TEST(VpnSetting, vpnSettingsSetDomain_n2)
 262 {
 263         int ret;
 264         VpnSetting vpn;
 265
 266         ret = vpn.vpnSettingsSetDomain_n2();
 267         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 268 }
 269
 270 TEST(VpnSetting, DISABLED_vpnCreate_p1)
 271 {
 272         int ret;
 273         VpnSetting vpn;
 274
 275         ret = vpn.vpnCreate_p1();
 276         EXPECT_EQ(VPN_ERROR_NONE, ret);
 277 }
 278
 279 TEST(VpnSetting, DISABLED_vpnCreate_p2)
 280 {
 281         int ret;
 282         VpnSetting vpn;
 283
 284         ret = vpn.vpnCreate_p2();
 285         EXPECT_EQ(VPN_ERROR_NONE, ret);
 286 }
 287
 288 TEST(VpnSetting, vpnCreate_n1)
 289 {
 290         int ret;
 291         VpnSetting vpn;
 292
 293         ret = vpn.vpnCreate_n1();
 294         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 295 }
 296
 297 TEST(VpnSetting, vpnCreate_n2)
 298 {
 299         int ret;
 300         VpnSetting vpn;
 301
 302         ret = vpn.vpnCreate_n2();
 303         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 304 }
 305
 306 TEST(VpnSetting, DISABLED_vpnRemove_p1)
 307 {
 308         int ret;
 309         VpnSetting vpn;
 310
 311         ret = vpn.vpnRemove_p1();
 312         EXPECT_EQ(VPN_ERROR_NONE, ret);
 313 }
 314
 315 TEST(VpnSetting, DISABLED_vpnRemove_p2)
 316 {
 317         int ret;
 318         VpnSetting vpn;
 319
 320         ret = vpn.vpnRemove_p2();
 321         EXPECT_EQ(VPN_ERROR_NONE, ret);
 322 }
 323
 324 TEST(VpnSetting, vpnRemove_n1)
 325 {
 326         int ret;
 327         VpnSetting vpn;
 328
 329         ret = vpn.vpnRemove_n1();
 330         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 331 }
 332
 333 TEST(VpnSetting, vpnRemove_n2)
 334 {
 335         int ret;
 336         VpnSetting vpn;
 337
 338         ret = vpn.vpnRemove_n2();
 339         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 340 }
 341
 342 TEST(VpnSetting, vpnRemove_n3)
 343 {
 344         int ret;
 345         VpnSetting vpn;
 346
 347         ret = vpn.vpnRemove_n3();
 348         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 349 }
 350
 351 TEST(VpnSetting, DISABLED_vpnConnect_p1)
 352 {
 353         int ret;
 354         VpnSetting vpn;
 355
 356         ret = vpn.vpnConnect_p1();
 357         EXPECT_EQ(VPN_ERROR_NONE, ret);
 358 }
 359
 360 TEST(VpnSetting, DISABLED_vpnConnect_p2)
 361 {
 362         int ret;
 363         VpnSetting vpn;
 364
 365         ret = vpn.vpnConnect_p2();
 366         EXPECT_EQ(VPN_ERROR_NONE, ret);
 367 }
 368
 369 TEST(VpnSetting, vpnConnect_n1)
 370 {
 371         int ret;
 372         VpnSetting vpn;
 373
 374         ret = vpn.vpnConnect_n1();
 375         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 376 }
 377
 378 TEST(VpnSetting, vpnConnect_n2)
 379 {
 380         int ret;
 381         VpnSetting vpn;
 382
 383         ret = vpn.vpnConnect_n2();
 384         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 385 }
 386
 387 TEST(VpnSetting, vpnConnect_n3)
 388 {
 389         int ret;
 390         VpnSetting vpn;
 391
 392         ret = vpn.vpnConnect_n3();
 393         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 394 }
 395
 396 TEST(VpnSetting, DISABLED_vpnDisconnect_p1)
 397 {
 398         int ret;
 399         VpnSetting vpn;
 400
 401         ret = vpn.vpnDisconnect_p1();
 402         EXPECT_EQ(VPN_ERROR_NONE, ret);
 403 }
 404
 405 TEST(VpnSetting, DISABLED_vpnDisconnect_p2)
 406 {
 407         int ret;
 408         VpnSetting vpn;
 409
 410         ret = vpn.vpnDisconnect_p2();
 411         EXPECT_EQ(VPN_ERROR_NONE, ret);
 412 }
 413
 414 TEST(VpnSetting, vpnDisconnect_n1)
 415 {
 416         int ret;
 417         VpnSetting vpn;
 418
 419         ret = vpn.vpnDisconnect_n1();
 420         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 421 }
 422
 423 TEST(VpnSetting, vpnDisconnect_n2)
 424 {
 425         int ret;
 426         VpnSetting vpn;
 427
 428         ret = vpn.vpnDisconnect_n2();
 429         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 430 }
 431
 432 TEST(VpnSetting, vpnDisconnect_n3)
 433 {
 434         int ret;
 435         VpnSetting vpn;
 436
 437         ret = vpn.vpnDisconnect_n3();
 438         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 439 }
 440
 441 TEST(VpnSetting, DISABLED_vpnGetVpnHandle_p)
 442 {
 443         int ret;
 444         VpnSetting vpn;
 445
 446         ret = vpn.vpnGetVpnHandle_p();
 447         EXPECT_EQ(VPN_ERROR_NONE, ret);
 448 }
 449
 450 TEST(VpnSetting, vpnGetVpnHandle_n1)
 451 {
 452         int ret;
 453         VpnSetting vpn;
 454
 455         ret = vpn.vpnGetVpnHandle_n1();
 456         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 457 }
 458
 459 TEST(VpnSetting, vpnGetVpnHandle_n2)
 460 {
 461         int ret;
 462         VpnSetting vpn;
 463
 464         ret = vpn.vpnGetVpnHandle_n2();
 465         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 466 }
 467
 468 TEST(VpnSetting, vpnGetVpnHandle_n3)
 469 {
 470         int ret;
 471         VpnSetting vpn;
 472
 473         ret = vpn.vpnGetVpnHandle_n3();
 474         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 475 }
 476
 477 TEST(VpnSetting, vpnGetVpnHandle_n4)
 478 {
 479         int ret;
 480         VpnSetting vpn;
 481
 482         ret = vpn.vpnGetVpnHandle_n4();
 483         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 484 }
 485
 486 TEST(VpnSetting, vpnGetVpnHandle_n5)
 487 {
 488         int ret;
 489         VpnSetting vpn;
 490
 491         ret = vpn.vpnGetVpnHandle_n5();
 492         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 493 }
 494
 495 TEST(VpnSetting, vpnGetVpnHandle_n6)
 496 {
 497         int ret;
 498         VpnSetting vpn;
 499
 500         ret = vpn.vpnGetVpnHandle_n6();
 501         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 502 }
 503
 504 TEST(VpnSetting, DISABLED_vpnGetVpnInfoName_p)
 505 {
 506         int ret;
 507         VpnSetting vpn;
 508
 509         ret = vpn.vpnGetVpnInfoName_p();
 510         EXPECT_EQ(VPN_ERROR_NONE, ret);
 511 }
 512
 513 TEST(VpnSetting, vpnGetVpnInfoName_n1)
 514 {
 515         int ret;
 516         VpnSetting vpn;
 517
 518         ret = vpn.vpnGetVpnInfoName_n1();
 519         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 520 }
 521
 522 TEST(VpnSetting, vpnGetVpnInfoName_n2)
 523 {
 524         int ret;
 525         VpnSetting vpn;
 526
 527         ret = vpn.vpnGetVpnInfoName_n2();
 528         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 529 }
 530
 531 TEST(VpnSetting, vpnGetVpnInfoName_n3)
 532 {
 533         int ret;
 534         VpnSetting vpn;
 535
 536         ret = vpn.vpnGetVpnInfoName_n3();
 537         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 538 }
 539
 540 TEST(VpnSetting, vpnGetVpnInfoName_n4)
 541 {
 542         int ret;
 543         VpnSetting vpn;
 544
 545         ret = vpn.vpnGetVpnInfoName_n4();
 546         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 547 }
 548
 549 TEST(VpnSetting, DISABLED_vpnGetVpnInfoType_p)
 550 {
 551         int ret;
 552         VpnSetting vpn;
 553
 554         ret = vpn.vpnGetVpnInfoType_p();
 555         EXPECT_EQ(VPN_ERROR_NONE, ret);
 556 }
 557
 558 TEST(VpnSetting, vpnGetVpnInfoType_n1)
 559 {
 560         int ret;
 561         VpnSetting vpn;
 562
 563         ret = vpn.vpnGetVpnInfoType_n1();
 564         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 565 }
 566
 567 TEST(VpnSetting, vpnGetVpnInfoType_n2)
 568 {
 569         int ret;
 570         VpnSetting vpn;
 571
 572         ret = vpn.vpnGetVpnInfoType_n2();
 573         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 574 }
 575
 576 TEST(VpnSetting, vpnGetVpnInfoType_n3)
 577 {
 578         int ret;
 579         VpnSetting vpn;
 580
 581         ret = vpn.vpnGetVpnInfoType_n3();
 582         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 583 }
 584
 585 TEST(VpnSetting, vpnGetVpnInfoType_n4)
 586 {
 587         int ret;
 588         VpnSetting vpn;
 589
 590         ret = vpn.vpnGetVpnInfoType_n4();
 591         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 592 }
 593
 594 TEST(VpnSetting, DISABLED_vpnGetVpnInfoHost_p)
 595 {
 596         int ret;
 597         VpnSetting vpn;
 598
 599         ret = vpn.vpnGetVpnInfoHost_p();
 600         EXPECT_EQ(VPN_ERROR_NONE, ret);
 601 }
 602
 603 TEST(VpnSetting, vpnGetVpnInfoHost_n1)
 604 {
 605         int ret;
 606         VpnSetting vpn;
 607
 608         ret = vpn.vpnGetVpnInfoHost_n1();
 609         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 610 }
 611
 612 TEST(VpnSetting, vpnGetVpnInfoHost_n2)
 613 {
 614         int ret;
 615         VpnSetting vpn;
 616
 617         ret = vpn.vpnGetVpnInfoHost_n2();
 618         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 619 }
 620
 621 TEST(VpnSetting, vpnGetVpnInfoHost_n3)
 622 {
 623         int ret;
 624         VpnSetting vpn;
 625
 626         ret = vpn.vpnGetVpnInfoHost_n3();
 627         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 628 }
 629
 630 TEST(VpnSetting, vpnGetVpnInfoHost_n4)
 631 {
 632         int ret;
 633         VpnSetting vpn;
 634
 635         ret = vpn.vpnGetVpnInfoHost_n4();
 636         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 637 }
 638
 639 TEST(VpnSetting, DISABLED_vpnGetVpnInfoDomain_p)
 640 {
 641         int ret;
 642         VpnSetting vpn;
 643
 644         ret = vpn.vpnGetVpnInfoDomain_p();
 645         EXPECT_EQ(VPN_ERROR_NONE, ret);
 646 }
 647
 648 TEST(VpnSetting, vpnGetVpnInfoDomain_n1)
 649 {
 650         int ret;
 651         VpnSetting vpn;
 652
 653         ret = vpn.vpnGetVpnInfoDomain_n1();
 654         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 655 }
 656
 657 TEST(VpnSetting, vpnGetVpnInfoDomain_n2)
 658 {
 659         int ret;
 660         VpnSetting vpn;
 661
 662         ret = vpn.vpnGetVpnInfoDomain_n2();
 663         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 664 }
 665
 666 TEST(VpnSetting, vpnGetVpnInfoDomain_n3)
 667 {
 668         int ret;
 669         VpnSetting vpn;
 670
 671         ret = vpn.vpnGetVpnInfoDomain_n3();
 672         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 673 }
 674
 675 TEST(VpnSetting, vpnGetVpnInfoDomain_n4)
 676 {
 677         int ret;
 678         VpnSetting vpn;
 679
 680         ret = vpn.vpnGetVpnInfoDomain_n4();
 681         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 682 }
 683
 684 TEST(VpnSetting, vpnGetVpnHandleList_p)
 685 {
 686         int ret;
 687         VpnSetting vpn;
 688
 689         ret = vpn.vpnGetVpnHandleList_p();
 690         EXPECT_EQ(VPN_ERROR_NONE, ret);
 691 }
 692
 693 TEST(VpnSetting, vpnGetVpnHandleList_n)
 694 {
 695         int ret;
 696         VpnSetting vpn;
 697
 698         ret = vpn.vpnGetVpnHandleList_n();
 699         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 700 }
 701
 702 TEST(VpnSetting, DISABLED_vpnSetStateCallback_p)
 703 {
 704         int ret;
 705         VpnSetting vpn;
 706
 707         ret = vpn.vpnSetStateCallback_p();
 708         EXPECT_EQ(VPN_ERROR_NONE, ret);
 709 }
 710
 711 TEST(VpnSetting, vpnSetStateCallback_n1)
 712 {
 713         int ret;
 714         VpnSetting vpn;
 715
 716         ret = vpn.vpnSetStateCallback_n1();
 717         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 718 }
 719
 720 TEST(VpnSetting, vpnSetStateCallback_n2)
 721 {
 722         int ret;
 723         VpnSetting vpn;
 724
 725         ret = vpn.vpnSetStateCallback_n2();
 726         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 727 }
 728
 729 TEST(VpnSetting, vpnSetStateCallback_n3)
 730 {
 731         int ret;
 732         VpnSetting vpn;
 733
 734         ret = vpn.vpnSetStateCallback_n3();
 735         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 736 }
 737
 738 TEST(VpnSetting, vpnSetStateCallback_n4)
 739 {
 740         int ret;
 741         VpnSetting vpn;
 742
 743         ret = vpn.vpnSetStateCallback_n4();
 744         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 745 }
 746
 747 TEST(VpnSetting, DISABLED_vpnUnsetStateCallback_p)
 748 {
 749         int ret;
 750         VpnSetting vpn;
 751
 752         ret = vpn.vpnUnsetStateCallback_p();
 753         EXPECT_EQ(VPN_ERROR_NONE, ret);
 754 }
 755
 756 TEST(VpnSetting, vpnUnsetStateCallback_n1)
 757 {
 758         int ret;
 759         VpnSetting vpn;
 760
 761         ret = vpn.vpnUnsetStateCallback_n1();
 762         EXPECT_EQ(VPN_ERROR_INVALID_OPERATION, ret);
 763 }
 764
 765 TEST(VpnSetting, vpnUnsetStateCallback_n2)
 766 {
 767         int ret;
 768         VpnSetting vpn;
 769
 770         ret = vpn.vpnUnsetStateCallback_n2();
 771         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 772 }
 773
 774 TEST(VpnSetting, vpnUnsetStateCallback_n3)
 775 {
 776         int ret;
 777         VpnSetting vpn;
 778
 779         ret = vpn.vpnUnsetStateCallback_n3();
 780         EXPECT_EQ(VPN_ERROR_INVALID_PARAMETER, ret);
 781 }
 782
 783 int main(int argc, char **argv)
 784 {
 785         int ret = 0;
 786
 787 #ifdef TIZEN_TEST_GCOV
 788         setenv("GCOV_PREFIX", "/tmp", 1);
 789 #endif
 790
 791         InitGoogleTest(&argc, argv);
 792         ret = RUN_ALL_TESTS();
 793
 794 #ifdef TIZEN_TEST_GCOV
 795         __gcov_flush();
 796 #endif
 797
 798         return ret;
 799 }
 800
 801 //LCOV_EXCL_STOP