projects / platform / upstream / iotivity.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Add Unit Tests for EasySetup APIs.
[platform/upstream/iotivity.git] / service / easy-setup / enrollee / unittests / ESEnrolleeTest.cpp
diff --git a/service/easy-setup/enrollee/unittests/ESEnrolleeTest.cpp b/service/easy-setup/enrollee/unittests/ESEnrolleeTest.cpp
index ef6611f..0a172bb 100755 (executable)
--- 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
@@ -118,30 +121,30 @@ 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);
     }
@@ -149,9 +152,9 @@ public:
     ESResult startEnrolleeWithInvalidRsrcMask()
     {
         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, (ESResourceMask)0, callbacks);
     }
@@ -159,7 +162,7 @@ public:
     ESResult setDeviceProperty()
     {
         ESDeviceProperty deviceProperty = {
-            {{WIFI_11G, WiFi_EOF}, WIFI_5G}, {"Test Device", "Test Model Number"}
+            {{WIFI_11G, WiFi_EOF}, WIFI_5G}, {"Test Device"}
         };
 
         return ESSetDeviceProperty(&deviceProperty);
@@ -211,13 +214,13 @@ TEST_F(EasysetupEnrolleeTest, ESInitEnrolleeFailedInvalidRsrcMask)
 
 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);
@@ -226,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);
@@ -241,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);
@@ -382,8 +385,8 @@ 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") &&
@@ -393,15 +396,6 @@ TEST_F(EasysetupEnrolleeTest, WiFiAndDevConfProperiesProvisionedWithSuccess)
                 cntForReceivedCallbackWithSuccess++;
             }
         });
-    mocks.OnCallFunc(DevConfProvCbInApp).Do(
-        [& cntForReceivedCallbackWithSuccess](ESDevConfProvData *data)
-        {
-            if(!strcmp(data->language, "korean") &&
-                !strcmp(data->country, "Korea"))
-            {
-                cntForReceivedCallbackWithSuccess++;
-            }
-        });
 
     startEnrollee();
 
@@ -410,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();
 }
@@ -422,15 +416,14 @@ TEST_F(EasysetupEnrolleeTest, CloudServerProperiesProvisionedWithSuccess)
     mocks.OnCallFunc(cloudProvisioningStatusCallback).Do(
         [& cntForReceivedCallbackWithSuccess](std::shared_ptr< CloudPropProvisioningStatus > status)
         {
-            // Will called twice
-            if(status->getESResult() == ES_OK || status->getESResult() == ES_FOUND_ENROLLEE)
+            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") &&
@@ -447,7 +440,7 @@ 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();
 }
@@ -542,3 +535,215 @@ TEST_F(EasysetupEnrolleeTest, ESSetCallabckForUserDataFailed)
     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();
+}
+
Domain: Network & Connectivity / IoT Connectivity;