#include "ESMediatorSimulator.h"
#include "easysetup.h"
+extern "C" {
+#include "samsung/sc_easysetup.h"
+}
using namespace OC;
namespace
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();
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;
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 = {
return ESSetDeviceProperty(&deviceProperty);
}
+ ESResult setCallabckForUserDataNULL()
+ {
+ return ESSetCallbackForUserdata(NULL, NULL);
+ }
+
protected:
void SetUp()
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);
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);
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);
{
EnrolleeStatus enrolleeStatus = status->getEnrolleeStatus();
+
if(enrolleeStatus.getProvStatus() == ES_STATE_CONNECTED_TO_ENROLLER &&
enrolleeStatus.getLastErrCode() == ES_ERRCODE_NO_INTERNETCONNECTION)
+ {
isWellConstructed = true;
+ }
}
});
ESResult ret = startEnrollee();
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();
std::unique_lock< std::mutex > lock{ mutexForCondition };
responseCon.wait_for(lock, g_waitForResponse);
- EXPECT_EQ(cntForReceivedCallbackWithSuccess, 3);
+ EXPECT_EQ(cntForReceivedCallbackWithSuccess, 2);
ESTerminateEnrollee();
}
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();
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();
+}
projects / platform / upstream / iotivity.git / blobdiff