X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=service%2Feasy-setup%2Fenrollee%2Funittests%2FESEnrolleeTest.cpp;h=0a172bbfb22304c3cbb13d016ea93731ae614f42;hb=1897553fd6563f30e4841d2da608deaf569f4a91;hp=a4283e648270c79fec6e87d62082559791c5af8f;hpb=e7725ad2a4b6cae243df46a24fdc5345abfe729f;p=platform%2Fupstream%2Fiotivity.git

diff --git a/service/easy-setup/enrollee/unittests/ESEnrolleeTest.cpp b/service/easy-setup/enrollee/unittests/ESEnrolleeTest.cpp
index a4283e6..0a172bb 100755
--- a/service/easy-setup/enrollee/unittests/ESEnrolleeTest.cpp
+++ b/service/easy-setup/enrollee/unittests/ESEnrolleeTest.cpp
@@ -29,6 +29,9 @@
 #include "ESMediatorSimulator.h"
 #include "easysetup.h"
 
+extern "C" {
+#include "samsung/sc_easysetup.h"
+}
 using namespace OC;
 
 namespace
@@ -49,9 +52,12 @@ public:
     MockRepository mocks;
 
 protected:
-    virtual ~TestWithMock() noexcept(noexcept(std::declval<Test>().~Test())) {}
+    virtual ~TestWithMock() noexcept(noexcept(std::declval<Test>().~Test()))
+    {
+    }
 
-    virtual void TearDown() {
+    virtual void TearDown()
+    {
         try
         {
             mocks.VerifyAll();
@@ -85,6 +91,26 @@ public:
         std::cout << __func__ << std::endl;
     }
 
+    static void onGetWifiRsrc(const OCRepresentation& )
+    {
+        std::cout << __func__ << std::endl;
+    }
+
+    static void onGetCloudRsrc(const OCRepresentation& )
+    {
+        std::cout << __func__ << std::endl;
+    }
+
+    static void onGetDeviceConf(const OCRepresentation& )
+    {
+        std::cout << __func__ << std::endl;
+    }
+
+    static void onPutRequest(const OCRepresentation& )
+    {
+        std::cout << __func__ << std::endl;
+    }
+
     static void deviceProvisioningStatusCallback(std::shared_ptr< DevicePropProvisioningStatus >)
     {
         std::cout << __func__ << std::endl;
@@ -95,34 +121,44 @@ public:
         std::cout << __func__ << std::endl;
     }
 
-    static void WiFiProvCbInApp(ESWiFiProvData *)
+    static void WiFiConfProvCbInApp(ESWiFiConfData *)
     {
         std::cout << __func__ << std::endl;
     }
 
-    static void DevConfProvCbInApp(ESDevConfProvData *)
+    static void DevConfProvCbInApp(ESDevConfData *)
     {
         std::cout << __func__ << std::endl;
     }
 
-    static void CloudDataCbInApp(ESCloudProvData *)
+    static void CoapCloudConfCbInApp(ESCoapCloudConfData *)
     {
         std::cout << __func__ << std::endl;
     }
 
     ESResult startEnrollee()
     {
-        ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFI_RESOURCE |
-                                                    ES_CLOUD_RESOURCE |
+        ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
+                                                    ES_COAPCLOUDCONF_RESOURCE |
                                                     ES_DEVCONF_RESOURCE);
         ESProvisioningCallbacks callbacks;
-        callbacks.WiFiProvCb = &EasysetupEnrolleeTest::WiFiProvCbInApp;
+        callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
         callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
-        callbacks.CloudDataProvCb = &EasysetupEnrolleeTest::CloudDataCbInApp;
+        callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
 
         return ESInitEnrollee(false, resourcemMask, callbacks);
     }
 
+    ESResult startEnrolleeWithInvalidRsrcMask()
+    {
+        ESProvisioningCallbacks callbacks;
+        callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
+        callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
+        callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
+
+        return ESInitEnrollee(false, (ESResourceMask)0, callbacks);
+    }
+
     ESResult setDeviceProperty()
     {
         ESDeviceProperty deviceProperty = {
@@ -132,6 +168,11 @@ public:
         return ESSetDeviceProperty(&deviceProperty);
     }
 
+    ESResult setCallabckForUserDataNULL()
+    {
+        return ESSetCallbackForUserdata(NULL, NULL);
+    }
+
 protected:
 
     void SetUp()
@@ -164,15 +205,22 @@ TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeSuccess)
     ESTerminateEnrollee();
 }
 
+TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedInvalidRsrcMask)
+{
+    ESResult ret = startEnrolleeWithInvalidRsrcMask();
+    EXPECT_EQ(ret, ES_ERROR);
+    ESTerminateEnrollee();
+}
+
 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByWiFiCbIsNull)
 {
-    ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFI_RESOURCE |
-                                                    ES_CLOUD_RESOURCE |
+    ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
+                                                    ES_COAPCLOUDCONF_RESOURCE |
                                                     ES_DEVCONF_RESOURCE);
     ESProvisioningCallbacks callbacks;
