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
index 38e27bf..3cb5a25 100644 (file)
--- a/resource/provisioning/unittests/OCProvisioningTest.cpp
+++ b/resource/provisioning/unittests/OCProvisioningTest.cpp
@@ -24,7 +24,8 @@
 #include <OCPlatform_impl.h>
 #include <oxmjustworks.h>
 #include <oxmrandompin.h>
-#include <OCProvisioningManager.h>
+#include <srmutility.h>
+#include <OCProvisioningManager.hpp>
 #include <gtest/gtest.h>
 
 #define TIMEOUT 5
@@ -51,6 +52,24 @@ namespace OCProvisioningTest
         EXPECT_EQ(OC_STACK_OK, OCSecure::provisionInit(dbPath));
     }
 
+    TEST(DiscoveryTest, SecureResource)
+    {
+        std::shared_ptr< OC::OCSecureResource > secureResource;
+        OicUuid_t uuid;
+        ConvertStrToUuid("11111111-1111-1111-1111-111111111111", &uuid);
+
+        EXPECT_EQ(OC_STACK_TIMEOUT, OCSecure::discoverSingleDevice(TIMEOUT, &uuid, secureResource));
+    }
+
+    TEST(DiscoveryTest, SecureResourceZeroTimeout)
+    {
+        std::shared_ptr< OC::OCSecureResource > secureResource;
+        OicUuid_t uuid;
+        ConvertStrToUuid("11111111-1111-1111-1111-111111111111", &uuid);
+
+        EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverSingleDevice(0, &uuid, secureResource));
+    }
+
     TEST(DiscoveryTest, UnownedDevices)
     {
         DeviceList_t list;
@@ -63,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;
@@ -75,53 +120,66 @@ 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)
     {
         DeviceList_t owned, unowned;
@@ -173,4 +231,45 @@ namespace OCProvisioningTest
         OICFree(acl2);
     }
 
+    TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullPconf)
+    {
+        OCSecureResource device;
+        EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionDirectPairing(nullptr, resultCallback));
+    }
+
+    TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullCallback)
+    {
+        OCSecureResource device;
+        OicSecPconf_t *pconf = (OicSecPconf_t *)OICCalloc(1,sizeof(OicSecPconf_t));
+        EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionDirectPairing(pconf, nullptr));
+        OICFree(pconf);
+    }
+
+    TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullCallbackNUllPconf)
+    {
+        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__
 }