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();
+}