service/easy-setup/enrollee/unittests/ESEnrolleeTest.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2016 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include <gtest/gtest.h>
  22 #include <HippoMocks/hippomocks.h>
  23 #include <atomic>
  24 #include <functional>
  25 #include <condition_variable>
  26 #include <mutex>
  27 #include <chrono>
  28
  29 #include "ESMediatorSimulator.h"
  30 #include "easysetup.h"
  31
  32 extern "C" {
  33 #include "samsung/sc_easysetup.h"
  34 }
  35 using namespace OC;
  36
  37 namespace
  38 {
  39     std::atomic_bool g_isStartedStack(false);
  40
  41     std::chrono::milliseconds g_waitForResponse(1000);
  42
  43     std::condition_variable responseCon;
  44     std::mutex mutexForCondition;
  45
  46     ESMediatorSimulator g_mediatorSimul;
  47 }
  48
  49 class TestWithMock: public testing::Test
  50 {
  51 public:
  52     MockRepository mocks;
  53
  54 protected:
  55     virtual ~TestWithMock() noexcept(noexcept(std::declval<Test>().~Test()))
  56     {
  57     }
  58
  59     virtual void TearDown()
  60     {
  61         try
  62         {
  63             mocks.VerifyAll();
  64         }
  65         catch (...)
  66         {
  67             mocks.reset();
  68             throw;
  69         }
  70     }
  71 };
  72
  73 class EasysetupEnrolleeTest : public TestWithMock
  74 {
  75 public:
  76     EasysetupEnrolleeTest() = default;
  77     ~EasysetupEnrolleeTest() = default;
  78
  79     static void discoveredResource(std::shared_ptr<OC::OCResource>)
  80     {
  81         std::cout << __func__ << std::endl;
  82     }
  83
  84     static void onGetStatus(std::shared_ptr< GetEnrolleeStatus >)
  85     {
  86         std::cout << __func__ << std::endl;
  87     }
  88
  89     static void onGetConfiguration(std::shared_ptr< GetConfigurationStatus >)
  90     {
  91         std::cout << __func__ << std::endl;
  92     }
  93
  94     static void onGetWifiRsrc(const OCRepresentation& )
  95     {
  96         std::cout << __func__ << std::endl;
  97     }
  98
  99     static void onGetCloudRsrc(const OCRepresentation& )
 100     {
 101         std::cout << __func__ << std::endl;
 102     }
 103
 104     static void onGetDeviceConf(const OCRepresentation& )
 105     {
 106         std::cout << __func__ << std::endl;
 107     }
 108
 109     static void onPutRequest(const OCRepresentation& )
 110     {
 111         std::cout << __func__ << std::endl;
 112     }
 113
 114     static void deviceProvisioningStatusCallback(std::shared_ptr< DevicePropProvisioningStatus >)
 115     {
 116         std::cout << __func__ << std::endl;
 117     }
 118
 119     static void cloudProvisioningStatusCallback(std::shared_ptr< CloudPropProvisioningStatus >)
 120     {
 121         std::cout << __func__ << std::endl;
 122     }
 123
 124     static void WiFiConfProvCbInApp(ESWiFiConfData *)
 125     {
 126         std::cout << __func__ << std::endl;
 127     }
 128
 129     static void DevConfProvCbInApp(ESDevConfData *)
 130     {
 131         std::cout << __func__ << std::endl;
 132     }
 133
 134     static void CoapCloudConfCbInApp(ESCoapCloudConfData *)
 135     {
 136         std::cout << __func__ << std::endl;
 137     }
 138
 139     ESResult startEnrollee()
 140     {
 141         ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
 142                                                     ES_COAPCLOUDCONF_RESOURCE |
 143                                                     ES_DEVCONF_RESOURCE);
 144         ESProvisioningCallbacks callbacks;
 145         callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
 146         callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
 147         callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
 148
 149         return ESInitEnrollee(false, resourcemMask, callbacks);
 150     }
 151
 152     ESResult startEnrolleeWithInvalidRsrcMask()
 153     {
 154         ESProvisioningCallbacks callbacks;
 155         callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
 156         callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
 157         callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
 158
 159         return ESInitEnrollee(false, (ESResourceMask)0, callbacks);
 160     }
 161
 162     ESResult setDeviceProperty()
 163     {
 164         ESDeviceProperty deviceProperty = {
 165             {{WIFI_11G, WiFi_EOF}, WIFI_5G}, {"Test Device"}
 166         };
 167
 168         return ESSetDeviceProperty(&deviceProperty);
 169     }
 170
 171     ESResult setCallabckForUserDataNULL()
 172     {
 173         return ESSetCallbackForUserdata(NULL, NULL);
 174     }
 175
 176 protected:
 177
 178     void SetUp()
 179     {
 180         TestWithMock::SetUp();
 181
 182         if (g_isStartedStack == false)
 183         {
 184             if (OCInit(NULL, 0, OC_SERVER) != OC_STACK_OK)
 185             {
 186                 printf("OCStack init error!!\n");
 187                 return;
 188             }
 189
 190             g_isStartedStack = true;
 191         }
 192     }
 193
 194     void TearDown()
 195     {
 196         TestWithMock::TearDown();
 197     }
 198
 199 };
 200
 201 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeSuccess)
 202 {
 203     ESResult ret = startEnrollee();
 204     EXPECT_EQ(ret, ES_OK);
 205     ESTerminateEnrollee();
 206 }
 207
 208 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedInvalidRsrcMask)
 209 {
 210     ESResult ret = startEnrolleeWithInvalidRsrcMask();
 211     EXPECT_EQ(ret, ES_ERROR);
 212     ESTerminateEnrollee();
 213 }
 214
 215 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByWiFiCbIsNull)
 216 {
 217     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
 218                                                     ES_COAPCLOUDCONF_RESOURCE |
 219                                                     ES_DEVCONF_RESOURCE);
 220     ESProvisioningCallbacks callbacks;
 221     callbacks.WiFiConfProvCb = NULL;
 222     callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
 223     callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
 224
 225     ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
 226     EXPECT_EQ(ret, ES_ERROR);
 227     ESTerminateEnrollee();
 228 }
 229
 230 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByDevConfCbIsNull)
 231 {
 232     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
 233                                                     ES_COAPCLOUDCONF_RESOURCE |
 234                                                     ES_DEVCONF_RESOURCE);
 235     ESProvisioningCallbacks callbacks;
 236     callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
 237     callbacks.DevConfProvCb = NULL;
 238     callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
 239
 240     ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
 241     EXPECT_EQ(ret, ES_ERROR);
 242     ESTerminateEnrollee();
 243 }
 244
 245 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByCloudCbIsNull)
 246 {
 247     ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
 248                                                     ES_COAPCLOUDCONF_RESOURCE |
 249                                                     ES_DEVCONF_RESOURCE);
 250     ESProvisioningCallbacks callbacks;
 251     callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
 252     callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
 253     callbacks.CoapCloudConfProvCb = NULL;
 254
 255     ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
 256     EXPECT_EQ(ret, ES_ERROR);
 257     ESTerminateEnrollee();
 258 }
 259
 260 TEST_F(EasysetupEnrolleeTest, FindProvisioningResourceAtEnrolleeWithSuccess)
 261 {
 262     mocks.ExpectCallFunc(discoveredResource).Do(
 263         [](std::shared_ptr<OC::OCResource> resource)
 264         {
 265             try
 266             {
 267                 std::cout<<"DISCOVERED Resource:"<<std::endl;
 268                 // Get the resource host address
 269                 std::string uri = resource->uri();
 270                 std::cout << "\tURI of the resource: " << uri << std::endl;
 271             } catch (OCException &e)
 272             {
 273                 std::cout << e.reason() << std::endl;
 274             }
 275
 276         });
 277
 278     ESResult ret = startEnrollee();
 279
 280     g_mediatorSimul.discoverRemoteEnrollee(discoveredResource);
 281
 282     std::unique_lock< std::mutex > lock{ mutexForCondition };
 283     responseCon.wait_for(lock, g_waitForResponse);
 284
 285     EXPECT_EQ(ret, ES_OK);
 286
 287     ESTerminateEnrollee();
 288 }
 289
 290 TEST_F(EasysetupEnrolleeTest, SetDevicePropertyWithSuccess)
 291 {
 292     ESResult ret = startEnrollee();
 293     ret = setDeviceProperty();
 294     EXPECT_EQ(ret, ES_OK);
 295     ESTerminateEnrollee();
 296 }
 297
 298 TEST_F(EasysetupEnrolleeTest, SetProvStatusWithSuccess)
 299 {
 300     ESResult ret = startEnrollee();
 301     ret = ESSetState(ES_STATE_CONNECTED_TO_ENROLLER);
 302     EXPECT_EQ(ret, ES_OK);
 303     ESTerminateEnrollee();
 304 }
 305
 306 TEST_F(EasysetupEnrolleeTest, SetErrorCodeWithSuccess)
 307 {
 308     ESResult ret = startEnrollee();
 309     ret = ESSetErrorCode(ES_ERRCODE_PW_WRONG);
 310     EXPECT_EQ(ret, ES_OK);
 311     ESTerminateEnrollee();
 312 }
 313
 314 TEST_F(EasysetupEnrolleeTest, DevicePropertyIsWellConstructedInResponsePayload)
 315 {
 316     bool isWellConstructed = false;
 317     mocks.ExpectCallFunc(onGetConfiguration).Do(
 318         [& isWellConstructed](std::shared_ptr< GetConfigurationStatus > status)
 319         {
 320             if(status->getESResult() == ES_OK)
 321             {
 322                 EnrolleeConf conf = status->getEnrolleeConf();
 323                 if(conf.getWiFiModes().at(0) == WIFI_11G &&
 324                     conf.getWiFiFreq() == WIFI_5G &&
 325                     !strcmp(conf.getDeviceName().c_str(), "Test Device"))
 326                 {
 327                     isWellConstructed = true;
 328                 }
 329             }
 330         });
 331     ESResult ret = startEnrollee();
 332     ret = setDeviceProperty();
 333
 334     g_mediatorSimul.getConfiguration(onGetConfiguration);
 335
 336     std::unique_lock< std::mutex > lock{ mutexForCondition };
 337     responseCon.wait_for(lock, g_waitForResponse);
 338
 339     EXPECT_EQ(ret, ES_OK);
 340
 341     ESTerminateEnrollee();
 342 }
 343
 344 TEST_F(EasysetupEnrolleeTest, ProvisioningPropertiesIsWellConstructedInResponsePayload)
 345 {
 346     bool isWellConstructed = false;
 347     mocks.ExpectCallFunc(onGetStatus).Do(
 348         [& isWellConstructed](std::shared_ptr< GetEnrolleeStatus > status)
 349         {
 350             if(status->getESResult() == ES_OK)
 351             {
 352                 EnrolleeStatus enrolleeStatus = status->getEnrolleeStatus();
 353
 354
 355                 if(enrolleeStatus.getProvStatus() == ES_STATE_CONNECTED_TO_ENROLLER &&
 356                    enrolleeStatus.getLastErrCode() == ES_ERRCODE_NO_INTERNETCONNECTION)
 357                 {
 358                     isWellConstructed = true;
 359                 }
 360             }
 361         });
 362     ESResult ret = startEnrollee();
 363     ret = setDeviceProperty();
 364     ret = ESSetState(ES_STATE_CONNECTED_TO_ENROLLER);
 365     ret = ESSetErrorCode(ES_ERRCODE_NO_INTERNETCONNECTION);
 366
 367     g_mediatorSimul.getStatus(onGetStatus);
 368
 369     std::unique_lock< std::mutex > lock{ mutexForCondition };
 370     responseCon.wait_for(lock, g_waitForResponse);
 371
 372     EXPECT_EQ(ret, ES_OK);
 373
 374     ESTerminateEnrollee();
 375 }
 376
 377 TEST_F(EasysetupEnrolleeTest, WiFiAndDevConfProperiesProvisionedWithSuccess)
 378 {
 379     int cntForReceivedCallbackWithSuccess = 0;
 380
 381     mocks.OnCallFunc(deviceProvisioningStatusCallback).Do(
 382         [& cntForReceivedCallbackWithSuccess](std::shared_ptr< DevicePropProvisioningStatus > status)
 383         {
 384             if(status->getESResult() == ES_OK)
 385                cntForReceivedCallbackWithSuccess++;
 386         });
 387
 388     mocks.OnCallFunc(WiFiConfProvCbInApp).Do(
 389         [& cntForReceivedCallbackWithSuccess](ESWiFiConfData *data)
 390         {
 391             if(!strcmp(data->ssid, "Iotivity_SSID") &&
 392                 !strcmp(data->pwd, "Iotivity_PWD") &&
 393                 data->authtype == WPA2_PSK &&
 394                 data->enctype == TKIP_AES)
 395             {
 396                 cntForReceivedCallbackWithSuccess++;
 397             }
 398         });
 399
 400     startEnrollee();
 401
 402     g_mediatorSimul.provisionDeviceProperties(deviceProvisioningStatusCallback);
 403
 404     std::unique_lock< std::mutex > lock{ mutexForCondition };
 405     responseCon.wait_for(lock, g_waitForResponse);
 406
 407     EXPECT_EQ(cntForReceivedCallbackWithSuccess, 2);
 408
 409     ESTerminateEnrollee();
 410 }
 411
 412 TEST_F(EasysetupEnrolleeTest, CloudServerProperiesProvisionedWithSuccess)
 413 {
 414     int cntForReceivedCallbackWithSuccess = 0;
 415
 416     mocks.OnCallFunc(cloudProvisioningStatusCallback).Do(
 417         [& cntForReceivedCallbackWithSuccess](std::shared_ptr< CloudPropProvisioningStatus > status)
 418         {
 419             if(status->getESResult() == ES_OK)
 420             {
 421                cntForReceivedCallbackWithSuccess++;
 422             }
 423         });
 424
 425     mocks.OnCallFunc(CoapCloudConfCbInApp).Do(
 426         [& cntForReceivedCallbackWithSuccess](ESCoapCloudConfData *data)
 427         {
 428             if(!strcmp(data->authCode, "authCode") &&
 429                 !strcmp(data->authProvider, "authProvider") &&
 430                 !strcmp(data->ciServer, "ciServer"))
 431             {
 432                 cntForReceivedCallbackWithSuccess++;
 433             }
 434         });
 435
 436     startEnrollee();
 437
 438     g_mediatorSimul.provisionCloudProperties(cloudProvisioningStatusCallback);
 439
 440     std::unique_lock< std::mutex > lock{ mutexForCondition };
 441     responseCon.wait_for(lock, g_waitForResponse);
 442
 443     EXPECT_EQ(cntForReceivedCallbackWithSuccess, 2);
 444
 445     ESTerminateEnrollee();
 446 }
 447
 448 TEST_F(EasysetupEnrolleeTest, GetWifiRsrcTest)
 449 {
 450     bool isRepFlag = false;
 451     mocks.ExpectCallFunc(onGetWifiRsrc).Do(
 452         [& isRepFlag](const OCRepresentation& /*rep*/)
 453         {
 454
 455             isRepFlag = true;
 456         });
 457
 458     ESResult ret = startEnrollee();
 459     g_mediatorSimul.getWifiRsrc(onGetWifiRsrc);
 460
 461     std::unique_lock< std::mutex > lock{ mutexForCondition };
 462     responseCon.wait_for(lock, g_waitForResponse);
 463
 464     EXPECT_EQ(ret, ES_OK);
 465
 466     ESTerminateEnrollee();
 467 }
 468
 469 TEST_F(EasysetupEnrolleeTest, GetCloudRsrcTest)
 470 {
 471     bool isRepFlag = false;
 472     mocks.ExpectCallFunc(onGetCloudRsrc).Do(
 473         [& isRepFlag](const OCRepresentation& /*rep*/)
 474         {
 475             isRepFlag = true;
 476         });
 477
 478     ESResult ret = startEnrollee();
 479     g_mediatorSimul.getCloudRsrc(onGetCloudRsrc);
 480
 481     std::unique_lock< std::mutex > lock{ mutexForCondition };
 482     responseCon.wait_for(lock, g_waitForResponse);
 483
 484     EXPECT_EQ(ret, ES_OK);
 485
 486     ESTerminateEnrollee();
 487 }
 488
 489 TEST_F(EasysetupEnrolleeTest, GetDevConfTest)
 490 {
 491     bool isRepFlag = false;
 492     mocks.ExpectCallFunc(onGetDeviceConf).Do(
 493         [& isRepFlag](const OCRepresentation& /*rep*/)
 494         {
 495             isRepFlag = true;
 496         });
 497
 498     ESResult ret = startEnrollee();
 499     ret = setDeviceProperty();
 500
 501     g_mediatorSimul.getDevConfiguration(onGetDeviceConf);
 502
 503     std::unique_lock< std::mutex > lock{ mutexForCondition };
 504     responseCon.wait_for(lock, g_waitForResponse);
 505
 506     EXPECT_EQ(ret, ES_OK);
 507
 508     ESTerminateEnrollee();
 509 }
 510
 511 TEST_F(EasysetupEnrolleeTest, PutRequestTest)
 512 {
 513     bool isRepFlag = false;
 514     mocks.ExpectCallFunc(onPutRequest).Do(
 515         [& isRepFlag](const OCRepresentation& /*rep*/)
 516         {
 517             isRepFlag = true;
 518         });
 519
 520     ESResult ret = startEnrollee();
 521
 522     g_mediatorSimul.putProvRsrc(onPutRequest);
 523
 524     std::unique_lock< std::mutex > lock{ mutexForCondition };
 525     responseCon.wait_for(lock, g_waitForResponse);
 526
 527     EXPECT_EQ(ret, ES_OK);
 528
 529     ESTerminateEnrollee();
 530 }
 531
 532 TEST_F(EasysetupEnrolleeTest, ESSetCallabckForUserDataFailed)
 533 {
 534     ESResult ret = setCallabckForUserDataNULL();
 535     EXPECT_EQ(ret, ES_ERROR);
 536     ESTerminateEnrollee();
 537 }
 538
 539 TEST_F(EasysetupEnrolleeTest, ESSC_SetSCProperties)
 540 {
 541     ESResult ret = startEnrollee();
 542     EXPECT_EQ(ret, ES_OK);
 543     SCProperties properties;
 544     strncpy(properties.candidateAPInfo[0].ssid, "x_5GHz", MAXLEN_STRING);
 545     strncpy(properties.candidateAPInfo[0].passphrase, "12345678",MAXLEN_STRING);
 546     properties.candidateAPInfo[0].channel = 149;
 547     strncpy(properties.candidateAPInfo[0].bssid, "aa:bb:cc:dd:ee:01", MAXLEN_STRING);
 548     strncpy(properties.candidateAPInfo[1].ssid, "5GHz", MAXLEN_STRING);
 549     strncpy(properties.candidateAPInfo[1].passphrase, "12345678",MAXLEN_STRING);
 550     properties.candidateAPInfo[1].channel = 161;
 551     strncpy(properties.candidateAPInfo[1].bssid, "aa:bb:cc:dd:ee:02", MAXLEN_STRING);
 552     properties.numCandidateAP=2;
 553
 554     ret = SetSCProperties(&properties);
 555     EXPECT_EQ(ret, ES_OK);
 556     ESTerminateEnrollee();
 557 }
 558
 559 TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLSCProperties)
 560 {
 561     ESResult ret = startEnrollee();
 562     EXPECT_EQ(ret, ES_OK);
 563
 564     ret = SetSCProperties(NULL);
 565     EXPECT_EQ(ret, ES_ERROR);
 566     ESTerminateEnrollee();
 567 }
 568
 569 TEST_F(EasysetupEnrolleeTest, ESSC_SetTncInfo)
 570 {
 571     ESResult ret = startEnrollee();
 572     EXPECT_EQ(ret, ES_OK);
 573
 574     SCTncInfo info;
 575     strncpy(info.header, "h1", MAXLEN_STRING);
 576     strncpy(info.version, "v1",MAXLEN_STRING);
 577
 578     ret = SetSCTncInfo(&info);
 579     EXPECT_EQ(ret, ES_OK);
 580     ESTerminateEnrollee();
 581 }
 582
 583 TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLTncInfo)
 584 {
 585     ESResult ret = startEnrollee();
 586     EXPECT_EQ(ret, ES_OK);
 587
 588     ret = SetSCTncInfo(NULL);
 589     EXPECT_EQ(ret, ES_ERROR);
 590     ESTerminateEnrollee();
 591 }
 592
 593 TEST_F(EasysetupEnrolleeTest, ESSC_SetTncStatus)
 594 {
 595     ESResult ret = startEnrollee();
 596     EXPECT_EQ(ret, ES_OK);
 597
 598     ret = SetSCTncStatus(1);
 599     EXPECT_EQ(ret, ES_OK);
 600     ESTerminateEnrollee();
 601 }
 602
 603 TEST_F(EasysetupEnrolleeTest, ESSC_SetSCNetConnectionState)
 604 {
 605     ESResult ret = startEnrollee();
 606     EXPECT_EQ(ret, ES_OK);
 607
 608     ret = SetSCNetConnectionState(NET_STATE_INIT);
 609     EXPECT_EQ(ret, ES_OK);
 610     ESTerminateEnrollee();
 611 }
 612
 613 TEST_F(EasysetupEnrolleeTest, ESSC_SetRegisterSetDevice)
 614 {
 615     ESResult ret = startEnrollee();
 616     EXPECT_EQ(ret, ES_OK);
 617
 618     ret = SetRegisterSetDevice("fridge");
 619     EXPECT_EQ(ret, ES_OK);
 620     ESTerminateEnrollee();
 621 }
 622
 623 TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLRegisterSetDevice)
 624 {
 625     ESResult ret = startEnrollee();
 626     EXPECT_EQ(ret, ES_OK);
 627
 628     ret = SetRegisterSetDevice(NULL);
 629     EXPECT_EQ(ret, ES_ERROR);
 630     ESTerminateEnrollee();
 631 }
 632
 633 TEST_F(EasysetupEnrolleeTest, ESSC_SetNetworkProvInfo)
 634 {
 635     ESResult ret = startEnrollee();
 636     EXPECT_EQ(ret, ES_OK);
 637
 638     ret = SetNetworkProvInfo("netInfo");
 639     EXPECT_EQ(ret, ES_OK);
 640     ESTerminateEnrollee();
 641 }
 642
 643 TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLSetNetworkProvInfo)
 644 {
 645     ESResult ret = startEnrollee();
 646     EXPECT_EQ(ret, ES_OK);
 647
 648     ret = SetNetworkProvInfo(NULL);
 649     EXPECT_EQ(ret, ES_ERROR);
 650     ESTerminateEnrollee();
 651 }
 652
 653 TEST_F(EasysetupEnrolleeTest, ESSC_SetSCPnPPin)
 654 {
 655     ESResult ret = startEnrollee();
 656     EXPECT_EQ(ret, ES_OK);
 657
 658     ret = SetSCPnPPin("123456");
 659     EXPECT_EQ(ret, ES_OK);
 660     ESTerminateEnrollee();
 661 }
 662
 663 TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLSCPnPPin)
 664 {
 665     ESResult ret = startEnrollee();
 666     EXPECT_EQ(ret, ES_OK);
 667
 668     ret = SetSCPnPPin(NULL);
 669     EXPECT_EQ(ret, ES_ERROR);
 670     ESTerminateEnrollee();
 671 }
 672
 673 TEST_F(EasysetupEnrolleeTest, ESSC_SetESVersionInfo)
 674 {
 675     ESResult ret = startEnrollee();
 676     EXPECT_EQ(ret, ES_OK);
 677
 678     ret = SetESVersionInfo("1.0");
 679     EXPECT_EQ(ret, ES_OK);
 680     ESTerminateEnrollee();
 681 }
 682
 683 TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLESVersionInfo)
 684 {
 685     ESResult ret = startEnrollee();
 686     EXPECT_EQ(ret, ES_OK);
 687
 688     ret = SetESVersionInfo(NULL);
 689     EXPECT_EQ(ret, ES_ERROR);
 690     ESTerminateEnrollee();
 691 }
 692
 693 TEST_F(EasysetupEnrolleeTest, ESSC_SetSSOList)
 694 {
 695     ESResult ret = startEnrollee();
 696     EXPECT_EQ(ret, ES_OK);
 697
 698     ret = SetSSOList("xyz");
 699     EXPECT_EQ(ret, ES_OK);
 700     ESTerminateEnrollee();
 701 }
 702
 703 TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLSSOList)
 704 {
 705     ESResult ret = startEnrollee();
 706     EXPECT_EQ(ret, ES_OK);
 707
 708     ret = SetSSOList(NULL);
 709     EXPECT_EQ(ret, ES_ERROR);
 710     ESTerminateEnrollee();
 711 }
 712
 713 TEST_F(EasysetupEnrolleeTest, ReadWriteUserCallback)
 714 {
 715     int cntForReceivedCallbackWithSuccess = 0;
 716
 717     mocks.OnCallFunc(deviceProvisioningStatusCallback).Do(
 718         [& cntForReceivedCallbackWithSuccess](std::shared_ptr< DevicePropProvisioningStatus > status)
 719         {
 720             if(status->getESResult() == ES_OK)
 721                cntForReceivedCallbackWithSuccess++;
 722         });
 723
 724     mocks.OnCallFunc(WiFiConfProvCbInApp).Do(
 725         [& cntForReceivedCallbackWithSuccess](ESWiFiConfData *data)
 726         {
 727             if(!strcmp(data->ssid, "Iotivity_SSID") &&
 728                 !strcmp(data->pwd, "Iotivity_PWD") &&
 729                 data->authtype == WPA2_PSK &&
 730                 data->enctype == TKIP_AES)
 731             {
 732                 cntForReceivedCallbackWithSuccess++;
 733             }
 734         });
 735
 736     startEnrollee();
 737
 738     EXPECT_EQ(ESSetCallbackForUserdata(&ReadUserdataCb, &WriteUserdataCb), ES_OK);
 739
 740     g_mediatorSimul.provisionDeviceProperties(deviceProvisioningStatusCallback);
 741
 742     std::unique_lock< std::mutex > lock{ mutexForCondition };
 743     responseCon.wait_for(lock, g_waitForResponse);
 744
 745     EXPECT_EQ(cntForReceivedCallbackWithSuccess, 2);
 746
 747     ESTerminateEnrollee();
 748 }
 749