-    callbacks.WiFiProvCb = NULL;
+    callbacks.WiFiConfProvCb = NULL;
     callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
-    callbacks.CloudDataProvCb = &EasysetupEnrolleeTest::CloudDataCbInApp;
+    callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
 
     ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
     EXPECT_EQ(ret, ES_ERROR);
@@ -181,13 +229,13 @@ TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByWiFiCbIsNull)
 
 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByDevConfCbIsNull)
 {
-    ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFI_RESOURCE |
-                                                    ES_CLOUD_RESOURCE |
+    ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
+                                                    ES_COAPCLOUDCONF_RESOURCE |
                                                     ES_DEVCONF_RESOURCE);
     ESProvisioningCallbacks callbacks;
-    callbacks.WiFiProvCb = &EasysetupEnrolleeTest::WiFiProvCbInApp;
+    callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
     callbacks.DevConfProvCb = NULL;
-    callbacks.CloudDataProvCb = &EasysetupEnrolleeTest::CloudDataCbInApp;
+    callbacks.CoapCloudConfProvCb = &EasysetupEnrolleeTest::CoapCloudConfCbInApp;
 
     ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
     EXPECT_EQ(ret, ES_ERROR);
@@ -196,13 +244,13 @@ TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByDevConfCbIsNull)
 
 TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedByCloudCbIsNull)
 {
-    ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFI_RESOURCE |
-                                                    ES_CLOUD_RESOURCE |
+    ESResourceMask resourcemMask = (ESResourceMask)(ES_WIFICONF_RESOURCE |
+                                                    ES_COAPCLOUDCONF_RESOURCE |
                                                     ES_DEVCONF_RESOURCE);
     ESProvisioningCallbacks callbacks;
-    callbacks.WiFiProvCb = &EasysetupEnrolleeTest::WiFiProvCbInApp;
+    callbacks.WiFiConfProvCb = &EasysetupEnrolleeTest::WiFiConfProvCbInApp;
     callbacks.DevConfProvCb = &EasysetupEnrolleeTest::DevConfProvCbInApp;
-    callbacks.CloudDataProvCb = NULL;
+    callbacks.CoapCloudConfProvCb = NULL;
 
     ESResult ret = ESInitEnrollee(false, resourcemMask, callbacks);
     EXPECT_EQ(ret, ES_ERROR);
@@ -303,9 +351,12 @@ TEST_F(EasysetupEnrolleeTest, ProvisioningPropertiesIsWellConstructedInResponseP
             {
                 EnrolleeStatus enrolleeStatus = status->getEnrolleeStatus();
 
+
                 if(enrolleeStatus.getProvStatus() == ES_STATE_CONNECTED_TO_ENROLLER &&
                    enrolleeStatus.getLastErrCode() == ES_ERRCODE_NO_INTERNETCONNECTION)
+                {
                     isWellConstructed = true;
+                }
             }
         });
     ESResult ret = startEnrollee();
@@ -334,21 +385,16 @@ TEST_F(EasysetupEnrolleeTest, WiFiAndDevConfProperiesProvisionedWithSuccess)
                cntForReceivedCallbackWithSuccess++;
         });
 
-    mocks.OnCallFunc(WiFiProvCbInApp).Do(
-        [& cntForReceivedCallbackWithSuccess](ESWiFiProvData *data)
+    mocks.OnCallFunc(WiFiConfProvCbInApp).Do(
+        [& cntForReceivedCallbackWithSuccess](ESWiFiConfData *data)
         {
             if(!strcmp(data->ssid, "Iotivity_SSID") &&
                 !strcmp(data->pwd, "Iotivity_PWD") &&
                 data->authtype == WPA2_PSK &&
                 data->enctype == TKIP_AES)
+            {
                 cntForReceivedCallbackWithSuccess++;
-        });
-    mocks.OnCallFunc(DevConfProvCbInApp).Do(
-        [& cntForReceivedCallbackWithSuccess](ESDevConfProvData *data)
-        {
-            if(!strcmp(data->language, "korean") &&
-                !strcmp(data->country, "Korea"))
-                cntForReceivedCallbackWithSuccess++;
+            }
         });
 
     startEnrollee();
@@ -358,7 +404,7 @@ TEST_F(EasysetupEnrolleeTest, WiFiAndDevConfProperiesProvisionedWithSuccess)
     std::unique_lock< std::mutex > lock{ mutexForCondition };
     responseCon.wait_for(lock, g_waitForResponse);
 
-    EXPECT_EQ(cntForReceivedCallbackWithSuccess, 3);
+    EXPECT_EQ(cntForReceivedCallbackWithSuccess, 2);
 
     ESTerminateEnrollee();
 }
