replace : iotivity -> iotivity-sec

[platform/upstream/iotivity.git] / resource / provisioning / unittests / OCProvisioningTest.cpp

diff --git a/resource/provisioning/unittests/OCProvisioningTest.cpp b/resource/provisioning/unittests/OCProvisioningTest.cpp
old mode 100755 (executable)
new mode 100644 (file)
index 11e198b..3cb5a25
--- a/resource/provisioning/unittests/OCProvisioningTest.cpp
+++ b/resource/provisioning/unittests/OCProvisioningTest.cpp
@@ -58,7 +58,7 @@ namespace OCProvisioningTest
         OicUuid_t uuid;
         ConvertStrToUuid("11111111-1111-1111-1111-111111111111", &uuid);
 
-        EXPECT_EQ(OC_STACK_OK, OCSecure::discoverSingleDevice(TIMEOUT, &uuid, secureResource));
+        EXPECT_EQ(OC_STACK_TIMEOUT, OCSecure::discoverSingleDevice(TIMEOUT, &uuid, secureResource));
     }
 
     TEST(DiscoveryTest, SecureResourceZeroTimeout)
@@ -82,6 +82,32 @@ namespace OCProvisioningTest
         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverUnownedDevices(0, list));
     }
 
+#ifdef MULTIPLE_OWNER
+    TEST(MOTDiscoveryTest, MultipleOwnerEnabledDevices)
+    {
+        DeviceList_t list;
+        EXPECT_EQ(OC_STACK_OK, OCSecure::discoverMultipleOwnerEnabledDevices(TIMEOUT, list));
+    }
+
+    TEST(MOTDiscoveryTest, MultipleOwnerEnabledDevicesZeroTimeOut)
+    {
+        DeviceList_t list;
+        EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverMultipleOwnerEnabledDevices(0, list));
+    }
+
+    TEST(MOTDiscoveryTest, MultipleOwnedDevices)
+    {
+        DeviceList_t list;
+        EXPECT_EQ(OC_STACK_OK, OCSecure::discoverMultipleOwnedDevices(TIMEOUT, list));
+    }
+
+    TEST(MOTDiscoveryTest, MultipleOwnedDevicesZeroTimeOut)
+    {
+        DeviceList_t list;
+        EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverMultipleOwnedDevices(0, list));
+    }
+#endif
+
     TEST(DiscoveryTest, OwnedDevices)
     {
         DeviceList_t list;
@@ -94,52 +120,65 @@ namespace OCProvisioningTest
         EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverOwnedDevices(0, list));
     }
 
-    TEST(OwnershipTest, SetOwnershipTransferCBDataNull)
+    TEST(OwnershipTest, OwnershipTransferNullCallback)
     {
-        EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setOwnerTransferCallbackData(
-                    OIC_JUST_WORKS, NULL, NULL));
+        OCSecureResource device;
+        EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.doOwnershipTransfer(nullptr));
     }
 
-    TEST(OwnershipTest, SetOwnershipTransferCBData)
+#ifdef MULTIPLE_OWNER
+    TEST(MOTOwnershipTest, MOTOwnershipTransferNullCallback)
     {
-        OTMCallbackData_t justWorksCBData;
-        justWorksCBData.loadSecretCB = LoadSecretJustWorksCallback;
-        justWorksCBData.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
-        justWorksCBData.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
-        justWorksCBData.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
-        EXPECT_EQ(OC_STACK_OK, OCSecure::setOwnerTransferCallbackData(OIC_JUST_WORKS,
-                                        &justWorksCBData, NULL));
+        OCSecureResource device;
+        EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.doMultipleOwnershipTransfer(nullptr));
     }
 
