1 /* *****************************************************************
3 * Copyright 2015 Samsung Electronics All Rights Reserved.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
19 * *****************************************************************/
22 #include <oic_malloc.h>
24 #include <OCPlatform_impl.h>
25 #include <oxmjustworks.h>
26 #include <oxmrandompin.h>
27 #include <srmutility.h>
28 #include <OCProvisioningManager.hpp>
29 #include <gtest/gtest.h>
33 namespace OCProvisioningTest
37 void resultCallback(PMResultList_t *result, int hasError)
43 TEST(ProvisionInitTest, TestWithEmptyPath)
45 std::string dbPath("");
46 EXPECT_EQ(OC_STACK_OK, OCSecure::provisionInit(dbPath));
49 TEST(ProvisionInitTest, TestValidPath)
51 std::string dbPath("./dbPath");
52 EXPECT_EQ(OC_STACK_OK, OCSecure::provisionInit(dbPath));
55 TEST(DiscoveryTest, SecureResource)
57 std::shared_ptr< OC::OCSecureResource > secureResource;
59 ConvertStrToUuid("11111111-1111-1111-1111-111111111111", &uuid);
61 EXPECT_EQ(OC_STACK_TIMEOUT, OCSecure::discoverSingleDevice(TIMEOUT, &uuid, secureResource));
64 TEST(DiscoveryTest, SecureResourceZeroTimeout)
66 std::shared_ptr< OC::OCSecureResource > secureResource;
68 ConvertStrToUuid("11111111-1111-1111-1111-111111111111", &uuid);
70 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverSingleDevice(0, &uuid, secureResource));
73 TEST(DiscoveryTest, UnownedDevices)
76 EXPECT_EQ(OC_STACK_OK, OCSecure::discoverUnownedDevices(TIMEOUT, list));
79 TEST(DiscoveryTest, UnownedDevicesZeroTimeout)
82 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverUnownedDevices(0, list));
86 TEST(MOTDiscoveryTest, MultipleOwnerEnabledDevices)
89 EXPECT_EQ(OC_STACK_OK, OCSecure::discoverMultipleOwnerEnabledDevices(TIMEOUT, list));
92 TEST(MOTDiscoveryTest, MultipleOwnerEnabledDevicesZeroTimeOut)
95 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverMultipleOwnerEnabledDevices(0, list));
98 TEST(MOTDiscoveryTest, MultipleOwnedDevices)
101 EXPECT_EQ(OC_STACK_OK, OCSecure::discoverMultipleOwnedDevices(TIMEOUT, list));
104 TEST(MOTDiscoveryTest, MultipleOwnedDevicesZeroTimeOut)
107 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverMultipleOwnedDevices(0, list));
111 TEST(DiscoveryTest, OwnedDevices)
114 EXPECT_EQ(OC_STACK_OK, OCSecure::discoverOwnedDevices(TIMEOUT, list));
117 TEST(DiscoveryTest, OwnedDevicesZeroTimeout)
120 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::discoverOwnedDevices(0, list));
123 TEST(OwnershipTest, OwnershipTransferNullCallback)
125 OCSecureResource device;
126 EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.doOwnershipTransfer(nullptr));
129 #ifdef MULTIPLE_OWNER
130 TEST(MOTOwnershipTest, MOTOwnershipTransferNullCallback)
132 OCSecureResource device;
133 EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.doMultipleOwnershipTransfer(nullptr));
136 TEST(selectMOTMethodTest, selectMOTMethodNullCallback)
138 OCSecureResource device;
139 const OicSecOxm_t stsecOxm = OIC_PRECONFIG_PIN;
140 EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.selectMOTMethod(stsecOxm, NULL));
143 TEST(changeMOTModeTest, changeMOTModeNullCallback)
145 OCSecureResource device;
146 const OicSecMomType_t momType = OIC_MULTIPLE_OWNER_ENABLE;
147 EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.changeMOTMode(momType, NULL));
150 TEST(addPreconfigPINTest, addPreconfigPINNullPin)
152 OCSecureResource device;
153 EXPECT_EQ(OC_STACK_INVALID_PARAM, device.addPreconfigPIN(NULL, 0));
156 TEST(provisionPreconfPinTest, provisionPreconfPinNullCallback)
158 OCSecureResource device;
159 const char *pin = "test";
160 size_t PinLength = 4;
161 EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionPreconfPin(pin, PinLength, NULL));
164 TEST(isMOTEnabledTest, isMOTEnabledWithoutDeviceInst)
166 OCSecureResource device;
167 EXPECT_EQ(false, device.isMOTEnabled());
170 TEST(isMOTSupportedTest, isMOTSupportedWithoutDeviceInst)
172 OCSecureResource device;
173 EXPECT_EQ(false, device.isMOTSupported());
176 TEST(getMOTMethodTest, getMOTMethodNullOxM)
178 OCSecureResource device;
179 EXPECT_EQ(OC_STACK_INVALID_PARAM, device.getMOTMethod(NULL));
183 TEST(DeviceInfoTest, DevInfoFromNetwork)
185 DeviceList_t owned, unowned;
186 EXPECT_EQ(OC_STACK_OK, OCSecure::getDevInfoFromNetwork(TIMEOUT,
190 TEST(SetDisplayPinCBTest, SetDisplayPinCBTestNullCB)
192 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setDisplayPinCB(nullptr));
195 TEST(ProvisionAclTest, ProvisionAclTestNullAcl)
197 OCSecureResource device;
198 EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionACL(nullptr, resultCallback));
201 TEST(ProvisionAclTest, ProvisionAclTestNullCallback)
203 OCSecureResource device;
204 OicSecAcl_t *acl = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
205 EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionACL(acl, nullptr));
209 TEST(ProvisionAclTest, ProvisionAclTestNullCallbackNUllAcl)
211 OCSecureResource device;
212 EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionACL(nullptr, nullptr));
215 TEST(ProvisionCredTest, ProvisionCredTestNullCallback)
217 OCSecureResource device, dev2;
219 EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionCredentials(cred, dev2, nullptr));
222 TEST(ProvisionPairwiseTest, ProvisionPairwiseTestNullCallback)
224 OCSecureResource device, dev2;
226 OicSecAcl_t *acl1 = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
227 OicSecAcl_t *acl2 = (OicSecAcl_t *)OICCalloc(1,sizeof(OicSecAcl_t));
228 EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionPairwiseDevices(cred, acl1,
229 dev2, acl2, nullptr));
234 TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullPconf)
236 OCSecureResource device;
237 EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionDirectPairing(nullptr, resultCallback));
240 TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullCallback)
242 OCSecureResource device;
243 OicSecPconf_t *pconf = (OicSecPconf_t *)OICCalloc(1,sizeof(OicSecPconf_t));
244 EXPECT_EQ(OC_STACK_INVALID_CALLBACK, device.provisionDirectPairing(pconf, nullptr));
248 TEST(ProvisionDirectPairingTest, ProvisionDirectPairingTestNullCallbackNUllPconf)
250 OCSecureResource device;
251 EXPECT_EQ(OC_STACK_INVALID_PARAM, device.provisionDirectPairing(nullptr, nullptr));
254 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
255 TEST(setDeviceIdSeed, NullParam)
257 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setDeviceIdSeed(NULL, 0));
260 TEST(setDeviceIdSeed, InvalidParam)
262 uint8_t seed[1024] = {0};
264 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setDeviceIdSeed(seed, 0));
265 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSecure::setDeviceIdSeed(seed, sizeof(seed)));
268 TEST(setDeviceIdSeed, ValidValue)
270 uint8_t seed[16] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
271 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
272 EXPECT_EQ(OC_STACK_OK, OCSecure::setDeviceIdSeed(seed, sizeof(seed)));
274 #endif // __WITH_DTLS__ || __WITH_TLS__