@@ -370,18 +416,21 @@ TEST_F(EasysetupEnrolleeTest, CloudServerProperiesProvisionedWithSuccess)
     mocks.OnCallFunc(cloudProvisioningStatusCallback).Do(
         [& cntForReceivedCallbackWithSuccess](std::shared_ptr< CloudPropProvisioningStatus > status)
         {
-            // Will called twice
             if(status->getESResult() == ES_OK)
+            {
                cntForReceivedCallbackWithSuccess++;
+            }
         });
 
-    mocks.OnCallFunc(CloudDataCbInApp).Do(
-        [& cntForReceivedCallbackWithSuccess](ESCloudProvData *data)
+    mocks.OnCallFunc(CoapCloudConfCbInApp).Do(
+        [& cntForReceivedCallbackWithSuccess](ESCoapCloudConfData *data)
         {
             if(!strcmp(data->authCode, "authCode") &&
                 !strcmp(data->authProvider, "authProvider") &&
                 !strcmp(data->ciServer, "ciServer"))
+            {
                 cntForReceivedCallbackWithSuccess++;
+            }
         });
 
     startEnrollee();
@@ -391,9 +440,310 @@ TEST_F(EasysetupEnrolleeTest, CloudServerProperiesProvisionedWithSuccess)
     std::unique_lock< std::mutex > lock{ mutexForCondition };
     responseCon.wait_for(lock, g_waitForResponse);
 
-    EXPECT_EQ(cntForReceivedCallbackWithSuccess, 3);
+    EXPECT_EQ(cntForReceivedCallbackWithSuccess, 2);
+
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, GetWifiRsrcTest)
+{
+    bool isRepFlag = false;
+    mocks.ExpectCallFunc(onGetWifiRsrc).Do(
+        [& isRepFlag](const OCRepresentation& /*rep*/)
+        {
+
+            isRepFlag = true;
+        });
+
+    ESResult ret = startEnrollee();
+    g_mediatorSimul.getWifiRsrc(onGetWifiRsrc);
+
+    std::unique_lock< std::mutex > lock{ mutexForCondition };
+    responseCon.wait_for(lock, g_waitForResponse);
+
+    EXPECT_EQ(ret, ES_OK);
+
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, GetCloudRsrcTest)
+{
+    bool isRepFlag = false;
+    mocks.ExpectCallFunc(onGetCloudRsrc).Do(
+        [& isRepFlag](const OCRepresentation& /*rep*/)
+        {
+            isRepFlag = true;
+        });
+
+    ESResult ret = startEnrollee();
+    g_mediatorSimul.getCloudRsrc(onGetCloudRsrc);
+
+    std::unique_lock< std::mutex > lock{ mutexForCondition };
+    responseCon.wait_for(lock, g_waitForResponse);
+
+    EXPECT_EQ(ret, ES_OK);
+
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, GetDevConfTest)
+{
+    bool isRepFlag = false;
+    mocks.ExpectCallFunc(onGetDeviceConf).Do(
+        [& isRepFlag](const OCRepresentation& /*rep*/)
+        {
+            isRepFlag = true;
+        });
+
+    ESResult ret = startEnrollee();
+    ret = setDeviceProperty();
+
+    g_mediatorSimul.getDevConfiguration(onGetDeviceConf);
+
+    std::unique_lock< std::mutex > lock{ mutexForCondition };
+    responseCon.wait_for(lock, g_waitForResponse);
+
+    EXPECT_EQ(ret, ES_OK);
+
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, PutRequestTest)
+{
+    bool isRepFlag = false;
+    mocks.ExpectCallFunc(onPutRequest).Do(
+        [& isRepFlag](const OCRepresentation& /*rep*/)
+        {
+            isRepFlag = true;
+        });
+
+    ESResult ret = startEnrollee();
+
+    g_mediatorSimul.putProvRsrc(onPutRequest);
+
+    std::unique_lock< std::mutex > lock{ mutexForCondition };
+    responseCon.wait_for(lock, g_waitForResponse);
+
+    EXPECT_EQ(ret, ES_OK);
+
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSetCallabckForUserDataFailed)
+{
+    ESResult ret = setCallabckForUserDataNULL();
+    EXPECT_EQ(ret, ES_ERROR);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSC_SetSCProperties)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+    SCProperties properties;
+    strncpy(properties.candidateAPInfo[0].ssid, "x_5GHz", MAXLEN_STRING);
+    strncpy(properties.candidateAPInfo[0].passphrase, "12345678",MAXLEN_STRING);
+    properties.candidateAPInfo[0].channel = 149;
+    strncpy(properties.candidateAPInfo[0].bssid, "aa:bb:cc:dd:ee:01", MAXLEN_STRING);
+    strncpy(properties.candidateAPInfo[1].ssid, "5GHz", MAXLEN_STRING);
+    strncpy(properties.candidateAPInfo[1].passphrase, "12345678",MAXLEN_STRING);
+    properties.candidateAPInfo[1].channel = 161;
+    strncpy(properties.candidateAPInfo[1].bssid, "aa:bb:cc:dd:ee:02", MAXLEN_STRING);
+    properties.numCandidateAP=2;
+
+    ret = SetSCProperties(&properties);
+    EXPECT_EQ(ret, ES_OK);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLSCProperties)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    ret = SetSCProperties(NULL);
+    EXPECT_EQ(ret, ES_ERROR);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSC_SetTncInfo)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    SCTncInfo info;
+    strncpy(info.header, "h1", MAXLEN_STRING);
+    strncpy(info.version, "v1",MAXLEN_STRING);
+
+    ret = SetSCTncInfo(&info);
+    EXPECT_EQ(ret, ES_OK);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLTncInfo)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    ret = SetSCTncInfo(NULL);
+    EXPECT_EQ(ret, ES_ERROR);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSC_SetTncStatus)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    ret = SetSCTncStatus(1);
+    EXPECT_EQ(ret, ES_OK);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSC_SetSCNetConnectionState)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    ret = SetSCNetConnectionState(NET_STATE_INIT);
+    EXPECT_EQ(ret, ES_OK);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSC_SetRegisterSetDevice)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    ret = SetRegisterSetDevice("fridge");
+    EXPECT_EQ(ret, ES_OK);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLRegisterSetDevice)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    ret = SetRegisterSetDevice(NULL);
+    EXPECT_EQ(ret, ES_ERROR);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSC_SetNetworkProvInfo)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    ret = SetNetworkProvInfo("netInfo");
+    EXPECT_EQ(ret, ES_OK);
+    ESTerminateEnrollee();
+}
 
+TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLSetNetworkProvInfo)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    ret = SetNetworkProvInfo(NULL);
+    EXPECT_EQ(ret, ES_ERROR);
     ESTerminateEnrollee();
 }
 
+TEST_F(EasysetupEnrolleeTest, ESSC_SetSCPnPPin)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    ret = SetSCPnPPin("123456");
+    EXPECT_EQ(ret, ES_OK);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLSCPnPPin)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    ret = SetSCPnPPin(NULL);
+    EXPECT_EQ(ret, ES_ERROR);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSC_SetESVersionInfo)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    ret = SetESVersionInfo("1.0");
+    EXPECT_EQ(ret, ES_OK);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLESVersionInfo)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    ret = SetESVersionInfo(NULL);
+    EXPECT_EQ(ret, ES_ERROR);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSC_SetSSOList)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    ret = SetSSOList("xyz");
+    EXPECT_EQ(ret, ES_OK);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ESSC_SetNULLSSOList)
+{
+    ESResult ret = startEnrollee();
+    EXPECT_EQ(ret, ES_OK);
+
+    ret = SetSSOList(NULL);
+    EXPECT_EQ(ret, ES_ERROR);
+    ESTerminateEnrollee();
+}
+
+TEST_F(EasysetupEnrolleeTest, ReadWriteUserCallback)
+{
+    int cntForReceivedCallbackWithSuccess = 0;
+
+    mocks.OnCallFunc(deviceProvisioningStatusCallback).Do(
+        [& cntForReceivedCallbackWithSuccess](std::shared_ptr< DevicePropProvisioningStatus > status)
+        {
+            if(status->getESResult() == ES_OK)
+               cntForReceivedCallbackWithSuccess++;
+        });
+
+    mocks.OnCallFunc(WiFiConfProvCbInApp).Do(
+        [& cntForReceivedCallbackWithSuccess](ESWiFiConfData *data)
+        {
+            if(!strcmp(data->ssid, "Iotivity_SSID") &&
+                !strcmp(data->pwd, "Iotivity_PWD") &&
+                data->authtype == WPA2_PSK &&
+                data->enctype == TKIP_AES)
+            {
+                cntForReceivedCallbackWithSuccess++;
+            }
+        });
+
+    startEnrollee();
+
+    EXPECT_EQ(ESSetCallbackForUserdata(&ReadUserdataCb, &WriteUserdataCb), ES_OK);
+
+    g_mediatorSimul.provisionDeviceProperties(deviceProvisioningStatusCallback);
+
+    std::unique_lock< std::mutex > lock{ mutexForCondition };
+    responseCon.wait_for(lock, g_waitForResponse);
+
+    EXPECT_EQ(cntForReceivedCallbackWithSuccess, 2);
+
+    ESTerminateEnrollee();
+}