-    TEST(OwnershipTest, SetOwnershipTransferCBDataInvalidType)
+    TEST(selectMOTMethodTest, selectMOTMethodNullCallback)
     {
-        OTMCallbackData_t justWorksCBData;
-        justWorksCBData.loadSecretCB = LoadSecretJustWorksCallback;
-        justWorksCBData.createSecureSessionCB = CreateSecureSessionJustWorksCallback;
-        justWorksCBData.createSelectOxmPayloadCB = CreateJustWorksSelectOxmPayload;
-        justWorksCBData.createOwnerTransferPayloadCB = CreateJustWorksOwnerTransferPayload;
-        EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setOwnerTransferCallbackData(OIC_OXM_COUNT,
-                                        &justWorksCBData, NULL));
+        OCSecureResource device;
+        const OicSecOxm_t stsecOxm = OIC_PRECONFIG_PIN;
+        EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.selectMOTMethod(stsecOxm, NULL));
     }
 
-    TEST(OwnershipTest, SetOwnershipTransferCBDataNullInputPin)
+    TEST(changeMOTModeTest, changeMOTModeNullCallback)
     {
-        OTMCallbackData_t pinBasedCBData;
-        pinBasedCBData.loadSecretCB = InputPinCodeCallback;
-        pinBasedCBData.createSecureSessionCB = CreateSecureSessionRandomPinCallback;
-        pinBasedCBData.createSelectOxmPayloadCB = CreatePinBasedSelectOxmPayload;
-        pinBasedCBData.createOwnerTransferPayloadCB = CreatePinBasedOwnerTransferPayload;
-        OTMSetOwnershipTransferCallbackData(OIC_RANDOM_DEVICE_PIN, &pinBasedCBData);
+        OCSecureResource device;
+        const OicSecMomType_t momType = OIC_MULTIPLE_OWNER_ENABLE;
+        EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.changeMOTMode(momType, NULL));
+    }
 
-        EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setOwnerTransferCallbackData(
-                    OIC_RANDOM_DEVICE_PIN, &pinBasedCBData, NULL));
+    TEST(addPreconfigPINTest, addPreconfigPINNullPin)
+    {
+        OCSecureResource device;
+        EXPECT_EQ(OC_STACK_INVALID_PARAM, device.addPreconfigPIN(NULL, 0));
     }
 
-    TEST(OwnershipTest, OwnershipTransferNullCallback)
+    TEST(provisionPreconfPinTest, provisionPreconfPinNullCallback)
     {
         OCSecureResource device;
-        EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.doOwnershipTransfer(nullptr));
+        const char *pin = "test";
+        size_t PinLength = 4;
+        EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionPreconfPin(pin, PinLength, NULL));
+    }
+
+    TEST(isMOTEnabledTest, isMOTEnabledWithoutDeviceInst)
+    {
+        OCSecureResource device;
+        EXPECT_EQ(false, device.isMOTEnabled());
+    }
+
+    TEST(isMOTSupportedTest, isMOTSupportedWithoutDeviceInst)
+    {
+        OCSecureResource device;
+        EXPECT_EQ(false, device.isMOTSupported());
+    }
+
+    TEST(getMOTMethodTest, getMOTMethodNullOxM)
+    {
+        OCSecureResource device;
+        EXPECT_EQ(OC_STACK_INVALID_PARAM, device.getMOTMethod(NULL));
     }
+#endif
 
     TEST(DeviceInfoTest, DevInfoFromNetwork)
     {
@@ -211,4 +250,26 @@ namespace OCProvisioningTest
         OCSecureResource device;
         EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionDirectPairing(nullptr, nullptr));
     }
+
+#if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
+    TEST(setDeviceIdSeed, NullParam)
+    {
+        EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setDeviceIdSeed(NULL, 0));
+    }
+
+    TEST(setDeviceIdSeed, InvalidParam)
+    {
+        uint8_t seed[1024] = {0};
+
+        EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setDeviceIdSeed(seed, 0));
+        EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setDeviceIdSeed(seed, sizeof(seed)));
+    }
+
+    TEST(setDeviceIdSeed, ValidValue)
+    {
+        uint8_t seed[16] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+                            0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
+        EXPECT_EQ(OC_STACK_OK, OCSecure::setDeviceIdSeed(seed, sizeof(seed)));
+    }
+#endif // __WITH_DTLS__ || __WITH_TLS__
 }