1 /******************************************************************
3 * Copyright 2017 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.
20 ******************************************************************/
21 #include "PMCsdkHelper.h"
22 #include "PMCsdkMotHelper.h"
23 #include "PMCsdkUtilityHelper.h"
27 class PMCsdkMotTest_btc: public ::testing::Test
30 OCProvisionDev_t *m_UnownList, *m_OwnList, *m_motEnabledDevList, *m_motOwnedDevList;
31 OicSecAcl_t *m_Acl, *m_Acl1, *m_Acl2;
32 PMCsdkHelper m_PMHelper;
33 PMCsdkMotHelper m_PMMotHelper;
38 CommonUtil::killApp(KILL_SERVERS);
39 CommonUtil::waitInSecond(DELAY_MEDIUM);
40 PMCsdkUtilityHelper::removeAllResFile();
41 CommonUtil::waitInSecond(DELAY_MEDIUM);
42 CommonUtil::copyFile(PRECONFIG_SERVER1_CBOR_BACKUP, PRECONFIG_SERVER1_CBOR);
43 CommonUtil::copyFile(PRECONFIG_SERVER2_CBOR_BACKUP, PRECONFIG_SERVER2_CBOR);
44 CommonUtil::copyFile(RANDOMPIN_SERVER_CBOR_BACKUP, RANDOMPIN_SERVER_CBOR);
45 CommonUtil::copyFile(CLIENT_CBOR_BACKUP, CLIENT_CBOR);
46 CommonUtil::copyFile(JUSTWORKS_SERVER7_CBOR_BACKUP, JUSTWORKS_SERVER7_CBOR);
47 CommonUtil::copyFile(PRECONFIG_SERVER2_CBOR_BACKUP, PRECONFIG_SERVER2_CBOR);
48 CommonUtil::copyFile(MOT_CLIENT_CBOR_BACKUP, MOT_CLIENT_CBOR);
49 m_motEnabledDevList = NULL;
50 m_motOwnedDevList = NULL;
55 virtual void TearDown()
57 CommonTestUtil::runCommonTCTearDownPart();
58 CommonUtil::killApp(KILL_SERVERS);
64 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
65 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
66 * @see OCStackResult OCInitPM(const char* dbPath)
67 * @objective Test OCDiscoverMultipleOwnerEnabledDevices positively with waittime = DISCOVERY_TIMEOUT
68 * @target OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
69 * @test_data waittime = DISCOVERY_TIMEOUT
70 * @pre_condition Start Mot Enabled justworks simulators
71 * @procedure 1. call OCRegisterPersistentStorageHandler
74 * 4. call OCDiscoverMultipleOwnerEnabledDevices
75 * @post_condition none
76 * @expected OCDiscoverMultipleOwnerEnabledDevices will return OC_STACK_OK
78 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
79 TEST_F(PMCsdkMotTest_btc, OCDiscoverMultipleOwnerEnabledDevices_RV_SRC_P)
81 CommonUtil::launchApp(JUSTWORKS_SERVER7);
83 if (!m_PMMotHelper.initMotClient())
85 SET_FAILURE(m_PMMotHelper.getFailureMessage());
89 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
90 &m_motEnabledDevList, OC_STACK_OK))
92 SET_FAILURE(m_PMMotHelper.getFailureMessage());
99 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
100 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
101 * @see OCStackResult OCInitPM(const char* dbPath)
102 * @objective Test OCDiscoverMultipleOwnerEnabledDevices positively with waittime = 1
103 * @target OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
104 * @test_data waittime = 1
105 * @pre_condition Start Mot Enabled justworks simulators
106 * @procedure 1. call OCRegisterPersistentStorageHandler
109 * 4. call OCDiscoverMultipleOwnerEnabledDevices
110 * @post_condition none
111 * @expected OCDiscoverMultipleOwnerEnabledDevices will return OC_STACK_OK
113 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
114 TEST_F(PMCsdkMotTest_btc, OCDiscoverMultipleOwnerEnabledDevices_LBV_P)
116 CommonUtil::launchApp(JUSTWORKS_SERVER7);
118 if (!m_PMMotHelper.initMotClient())
120 SET_FAILURE(m_PMMotHelper.getFailureMessage());
124 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT_ONE,
125 &m_motEnabledDevList, OC_STACK_OK))
127 SET_FAILURE(m_PMMotHelper.getFailureMessage());
134 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
135 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
136 * @see OCStackResult OCInitPM(const char* dbPath)
137 * @objective Test OCDiscoverMultipleOwnerEnabledDevices negatively with waittime = 0
138 * @target OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
139 * @test_data waittime = 0
140 * @pre_condition Start Mot Enabled justworks simulators
141 * @procedure 1. call OCRegisterPersistentStorageHandler
144 * 4. call OCDiscoverMultipleOwnerEnabledDevices
145 * @post_condition none
146 * @expected OCDiscoverMultipleOwnerEnabledDevices will return OC_STACK_INVALID_PARAM
148 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
149 TEST_F(PMCsdkMotTest_btc, OCDiscoverMultipleOwnerEnabledDevices_LOBV_N)
151 CommonUtil::launchApp(JUSTWORKS_SERVER7);
153 if (!m_PMMotHelper.initMotClient())
155 SET_FAILURE(m_PMMotHelper.getFailureMessage());
159 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT_ZERO,
160 &m_motEnabledDevList, OC_STACK_INVALID_PARAM))
162 SET_FAILURE(m_PMMotHelper.getFailureMessage());
169 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
170 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
171 * @see OCStackResult OCInitPM(const char* dbPath)
172 * @objective Test OCDiscoverMultipleOwnerEnabledDevices negatively with ppList = NULL
173 * @target OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
174 * @test_data ppList = NULL
175 * @pre_condition Start Mot Enabled justworks simulators
176 * @procedure 1. call OCRegisterPersistentStorageHandler
179 * 4. call OCDiscoverMultipleOwnerEnabledDevices
180 * @post_condition none
181 * @expected OCDiscoverMultipleOwnerEnabledDevices will return OC_STACK_INVALID_PARAM
183 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
184 TEST_F(PMCsdkMotTest_btc, OCDiscoverMultipleOwnerEnabledDevicesDevlist_NV_N)
186 CommonUtil::launchApp(JUSTWORKS_SERVER7);
188 if (!m_PMMotHelper.initMotClient())
190 SET_FAILURE(m_PMMotHelper.getFailureMessage());
194 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT_ONE,
195 NULL, OC_STACK_INVALID_PARAM))
197 SET_FAILURE(m_PMMotHelper.getFailureMessage());
204 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
205 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
206 * @see OCStackResult OCInitPM(const char* dbPath)
207 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
208 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
209 * @see OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
210 * @objective Test OCDiscoverMultipleOwnerEnabledSingleDevice positively with waittime = DISCOVERY_TIMEOUT
211 * @target OCStackResult OCDiscoverMultipleOwnerEnabledSingleDevice(unsigned short timeoutSeconds, const OicUuid_t *deviceID, OCProvisionDev_t **ppFoundDevice)
212 * @test_data waittime = DISCOVERY_TIMEOUT
213 * @pre_condition Start Mot Enabled justworks simulators
214 * @procedure 1. call OCRegisterPersistentStorageHandler
217 * 4. call OCDiscoverUnownedDevices
218 * 5. call OCDoOwnershipTransfer
219 * 6. call OCDiscoverOwnedDevices
220 * 7. call OCChangeMOTMode
221 * 8. call OCDiscoverMultipleOwnerEnabledSingleDevice
222 * @post_condition none
223 * @expected OCDiscoverMultipleOwnerEnabledSingleDevice will return OC_STACK_OK
225 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
226 TEST_F(PMCsdkMotTest_btc, OCDiscoverMultipleOwnerEnabledSingleDevice_RV_SRC_P)
228 CommonUtil::launchApp(PRECONFIG_SERVER1);
229 CommonUtil::launchApp(PRECONFIG_SERVER2);
231 if (!m_PMHelper.initProvisionClient())
233 SET_FAILURE(m_PMHelper.getFailureMessage());
237 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
238 &m_UnownList, OC_STACK_OK))
240 SET_FAILURE(m_PMHelper.getFailureMessage());
244 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
245 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
247 SET_FAILURE(m_PMHelper.getFailureMessage());
251 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
253 SET_FAILURE(m_PMHelper.getFailureMessage());
257 OCProvisionDev_t* targetOwnedDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
259 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetOwnedDev, OIC_MULTIPLE_OWNER_ENABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
261 SET_FAILURE(m_PMMotHelper.getFailureMessage());
265 OicUuid_t deviceUuid = targetOwnedDev->doxm->deviceID;
267 if (!m_PMMotHelper.discoverMultipleOwnerEnabledSingleDevice(DISCOVERY_TIMEOUT,&deviceUuid,
268 &m_motEnabledDevList, OC_STACK_OK))
270 SET_FAILURE(m_PMMotHelper.getFailureMessage());
277 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
278 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
279 * @see OCStackResult OCInitPM(const char* dbPath)
280 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
281 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
282 * @see OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
283 * @objective Test OCDiscoverMultipleOwnerEnabledSingleDevice positively with waittime = DISCOVERY_TIMEOUT_ONE
284 * @target OCStackResult OCDiscoverMultipleOwnerEnabledSingleDevice(unsigned short timeoutSeconds, const OicUuid_t *deviceID, OCProvisionDev_t **ppFoundDevice)
285 * @test_data waittime = DISCOVERY_TIMEOUT_ONE
286 * @pre_condition Start Mot Enabled justworks simulators
287 * @procedure 1. call OCRegisterPersistentStorageHandler
290 * 4. call OCDiscoverUnownedDevices
291 * 5. call OCDoOwnershipTransfer
292 * 6. call OCDiscoverOwnedDevices
293 * 7. call OCChangeMOTMode
294 * 8. call OCDiscoverMultipleOwnerEnabledSingleDevice
295 * @post_condition none
296 * @expected OCDiscoverMultipleOwnerEnabledSingleDevice will return OC_STACK_OK
298 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
299 TEST_F(PMCsdkMotTest_btc, OCDiscoverMultipleOwnerEnabledSingleDevice_LBV_P)
301 CommonUtil::launchApp(PRECONFIG_SERVER1);
302 CommonUtil::launchApp(PRECONFIG_SERVER2);
304 if (!m_PMHelper.initProvisionClient())
306 SET_FAILURE(m_PMHelper.getFailureMessage());
310 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
311 &m_UnownList, OC_STACK_OK))
313 SET_FAILURE(m_PMHelper.getFailureMessage());
317 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
318 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
320 SET_FAILURE(m_PMHelper.getFailureMessage());
324 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
326 SET_FAILURE(m_PMHelper.getFailureMessage());
330 OCProvisionDev_t* targetOwnedDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
332 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetOwnedDev, OIC_MULTIPLE_OWNER_ENABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
334 SET_FAILURE(m_PMMotHelper.getFailureMessage());
338 OicUuid_t deviceUuid = targetOwnedDev->doxm->deviceID;
340 if (!m_PMMotHelper.discoverMultipleOwnerEnabledSingleDevice(DISCOVERY_TIMEOUT_ONE, &deviceUuid,
341 &m_motEnabledDevList, OC_STACK_OK))
343 SET_FAILURE(m_PMMotHelper.getFailureMessage());
350 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
351 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
352 * @see OCStackResult OCInitPM(const char* dbPath)
353 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
354 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
355 * @see OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
356 * @objective Test OCDiscoverMultipleOwnerEnabledSingleDevice negatively with waittime = DISCOVERY_TIMEOUT_ZERO
357 * @target OCStackResult OCDiscoverMultipleOwnerEnabledSingleDevice(unsigned short timeoutSeconds, const OicUuid_t *deviceID, OCProvisionDev_t **ppFoundDevice)
358 * @test_data waittime = DISCOVERY_TIMEOUT_ZERO
359 * @pre_condition Start Mot Enabled justworks simulators
360 * @procedure 1. call OCRegisterPersistentStorageHandler
363 * 4. call OCDiscoverUnownedDevices
364 * 5. call OCDoOwnershipTransfer
365 * 6. call OCDiscoverOwnedDevices
366 * 7. call OCChangeMOTMode
367 * 8. call OCDiscoverMultipleOwnerEnabledSingleDevice
368 * @post_condition none
369 * @expected OCDiscoverMultipleOwnerEnabledSingleDevice will return OC_STACK_INVALID_PARAM
371 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
372 TEST_F(PMCsdkMotTest_btc, OCDiscoverMultipleOwnerEnabledSingleDevice_LOBV_N)
374 CommonUtil::launchApp(PRECONFIG_SERVER1);
375 CommonUtil::launchApp(PRECONFIG_SERVER2);
377 if (!m_PMHelper.initProvisionClient())
379 SET_FAILURE(m_PMHelper.getFailureMessage());
383 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
384 &m_UnownList, OC_STACK_OK))
386 SET_FAILURE(m_PMHelper.getFailureMessage());
390 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
391 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
393 SET_FAILURE(m_PMHelper.getFailureMessage());
397 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
399 SET_FAILURE(m_PMHelper.getFailureMessage());
403 OCProvisionDev_t* targetOwnedDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
405 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetOwnedDev, OIC_MULTIPLE_OWNER_ENABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
407 SET_FAILURE(m_PMMotHelper.getFailureMessage());
411 OicUuid_t deviceUuid = targetOwnedDev->doxm->deviceID;
413 if (!m_PMMotHelper.discoverMultipleOwnerEnabledSingleDevice(DISCOVERY_TIMEOUT_ZERO, &deviceUuid,
414 &m_motEnabledDevList, OC_STACK_INVALID_PARAM))
416 SET_FAILURE(m_PMMotHelper.getFailureMessage());
423 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
424 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
425 * @see OCStackResult OCInitPM(const char* dbPath)
426 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
427 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
428 * @see OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
429 * @objective Test OCDiscoverMultipleOwnerEnabledSingleDevice negatively with deviceID = NULL
430 * @target OCStackResult OCDiscoverMultipleOwnerEnabledSingleDevice(unsigned short timeoutSeconds, const OicUuid_t *deviceID, OCProvisionDev_t **ppFoundDevice)
431 * @test_data deviceID = NULL
432 * @pre_condition Start Mot Enabled justworks simulators
433 * @procedure 1. call OCRegisterPersistentStorageHandler
436 * 4. call OCDiscoverUnownedDevices
437 * 5. call OCDoOwnershipTransfer
438 * 6. call OCDiscoverOwnedDevices
439 * 7. call OCChangeMOTMode
440 * 8. call OCDiscoverMultipleOwnerEnabledSingleDevice
441 * @post_condition none
442 * @expected OCDiscoverMultipleOwnerEnabledSingleDevice will return OC_STACK_INVALID_PARAM
444 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
445 TEST_F(PMCsdkMotTest_btc, OCDiscoverMultipleOwnerEnabledSingleDeviceDeviceID_NV_N)
447 CommonUtil::launchApp(PRECONFIG_SERVER1);
448 CommonUtil::launchApp(PRECONFIG_SERVER2);
450 if (!m_PMHelper.initProvisionClient())
452 SET_FAILURE(m_PMHelper.getFailureMessage());
456 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
457 &m_UnownList, OC_STACK_OK))
459 SET_FAILURE(m_PMHelper.getFailureMessage());
463 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
464 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
466 SET_FAILURE(m_PMHelper.getFailureMessage());
470 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
472 SET_FAILURE(m_PMHelper.getFailureMessage());
476 OCProvisionDev_t* targetOwnedDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
478 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetOwnedDev, OIC_MULTIPLE_OWNER_ENABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
480 SET_FAILURE(m_PMMotHelper.getFailureMessage());
484 if (!m_PMMotHelper.discoverMultipleOwnerEnabledSingleDevice(DISCOVERY_TIMEOUT, NULL,
485 &m_motEnabledDevList, OC_STACK_INVALID_PARAM))
487 SET_FAILURE(m_PMMotHelper.getFailureMessage());
494 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
495 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
496 * @see OCStackResult OCInitPM(const char* dbPath)
497 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
498 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
499 * @see OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
500 * @objective Test OCDiscoverMultipleOwnerEnabledSingleDevice negatively with ppFoundDevice = NULL
501 * @target OCStackResult OCDiscoverMultipleOwnerEnabledSingleDevice(unsigned short timeoutSeconds, const OicUuid_t *deviceID, OCProvisionDev_t **ppFoundDevice)
502 * @test_data ppFoundDevice = NULL
503 * @pre_condition Start Mot Enabled justworks simulators
504 * @procedure 1. call OCRegisterPersistentStorageHandler
507 * 4. call OCDiscoverUnownedDevices
508 * 5. call OCDoOwnershipTransfer
509 * 6. call OCDiscoverOwnedDevices
510 * 7. call OCChangeMOTMode
511 * 8. call OCDiscoverMultipleOwnerEnabledSingleDevice
512 * @post_condition none
513 * @expected OCDiscoverMultipleOwnerEnabledSingleDevice will return OC_STACK_INVALID_PARAM
515 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
516 TEST_F(PMCsdkMotTest_btc, OCDiscoverMultipleOwnerEnabledSingleDevicePpFoundDevice_NV_N)
518 CommonUtil::launchApp(PRECONFIG_SERVER1);
519 CommonUtil::launchApp(PRECONFIG_SERVER2);
521 if (!m_PMHelper.initProvisionClient())
523 SET_FAILURE(m_PMHelper.getFailureMessage());
527 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
528 &m_UnownList, OC_STACK_OK))
530 SET_FAILURE(m_PMHelper.getFailureMessage());
534 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
535 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
537 SET_FAILURE(m_PMHelper.getFailureMessage());
541 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
543 SET_FAILURE(m_PMHelper.getFailureMessage());
547 OCProvisionDev_t* targetOwnedDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
549 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetOwnedDev, OIC_MULTIPLE_OWNER_ENABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
551 SET_FAILURE(m_PMMotHelper.getFailureMessage());
555 OicUuid_t deviceUuid = targetOwnedDev->doxm->deviceID;
557 if (!m_PMMotHelper.discoverMultipleOwnerEnabledSingleDevice(DISCOVERY_TIMEOUT, &deviceUuid,
558 NULL, OC_STACK_INVALID_PARAM))
560 SET_FAILURE(m_PMMotHelper.getFailureMessage());
567 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
568 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
569 * @see OCStackResult OCInitPM(const char* dbPath)
570 * @objective Test OCDiscoverMultipleOwnedDevices positively with waittime = DISCOVERY_TIMEOUT
571 * @target OCStackResult OCDiscoverMultipleOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
572 * @test_data waittime = DISCOVERY_TIMEOUT
573 * @pre_condition Start Mot Enabled justworks simulators
574 * @procedure 1. call OCRegisterPersistentStorageHandler
577 * 4. call OCDiscoverMultipleOwnedDevices
578 * @post_condition none
579 * @expected OCDiscoverMultipleOwnedDevices will return OC_STACK_OK
581 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
582 TEST_F(PMCsdkMotTest_btc, OCDiscoverMultipleOwnedDevices_RV_SRC_P)
584 CommonUtil::launchApp(JUSTWORKS_SERVER7);
586 if (!m_PMMotHelper.initMotClient())
588 SET_FAILURE(m_PMMotHelper.getFailureMessage());
592 if (!m_PMMotHelper.discoverMultipleOwnedDevices(DISCOVERY_TIMEOUT,
593 &m_motEnabledDevList, OC_STACK_OK))
595 SET_FAILURE(m_PMMotHelper.getFailureMessage());
602 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
603 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
604 * @see OCStackResult OCInitPM(const char* dbPath)
605 * @objective Test OCDiscoverMultipleOwnedDevices positively with waittime = 1
606 * @target OCStackResult OCDiscoverMultipleOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
607 * @test_data waittime = 1
608 * @pre_condition Start Mot Enabled justworks simulators
609 * @procedure 1. call OCRegisterPersistentStorageHandler
612 * 4. call OCDiscoverMultipleOwnedDevices
613 * @post_condition none
614 * @expected OCDiscoverMultipleOwnedDevices will return OC_STACK_OK
616 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
617 TEST_F(PMCsdkMotTest_btc, OCDiscoverMultipleOwnedDevices_LBV_P)
619 CommonUtil::launchApp(JUSTWORKS_SERVER7);
621 if (!m_PMMotHelper.initMotClient())
623 SET_FAILURE(m_PMMotHelper.getFailureMessage());
627 if (!m_PMMotHelper.discoverMultipleOwnedDevices(DISCOVERY_TIMEOUT_ONE,
628 &m_motEnabledDevList, OC_STACK_OK))
630 SET_FAILURE(m_PMMotHelper.getFailureMessage());
637 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
638 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
639 * @see OCStackResult OCInitPM(const char* dbPath)
640 * @objective Test OCDiscoverMultipleOwnedDevices negatively with waittime = 0
641 * @target OCStackResult OCDiscoverMultipleOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
642 * @test_data waittime = 0
643 * @pre_condition Start Mot Enabled justworks simulators
644 * @procedure 1. call OCRegisterPersistentStorageHandler
647 * 4. call OCDiscoverMultipleOwnedDevices
648 * @post_condition none
649 * @expected OCDiscoverMultipleOwnedDevices will return OC_STACK_INVALID_PARAM
651 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
652 TEST_F(PMCsdkMotTest_btc, OCDiscoverMultipleOwnedDevices_LOBV_N)
654 CommonUtil::launchApp(JUSTWORKS_SERVER7);
656 if (!m_PMMotHelper.initMotClient())
658 SET_FAILURE(m_PMMotHelper.getFailureMessage());
662 if (!m_PMMotHelper.discoverMultipleOwnedDevices(DISCOVERY_TIMEOUT_ZERO,
663 &m_motEnabledDevList, OC_STACK_INVALID_PARAM))
665 SET_FAILURE(m_PMMotHelper.getFailureMessage());
672 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
673 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
674 * @see OCStackResult OCInitPM(const char* dbPath)
675 * @objective Test OCDiscoverMultipleOwnedDevices negatively with ppList = NULL
676 * @target OCStackResult OCDiscoverMultipleOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
677 * @test_data ppList = NULL
678 * @pre_condition Start Mot Enabled justworks simulators
679 * @procedure 1. call OCRegisterPersistentStorageHandler
682 * 4. call OCDiscoverMultipleOwnedDevices
683 * @post_condition none
684 * @expected OCDiscoverMultipleOwnedDevices will return OC_STACK_INVALID_PARAM
686 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
687 TEST_F(PMCsdkMotTest_btc, OCDiscoverMultipleOwnedDevicesDevlist_NV_N)
689 CommonUtil::launchApp(JUSTWORKS_SERVER7);
691 if (!m_PMMotHelper.initMotClient())
693 SET_FAILURE(m_PMMotHelper.getFailureMessage());
697 if (!m_PMMotHelper.discoverMultipleOwnedDevices(DISCOVERY_TIMEOUT_ONE,
698 NULL, OC_STACK_INVALID_PARAM))
700 SET_FAILURE(m_PMMotHelper.getFailureMessage());
707 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
708 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
709 * @see OCStackResult OCInitPM(const char* dbPath)
710 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
711 * @objective Test OCAddPreconfigPin positively with regular data
712 * @target OCStackResult OCAddPreconfigPin(const OCProvisionDev_t *targetDeviceInfo, const char* preconfPIN, size_t preconfPINLen)
713 * @test_data regular data for the API
714 * @pre_condition Start Mot Enabled justworks simulators
715 * @procedure 1. call OCRegisterPersistentStorageHandler
718 * 4. call OCDiscoverMultipleOwnerEnabledDevices
719 * 5. call OCAddPreconfigPin
720 * @post_condition none
721 * @expected OCAddPreconfigPin will return OC_STACK_OK
723 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
724 TEST_F(PMCsdkMotTest_btc, OCAddPreconfigPin_RV_SRC_P)
726 CommonUtil::launchApp(JUSTWORKS_SERVER7);
728 if (!m_PMMotHelper.initMotClient())
730 SET_FAILURE(m_PMMotHelper.getFailureMessage());
734 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
735 &m_motEnabledDevList, OC_STACK_OK))
737 SET_FAILURE(m_PMMotHelper.getFailureMessage());
741 OCProvisionDev_t* targetDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, 1);
743 if (!m_PMMotHelper.addPreconfigPIN(targetDev, MOT_DEFAULT_PRE_CONFIG_PIN, OXM_PRECONFIG_PIN_MAX_SIZE, OC_STACK_OK))
745 SET_FAILURE(m_PMMotHelper.getFailureMessage());
752 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
753 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
754 * @see OCStackResult OCInitPM(const char* dbPath)
755 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
756 * @objective Test OCAddPreconfigPin negatively with targetDeviceInfo=NULL
757 * @target OCStackResult OCAddPreconfigPin(const OCProvisionDev_t *targetDeviceInfo, const char* preconfPIN, size_t preconfPINLen)
758 * @test_data targetDeviceInfo=NULL
759 * @pre_condition Start Mot Enabled justworks simulators
760 * @procedure 1. call OCRegisterPersistentStorageHandler
763 * 4. call OCDiscoverMultipleOwnerEnabledDevices
764 * 5. call OCAddPreconfigPin
765 * @post_condition none
766 * @expected OCAddPreconfigPin will return OC_STACK_INVALID_PARAM
768 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
769 TEST_F(PMCsdkMotTest_btc, OCAddPreconfigPinTargetDeviceInfo_NV_N)
771 CommonUtil::launchApp(JUSTWORKS_SERVER7);
773 if (!m_PMMotHelper.initMotClient())
775 SET_FAILURE(m_PMMotHelper.getFailureMessage());
779 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
780 &m_motEnabledDevList, OC_STACK_OK))
782 SET_FAILURE(m_PMMotHelper.getFailureMessage());
786 if (!m_PMMotHelper.addPreconfigPIN(NULL, MOT_DEFAULT_PRE_CONFIG_PIN, OXM_PRECONFIG_PIN_MAX_SIZE, OC_STACK_INVALID_PARAM))
788 SET_FAILURE(m_PMMotHelper.getFailureMessage());
795 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
796 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
797 * @see OCStackResult OCInitPM(const char* dbPath)
798 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
799 * @objective Test OCAddPreconfigPin negatively with preconfPIN=NULL
800 * @target OCStackResult OCAddPreconfigPin(const OCProvisionDev_t *targetDeviceInfo, const char* preconfPIN, size_t preconfPINLen)
801 * @test_data preconfPIN=NULL
802 * @pre_condition Start Mot Enabled justworks simulators
803 * @procedure 1. call OCRegisterPersistentStorageHandler
806 * 4. call OCDiscoverMultipleOwnerEnabledDevices
807 * 5. call OCAddPreconfigPin
808 * @post_condition none
809 * @expected OCAddPreconfigPin will return OC_STACK_INVALID_PARAM
811 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
812 TEST_F(PMCsdkMotTest_btc, OCAddPreconfigPinPreconfPIN_NV_N)
814 CommonUtil::launchApp(JUSTWORKS_SERVER7);
816 if (!m_PMMotHelper.initMotClient())
818 SET_FAILURE(m_PMMotHelper.getFailureMessage());
822 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
823 &m_motEnabledDevList, OC_STACK_OK))
825 SET_FAILURE(m_PMMotHelper.getFailureMessage());
829 OCProvisionDev_t* targetDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, 1);
831 if (!m_PMMotHelper.addPreconfigPIN(targetDev, NULL, OXM_PRECONFIG_PIN_MAX_SIZE, OC_STACK_INVALID_PARAM))
833 SET_FAILURE(m_PMMotHelper.getFailureMessage());
840 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
841 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
842 * @see OCStackResult OCInitPM(const char* dbPath)
843 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
844 * @objective Test OCAddPreconfigPin negatively with preconfPINLen=MOT_PRECONFIG_PIN_ZERO_SIZE
845 * @target OCStackResult OCAddPreconfigPin(const OCProvisionDev_t *targetDeviceInfo, const char* preconfPIN, size_t preconfPINLen)
846 * @test_data preconfPINLen=MOT_PRECONFIG_PIN_ZERO_SIZE
847 * @pre_condition Start Mot Enabled justworks simulators
848 * @procedure 1. call OCRegisterPersistentStorageHandler
851 * 4. call OCDiscoverMultipleOwnerEnabledDevices
852 * 5. call OCAddPreconfigPin
853 * @post_condition none
854 * @expected OCAddPreconfigPin will return OC_STACK_INVALID_PARAM
856 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
857 TEST_F(PMCsdkMotTest_btc, OCAddPreconfigPinPreconfPINLen_LOBV_N)
859 CommonUtil::launchApp(JUSTWORKS_SERVER7);
861 if (!m_PMMotHelper.initMotClient())
863 SET_FAILURE(m_PMMotHelper.getFailureMessage());
867 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
868 &m_motEnabledDevList, OC_STACK_OK))
870 SET_FAILURE(m_PMMotHelper.getFailureMessage());
874 OCProvisionDev_t* targetDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, 1);
876 if (!m_PMMotHelper.addPreconfigPIN(targetDev, MOT_DEFAULT_PRE_CONFIG_PIN, MOT_PRECONFIG_PIN_ZERO_SIZE, OC_STACK_INVALID_PARAM))
878 SET_FAILURE(m_PMMotHelper.getFailureMessage());
885 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
886 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
887 * @see OCStackResult OCInitPM(const char* dbPath)
888 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
889 * @see OCStackResult OCAddPreconfigPin(const OCProvisionDev_t *targetDeviceInfo, const char* preconfPIN, size_t preconfPINLen)
890 * @objective Test OCAddPreconfigPin positively with regular data
891 * @target OCStackResult OCDoMultipleOwnershipTransfer(void* ctx,OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
892 * @test_data regular data for the API
893 * @pre_condition Start Mot Enabled justworks simulators
894 * @procedure 1. call OCRegisterPersistentStorageHandler
897 * 4. call OCDiscoverMultipleOwnerEnabledDevices
898 * 5. call OCAddPreconfigPin
899 * 6. call OCDoMultipleOwnershipTransfer
900 * @post_condition none
901 * @expected OCDoMultipleOwnershipTransfer will return OC_STACK_OK
903 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
904 TEST_F(PMCsdkMotTest_btc, DoMultipleOwnershipTransfer_RV_SRC_P)
906 CommonUtil::launchApp(JUSTWORKS_SERVER7);
908 if (!m_PMMotHelper.initMotClient())
910 SET_FAILURE(m_PMMotHelper.getFailureMessage());
914 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
915 &m_motEnabledDevList, OC_STACK_OK))
917 SET_FAILURE(m_PMMotHelper.getFailureMessage());
921 OCProvisionDev_t* targetDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, DEVICE_INDEX_ONE);
923 if (!m_PMMotHelper.addPreconfigPIN(targetDev, MOT_DEFAULT_PRE_CONFIG_PIN, OXM_PRECONFIG_PIN_MAX_SIZE, OC_STACK_OK))
925 SET_FAILURE(m_PMMotHelper.getFailureMessage());
929 if (!m_PMMotHelper.doMultipleOwnershipTransfer((void*)MOT_CTX, m_motEnabledDevList,
930 PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
932 SET_FAILURE(m_PMMotHelper.getFailureMessage());
939 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
940 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
941 * @see OCStackResult OCInitPM(const char* dbPath)
942 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
943 * @see OCStackResult OCAddPreconfigPin(const OCProvisionDev_t *targetDeviceInfo, const char* preconfPIN, size_t preconfPINLen)
944 * @objective Test OCAddPreconfigPin negatively with resultCallback as NULL
945 * @target OCStackResult OCDoMultipleOwnershipTransfer(void* ctx,OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
946 * @test_data resultCallback = NULL
947 * @pre_condition Start Mot Enabled justworks simulators
948 * @procedure 1. call OCRegisterPersistentStorageHandler
951 * 4. call OCDiscoverMultipleOwnerEnabledDevices
952 * 5. call OCAddPreconfigPin
953 * 6. call OCDoMultipleOwnershipTransfer
954 * @post_condition none
955 * @expected OCDoMultipleOwnershipTransfer will return OC_STACK_INVALID_CALLBACK
957 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
958 TEST_F(PMCsdkMotTest_btc, OCDoMultipleOwnershipTransferCB_NV_N)
960 CommonUtil::launchApp(JUSTWORKS_SERVER7);
962 if (!m_PMMotHelper.initMotClient())
964 SET_FAILURE(m_PMMotHelper.getFailureMessage());
968 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
969 &m_motEnabledDevList, OC_STACK_OK))
971 SET_FAILURE(m_PMMotHelper.getFailureMessage());
975 OCProvisionDev_t* targetDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, DEVICE_INDEX_ONE);
977 if (!m_PMMotHelper.addPreconfigPIN(targetDev, MOT_DEFAULT_PRE_CONFIG_PIN, OXM_PRECONFIG_PIN_MAX_SIZE, OC_STACK_OK))
979 SET_FAILURE(m_PMMotHelper.getFailureMessage());
983 if (!m_PMMotHelper.doMultipleOwnershipTransfer((void*)MOT_CTX, m_motEnabledDevList,
984 NULL, OC_STACK_INVALID_CALLBACK))
986 SET_FAILURE(m_PMMotHelper.getFailureMessage());
993 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
994 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
995 * @see OCStackResult OCInitPM(const char* dbPath)
996 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
997 * @see OCStackResult OCAddPreconfigPin(const OCProvisionDev_t *targetDeviceInfo, const char* preconfPIN, size_t preconfPINLen)
998 * @objective Test OCAddPreconfigPin negatively with targetDevices as NULL
999 * @target OCStackResult OCDoMultipleOwnershipTransfer(void* ctx,OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
1000 * @test_data targetDevices = NULL
1001 * @pre_condition Start Mot Enabled justworks simulators
1002 * @procedure 1. call OCRegisterPersistentStorageHandler
1005 * 4. call OCDiscoverMultipleOwnerEnabledDevices
1006 * 5. call OCAddPreconfigPin
1007 * 6. call OCDoMultipleOwnershipTransfer
1008 * @post_condition none
1009 * @expected OCDoMultipleOwnershipTransfer will return OC_STACK_INVALID_PARAM
1011 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
1012 TEST_F(PMCsdkMotTest_btc, OCDoMultipleOwnershipTransfer_NV_N)
1014 CommonUtil::launchApp(JUSTWORKS_SERVER7);
1016 if (!m_PMMotHelper.initMotClient())
1018 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1022 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
1023 &m_motEnabledDevList, OC_STACK_OK))
1025 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1029 OCProvisionDev_t* targetDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, DEVICE_INDEX_ONE);
1031 if (!m_PMMotHelper.addPreconfigPIN(targetDev, MOT_DEFAULT_PRE_CONFIG_PIN, OXM_PRECONFIG_PIN_MAX_SIZE, OC_STACK_OK))
1033 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1037 if (!m_PMMotHelper.doMultipleOwnershipTransfer((void*)MOT_CTX, NULL,
1038 PMCsdkCallbackHelper::provisionPostCB, OC_STACK_INVALID_PARAM))
1040 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1047 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
1048 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
1049 * @see OCStackResult OCInitPM(const char* dbPath)
1050 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
1051 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1052 * @objective Test OCChangeMOTMode positively with regular data
1053 * @target OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
1054 * @test_data regular data for the target API
1055 * @pre_condition Start two justworks simulators
1056 * @procedure 1. call OCRegisterPersistentStorageHandler
1059 * 4. call OCDiscoverUnownedDevices
1060 * 5. call OCDoOwnershipTransfer
1061 * 6. call OCDiscoverOwnedDevices
1062 * 7. call OCChangeMOTMode
1063 * @post_condition None
1064 * @expected OCChangeMOTMode will return OC_STACK_OK
1066 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
1067 TEST_F(PMCsdkMotTest_btc, OCChangeMOTMode_RV_SRC_P)
1069 CommonUtil::launchApp(PRECONFIG_SERVER1);
1070 CommonUtil::launchApp(PRECONFIG_SERVER2);
1071 CommonUtil::waitInSecond(DELAY_LONG);
1073 if (!m_PMHelper.initProvisionClient())
1075 SET_FAILURE(m_PMHelper.getFailureMessage());
1079 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
1080 &m_UnownList, OC_STACK_OK))
1082 SET_FAILURE(m_PMHelper.getFailureMessage());
1086 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
1087 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
1089 SET_FAILURE(m_PMHelper.getFailureMessage());
1093 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
1095 SET_FAILURE(m_PMHelper.getFailureMessage());
1099 OCProvisionDev_t* targetDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
1101 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetDev, OIC_MULTIPLE_OWNER_ENABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
1103 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1110 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
1111 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
1112 * @see OCStackResult OCInitPM(const char* dbPath)
1113 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
1114 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1115 * @objective Test OCChangeMOTMode positively with momType = OIC_MULTIPLE_OWNER_DISABLE
1116 * @target OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
1117 * @test_data momType = OIC_MULTIPLE_OWNER_DISABLE
1118 * @pre_condition Start two justworks simulators
1119 * @procedure 1. call OCRegisterPersistentStorageHandler
1122 * 4. call OCDiscoverUnownedDevices
1123 * 5. call OCDoOwnershipTransfer
1124 * 6. call OCDiscoverOwnedDevices
1125 * 7. call OCChangeMOTMode
1126 * @post_condition None
1127 * @expected OCChangeMOTMode will return OC_STACK_OK
1129 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
1130 TEST_F(PMCsdkMotTest_btc, OCChangeMOTMode_CLU_P)
1132 CommonUtil::launchApp(PRECONFIG_SERVER1);
1133 CommonUtil::launchApp(PRECONFIG_SERVER2);
1135 if (!m_PMHelper.initProvisionClient())
1137 SET_FAILURE(m_PMHelper.getFailureMessage());
1141 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
1142 &m_UnownList, OC_STACK_OK))
1144 SET_FAILURE(m_PMHelper.getFailureMessage());
1148 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
1149 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
1151 SET_FAILURE(m_PMHelper.getFailureMessage());
1155 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
1157 SET_FAILURE(m_PMHelper.getFailureMessage());
1161 OCProvisionDev_t* targetDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
1163 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetDev, OIC_MULTIPLE_OWNER_DISABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
1165 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1172 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
1173 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
1174 * @see OCStackResult OCInitPM(const char* dbPath)
1175 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
1176 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1177 * @objective Test OCChangeMOTMode negatively with momType greater Upper Boundary Value
1178 * @target OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
1179 * @test_data momType greater Upper Boundary Value
1180 * @pre_condition Start two justworks simulators
1181 * @procedure 1. call OCRegisterPersistentStorageHandler
1184 * 4. call OCDiscoverUnownedDevices
1185 * 5. call OCDoOwnershipTransfer
1186 * 6. call OCDiscoverOwnedDevices
1187 * 7. call OCChangeMOTMode
1188 * @post_condition None
1189 * @expected OCChangeMOTMode will return OC_STACK_INVALID_PARAM
1191 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
1192 TEST_F(PMCsdkMotTest_btc, OCChangeMOTMode_CLU_UOBV_N)
1194 CommonUtil::launchApp(PRECONFIG_SERVER1);
1195 CommonUtil::launchApp(PRECONFIG_SERVER2);
1197 if (!m_PMHelper.initProvisionClient())
1199 SET_FAILURE(m_PMHelper.getFailureMessage());
1203 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
1204 &m_UnownList, OC_STACK_OK))
1206 SET_FAILURE(m_PMHelper.getFailureMessage());
1210 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
1211 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
1213 SET_FAILURE(m_PMHelper.getFailureMessage());
1217 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
1219 SET_FAILURE(m_PMHelper.getFailureMessage());
1223 OCProvisionDev_t* targetDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
1225 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetDev, (const OicSecMomType_t) OIC_MULTIPLE_OWNER_UOBV, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_INVALID_PARAM))
1227 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1234 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
1235 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
1236 * @see OCStackResult OCInitPM(const char* dbPath)
1237 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
1238 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1239 * @objective Test OCChangeMOTMode negatively with resultCallback = NULL
1240 * @target OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
1241 * @test_data resultCallback = NULL
1242 * @pre_condition Start two justworks simulators
1243 * @procedure 1. call OCRegisterPersistentStorageHandler
1246 * 4. call OCDiscoverUnownedDevices
1247 * 5. call OCDoOwnershipTransfer
1248 * 6. call OCDiscoverOwnedDevices
1249 * 7. call OCChangeMOTMode
1250 * @post_condition None
1251 * @expected OCChangeMOTMode will return OC_STACK_INVALID_CALLBACK
1253 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
1254 TEST_F(PMCsdkMotTest_btc, OCChangeMOTModeCb_NV_N)
1256 CommonUtil::launchApp(PRECONFIG_SERVER1);
1257 CommonUtil::launchApp(PRECONFIG_SERVER2);
1259 if (!m_PMHelper.initProvisionClient())
1261 SET_FAILURE(m_PMHelper.getFailureMessage());
1265 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
1266 &m_UnownList, OC_STACK_OK))
1268 SET_FAILURE(m_PMHelper.getFailureMessage());
1272 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
1273 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
1275 SET_FAILURE(m_PMHelper.getFailureMessage());
1279 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
1281 SET_FAILURE(m_PMHelper.getFailureMessage());
1285 OCProvisionDev_t* targetDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
1287 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetDev, OIC_MULTIPLE_OWNER_ENABLE, NULL, OC_STACK_INVALID_CALLBACK))
1289 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1296 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
1297 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
1298 * @see OCStackResult OCInitPM(const char* dbPath)
1299 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
1300 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1301 * @objective Test OCChangeMOTMode negatively with targetDeviceInfo = NULL
1302 * @target OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
1303 * @test_data targetDeviceInfo = NULL
1304 * @pre_condition Start two justworks simulators
1305 * @procedure 1. call OCRegisterPersistentStorageHandler
1308 * 4. call OCDiscoverUnownedDevices
1309 * 5. call OCDoOwnershipTransfer
1310 * 6. call OCDiscoverOwnedDevices
1311 * 7. call OCChangeMOTMode
1312 * @post_condition None
1313 * @expected OCChangeMOTMode will return OC_STACK_INVALID_PARAM
1315 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
1316 TEST_F(PMCsdkMotTest_btc, OCChangeMOTModeDev_NV_N)
1318 CommonUtil::launchApp(PRECONFIG_SERVER1);
1319 CommonUtil::launchApp(PRECONFIG_SERVER2);
1321 if (!m_PMHelper.initProvisionClient())
1323 SET_FAILURE(m_PMHelper.getFailureMessage());
1327 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
1328 &m_UnownList, OC_STACK_OK))
1330 SET_FAILURE(m_PMHelper.getFailureMessage());
1334 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
1335 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
1337 SET_FAILURE(m_PMHelper.getFailureMessage());
1341 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
1343 SET_FAILURE(m_PMHelper.getFailureMessage());
1347 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, NULL, OIC_MULTIPLE_OWNER_DISABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_INVALID_PARAM))
1349 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1356 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
1357 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
1358 * @see OCStackResult OCInitPM(const char* dbPath)
1359 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
1360 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1361 * @see OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
1362 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1363 * @objective Test OCProvisionPreconfPin positively with regular data
1364 * @target OCStackResult OCProvisionPreconfPin(void* ctx, OCProvisionDev_t *targetDeviceInfo, const char * preconfPin, size_t preconfPinLen, OCProvisionResultCB resultCallback)
1365 * @test_data regular data for the target API
1366 * @pre_condition Start two justworks simulators
1367 * @procedure 1. call OCRegisterPersistentStorageHandler
1370 * 4. call OCDiscoverUnownedDevices
1371 * 5. call OCDoOwnershipTransfer
1372 * 6. call OCDiscoverOwnedDevices
1373 * 7. call OCChangeMOTMode
1374 * 8. call OCDiscoverMultipleOwnerEnabledDevices
1375 * 9. call OCProvisionPreconfPin
1376 * @post_condition None
1377 * @expected OCProvisionPreconfPin will return OC_STACK_OK
1379 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
1380 TEST_F(PMCsdkMotTest_btc, OCProvisionPreconfPin_RV_SRC_P)
1382 CommonUtil::launchApp(PRECONFIG_SERVER1);
1383 CommonUtil::launchApp(PRECONFIG_SERVER2);
1385 if (!m_PMHelper.initProvisionClient())
1387 SET_FAILURE(m_PMHelper.getFailureMessage());
1391 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
1392 &m_UnownList, OC_STACK_OK))
1394 SET_FAILURE(m_PMHelper.getFailureMessage());
1398 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
1399 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
1401 SET_FAILURE(m_PMHelper.getFailureMessage());
1405 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
1407 SET_FAILURE(m_PMHelper.getFailureMessage());
1411 OCProvisionDev_t* targetOwnedDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
1413 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetOwnedDev, OIC_MULTIPLE_OWNER_ENABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
1415 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1419 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
1420 &m_motEnabledDevList, OC_STACK_OK))
1422 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1426 OCProvisionDev_t* targetMotDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, DEVICE_INDEX_ONE);
1428 if (!m_PMMotHelper.provisionPreconfPin((void*)ctxProvisionPreconfPin, targetMotDev, MOT_DEFAULT_PRE_CONFIG_PIN, OXM_PRECONFIG_PIN_MAX_SIZE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
1430 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1437 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
1438 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
1439 * @see OCStackResult OCInitPM(const char* dbPath)
1440 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
1441 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1442 * @see OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
1443 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1444 * @objective Test OCProvisionPreconfPin negatively with targetDeviceInfo=NULL
1445 * @target OCStackResult OCProvisionPreconfPin(void* ctx, OCProvisionDev_t *targetDeviceInfo, const char * preconfPin, size_t preconfPinLen, OCProvisionResultCB resultCallback)
1446 * @test_data targetDeviceInfo=NULL
1447 * @pre_condition Start two justworks simulators
1448 * @procedure 1. call OCRegisterPersistentStorageHandler
1451 * 4. call OCDiscoverUnownedDevices
1452 * 5. call OCDoOwnershipTransfer
1453 * 6. call OCDiscoverOwnedDevices
1454 * 7. call OCChangeMOTMode
1455 * 8. call OCDiscoverMultipleOwnerEnabledDevices
1456 * 9. call OCProvisionPreconfPin
1457 * @post_condition None
1458 * @expected OCProvisionPreconfPin will return OC_STACK_INVALID_PARAM
1460 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
1461 TEST_F(PMCsdkMotTest_btc, OCProvisionPreconfPinTargetDeviceInfo_NV_N)
1463 CommonUtil::launchApp(PRECONFIG_SERVER1);
1464 CommonUtil::launchApp(PRECONFIG_SERVER2);
1466 if (!m_PMHelper.initProvisionClient())
1468 SET_FAILURE(m_PMHelper.getFailureMessage());
1472 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
1473 &m_UnownList, OC_STACK_OK))
1475 SET_FAILURE(m_PMHelper.getFailureMessage());
1479 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
1480 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
1482 SET_FAILURE(m_PMHelper.getFailureMessage());
1486 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
1488 SET_FAILURE(m_PMHelper.getFailureMessage());
1492 OCProvisionDev_t* targetOwnedDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
1494 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetOwnedDev, OIC_MULTIPLE_OWNER_ENABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
1496 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1500 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
1501 &m_motEnabledDevList, OC_STACK_OK))
1503 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1507 if (!m_PMMotHelper.provisionPreconfPin((void*)ctxProvisionPreconfPin, NULL, MOT_DEFAULT_PRE_CONFIG_PIN, OXM_PRECONFIG_PIN_MAX_SIZE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_INVALID_PARAM))
1509 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1516 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
1517 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
1518 * @see OCStackResult OCInitPM(const char* dbPath)
1519 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
1520 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1521 * @see OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
1522 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1523 * @objective Test OCProvisionPreconfPin negatively with preconfPin=NULL
1524 * @target OCStackResult OCProvisionPreconfPin(void* ctx, OCProvisionDev_t *targetDeviceInfo, const char * preconfPin, size_t preconfPinLen, OCProvisionResultCB resultCallback)
1525 * @test_data preconfPin=NULL
1526 * @pre_condition Start two justworks simulators
1527 * @procedure 1. call OCRegisterPersistentStorageHandler
1530 * 4. call OCDiscoverUnownedDevices
1531 * 5. call OCDoOwnershipTransfer
1532 * 6. call OCDiscoverOwnedDevices
1533 * 7. call OCChangeMOTMode
1534 * 8. call OCDiscoverMultipleOwnerEnabledDevices
1535 * 9. call OCProvisionPreconfPin
1536 * @post_condition None
1537 * @expected OCProvisionPreconfPin will return OC_STACK_INVALID_PARAM
1539 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
1540 TEST_F(PMCsdkMotTest_btc, OCProvisionPreconfPinPreconfPin_NV_N)
1542 CommonUtil::launchApp(PRECONFIG_SERVER1);
1543 CommonUtil::launchApp(PRECONFIG_SERVER2);
1545 if (!m_PMHelper.initProvisionClient())
1547 SET_FAILURE(m_PMHelper.getFailureMessage());
1551 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
1552 &m_UnownList, OC_STACK_OK))
1554 SET_FAILURE(m_PMHelper.getFailureMessage());
1558 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
1559 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
1561 SET_FAILURE(m_PMHelper.getFailureMessage());
1565 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
1567 SET_FAILURE(m_PMHelper.getFailureMessage());
1571 OCProvisionDev_t* targetOwnedDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
1573 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetOwnedDev, OIC_MULTIPLE_OWNER_ENABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
1575 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1579 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
1580 &m_motEnabledDevList, OC_STACK_OK))
1582 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1586 OCProvisionDev_t* targetMotDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, DEVICE_INDEX_ONE);
1588 if (!m_PMMotHelper.provisionPreconfPin((void*)ctxProvisionPreconfPin, targetMotDev, NULL, OXM_PRECONFIG_PIN_MAX_SIZE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_INVALID_PARAM))
1590 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1597 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
1598 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
1599 * @see OCStackResult OCInitPM(const char* dbPath)
1600 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
1601 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1602 * @see OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
1603 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1604 * @objective Test OCProvisionPreconfPin negatively with preconfPinLen=MOT_PRECONFIG_PIN_ZERO_SIZE
1605 * @target OCStackResult OCProvisionPreconfPin(void* ctx, OCProvisionDev_t *targetDeviceInfo, const char * preconfPin, size_t preconfPinLen, OCProvisionResultCB resultCallback)
1606 * @test_data preconfPin=MOT_PRECONFIG_PIN_ZERO_SIZE
1607 * @pre_condition Start two justworks simulators
1608 * @procedure 1. call OCRegisterPersistentStorageHandler
1611 * 4. call OCDiscoverUnownedDevices
1612 * 5. call OCDoOwnershipTransfer
1613 * 6. call OCDiscoverOwnedDevices
1614 * 7. call OCChangeMOTMode
1615 * 8. call OCDiscoverMultipleOwnerEnabledDevices
1616 * 9. call OCProvisionPreconfPin
1617 * @post_condition None
1618 * @expected OCProvisionPreconfPin will return OC_STACK_INVALID_PARAM
1620 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
1621 TEST_F(PMCsdkMotTest_btc, OCProvisionPreconfPinPreconfPinLen_LOBV_N)
1623 CommonUtil::launchApp(PRECONFIG_SERVER1);
1624 CommonUtil::launchApp(PRECONFIG_SERVER2);
1626 if (!m_PMHelper.initProvisionClient())
1628 SET_FAILURE(m_PMHelper.getFailureMessage());
1632 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
1633 &m_UnownList, OC_STACK_OK))
1635 SET_FAILURE(m_PMHelper.getFailureMessage());
1639 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
1640 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
1642 SET_FAILURE(m_PMHelper.getFailureMessage());
1646 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
1648 SET_FAILURE(m_PMHelper.getFailureMessage());
1652 OCProvisionDev_t* targetOwnedDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
1654 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetOwnedDev, OIC_MULTIPLE_OWNER_ENABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
1656 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1660 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
1661 &m_motEnabledDevList, OC_STACK_OK))
1663 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1667 OCProvisionDev_t* targetMotDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, DEVICE_INDEX_ONE);
1669 if (!m_PMMotHelper.provisionPreconfPin((void*)ctxProvisionPreconfPin, targetMotDev, MOT_DEFAULT_PRE_CONFIG_PIN, MOT_PRECONFIG_PIN_ZERO_SIZE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_INVALID_PARAM))
1671 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1678 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
1679 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
1680 * @see OCStackResult OCInitPM(const char* dbPath)
1681 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
1682 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1683 * @see OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
1684 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1685 * @objective Test OCProvisionPreconfPin negatively with resultCallback=NULL
1686 * @target OCStackResult OCProvisionPreconfPin(void* ctx, OCProvisionDev_t *targetDeviceInfo, const char * preconfPin, size_t preconfPinLen, OCProvisionResultCB resultCallback)
1687 * @test_data resultCallback=NULL
1688 * @pre_condition Start two justworks simulators
1689 * @procedure 1. call OCRegisterPersistentStorageHandler
1692 * 4. call OCDiscoverUnownedDevices
1693 * 5. call OCDoOwnershipTransfer
1694 * 6. call OCDiscoverOwnedDevices
1695 * 7. call OCChangeMOTMode
1696 * 8. call OCDiscoverMultipleOwnerEnabledDevices
1697 * 9. call OCProvisionPreconfPin
1698 * @post_condition None
1699 * @expected OCProvisionPreconfPin will return OC_STACK_INVALID_CALLBACK
1701 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
1702 TEST_F(PMCsdkMotTest_btc, OCProvisionPreconfPinResultCallback_NV_N)
1704 CommonUtil::launchApp(PRECONFIG_SERVER1);
1705 CommonUtil::launchApp(PRECONFIG_SERVER2);
1707 if (!m_PMHelper.initProvisionClient())
1709 SET_FAILURE(m_PMHelper.getFailureMessage());
1713 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
1714 &m_UnownList, OC_STACK_OK))
1716 SET_FAILURE(m_PMHelper.getFailureMessage());
1720 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
1721 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
1723 SET_FAILURE(m_PMHelper.getFailureMessage());
1727 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
1729 SET_FAILURE(m_PMHelper.getFailureMessage());
1733 OCProvisionDev_t* targetOwnedDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
1735 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetOwnedDev, OIC_MULTIPLE_OWNER_ENABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
1737 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1741 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
1742 &m_motEnabledDevList, OC_STACK_OK))
1744 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1748 OCProvisionDev_t* targetMotDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, DEVICE_INDEX_ONE);
1750 if (!m_PMMotHelper.provisionPreconfPin((void*)ctxProvisionPreconfPin, targetMotDev, MOT_DEFAULT_PRE_CONFIG_PIN, OXM_PRECONFIG_PIN_MAX_SIZE, NULL, OC_STACK_INVALID_CALLBACK))
1752 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1759 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
1760 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
1761 * @see OCStackResult OCInitPM(const char* dbPath)
1762 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
1763 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1764 * @see OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
1765 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1766 * @see OCStackResult OCProvisionPreconfPin(void* ctx, OCProvisionDev_t *targetDeviceInfo, const char * preconfPin, size_t preconfPinLen, OCProvisionResultCB resultCallback)
1767 * @objective Test OCSelectMOTMethod positively with regular data
1768 * @target OCStackResult OCSelectMOTMethod(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecOxm_t oxmSelValue, OCProvisionResultCB resultCallback)
1769 * @test_data regular data for the target API
1770 * @pre_condition Start two justworks simulators
1771 * @procedure 1. call OCRegisterPersistentStorageHandler
1774 * 4. call OCDiscoverUnownedDevices
1775 * 5. call OCDoOwnershipTransfer
1776 * 6. call OCDiscoverOwnedDevices
1777 * 7. call OCChangeMOTMode
1778 * 8. call OCDiscoverMultipleOwnerEnabledDevices
1779 * 9. call OCProvisionPreconfPin
1780 * 10. call OCSelectMOTMethod
1781 * @post_condition None
1782 * @expected OCSelectMOTMethod will return OC_STACK_OK
1784 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
1785 TEST_F(PMCsdkMotTest_btc, OCSelectMOTMethod_RV_SRC_P)
1787 CommonUtil::launchApp(PRECONFIG_SERVER1);
1788 CommonUtil::launchApp(PRECONFIG_SERVER2);
1789 CommonUtil::waitInSecond(DELAY_LONG);
1791 if (!m_PMHelper.initProvisionClient())
1793 SET_FAILURE(m_PMHelper.getFailureMessage());
1797 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
1798 &m_UnownList, OC_STACK_OK))
1800 SET_FAILURE(m_PMHelper.getFailureMessage());
1804 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
1805 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
1807 SET_FAILURE(m_PMHelper.getFailureMessage());
1811 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
1813 SET_FAILURE(m_PMHelper.getFailureMessage());
1817 OCProvisionDev_t* targetOwnedDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
1819 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetOwnedDev, OIC_MULTIPLE_OWNER_ENABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
1821 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1825 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
1826 &m_motEnabledDevList, OC_STACK_OK))
1828 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1832 OCProvisionDev_t* targetMotDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, DEVICE_INDEX_ONE);
1834 if (!m_PMMotHelper.provisionPreconfPin((void*)ctxProvisionPreconfPin, targetMotDev, MOT_DEFAULT_PRE_CONFIG_PIN, OXM_PRECONFIG_PIN_MAX_SIZE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
1836 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1840 if (!m_PMMotHelper.selectMOTMethod((void*)ctxSelectMOTMethod, targetMotDev, OIC_PRECONFIG_PIN, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
1842 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1849 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
1850 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
1851 * @see OCStackResult OCInitPM(const char* dbPath)
1852 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
1853 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1854 * @see OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
1855 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1856 * @see OCStackResult OCProvisionPreconfPin(void* ctx, OCProvisionDev_t *targetDeviceInfo, const char * preconfPin, size_t preconfPinLen, OCProvisionResultCB resultCallback)
1857 * @objective Test OCSelectMOTMethod negatively with targetDeviceInfo as NULL
1858 * @target OCStackResult OCSelectMOTMethod(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecOxm_t oxmSelValue, OCProvisionResultCB resultCallback)
1859 * @test_data targetDeviceInfo = NULL
1860 * @pre_condition Start two justworks simulators
1861 * @procedure 1. call OCRegisterPersistentStorageHandler
1864 * 4. call OCDiscoverUnownedDevices
1865 * 5. call OCDoOwnershipTransfer
1866 * 6. call OCDiscoverOwnedDevices
1867 * 7. call OCChangeMOTMode
1868 * 8. call OCDiscoverMultipleOwnerEnabledDevices
1869 * 9. call OCProvisionPreconfPin
1870 * 10. call OCSelectMOTMethod
1871 * @post_condition None
1872 * @expected OCSelectMOTMethod will return OC_STACK_INVALID_PARAM
1874 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
1875 TEST_F(PMCsdkMotTest_btc, OCSelectMOTMethodDev_NV_N)
1877 CommonUtil::launchApp(PRECONFIG_SERVER1);
1878 CommonUtil::launchApp(PRECONFIG_SERVER2);
1880 if (!m_PMHelper.initProvisionClient())
1882 SET_FAILURE(m_PMHelper.getFailureMessage());
1886 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
1887 &m_UnownList, OC_STACK_OK))
1889 SET_FAILURE(m_PMHelper.getFailureMessage());
1893 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
1894 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
1896 SET_FAILURE(m_PMHelper.getFailureMessage());
1900 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
1902 SET_FAILURE(m_PMHelper.getFailureMessage());
1906 OCProvisionDev_t* targetOwnedDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
1908 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetOwnedDev, OIC_MULTIPLE_OWNER_ENABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
1910 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1914 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
1915 &m_motEnabledDevList, OC_STACK_OK))
1917 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1921 OCProvisionDev_t* targetMotDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, DEVICE_INDEX_ONE);
1923 if (!m_PMMotHelper.provisionPreconfPin((void*)ctxProvisionPreconfPin, targetMotDev, MOT_DEFAULT_PRE_CONFIG_PIN, OXM_PRECONFIG_PIN_MAX_SIZE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
1925 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1929 if (!m_PMMotHelper.selectMOTMethod((void*)ctxSelectMOTMethod, NULL, OIC_PRECONFIG_PIN, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_INVALID_PARAM))
1931 SET_FAILURE(m_PMMotHelper.getFailureMessage());
1938 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
1939 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
1940 * @see OCStackResult OCInitPM(const char* dbPath)
1941 * @see OCStackResult OCDoOwnershipTransfer(void* ctx, OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
1942 * @see OCStackResult OCDiscoverOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1943 * @see OCStackResult OCChangeMOTMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
1944 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
1945 * @see OCStackResult OCProvisionPreconfPin(void* ctx, OCProvisionDev_t *targetDeviceInfo, const char * preconfPin, size_t preconfPinLen, OCProvisionResultCB resultCallback)
1946 * @objective Test OCSelectMOTMethod negatively with resultCallback = NULL
1947 * @target OCStackResult OCSelectMOTMethod(void *ctx, const OCProvisionDev_t *targetDeviceInfo, const OicSecOxm_t oxmSelValue, OCProvisionResultCB resultCallback)
1948 * @test_data resultCallback = NULL
1949 * @pre_condition Start two justworks simulators
1950 * @procedure 1. call OCRegisterPersistentStorageHandler
1953 * 4. call OCDiscoverUnownedDevices
1954 * 5. call OCDoOwnershipTransfer
1955 * 6. call OCDiscoverOwnedDevices
1956 * 7. call OCChangeMOTMode
1957 * 8. call OCDiscoverMultipleOwnerEnabledDevices
1958 * 9. call OCProvisionPreconfPin
1959 * 10. call OCSelectMOTMethod
1960 * @post_condition None
1961 * @expected OCSelectMOTMethod will return OC_STACK_INVALID_CALLBACK
1963 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
1964 TEST_F(PMCsdkMotTest_btc, OCSelectMOTMethodCb_NV_N)
1966 CommonUtil::launchApp(PRECONFIG_SERVER1);
1967 CommonUtil::launchApp(PRECONFIG_SERVER2);
1969 if (!m_PMHelper.initProvisionClient())
1971 SET_FAILURE(m_PMHelper.getFailureMessage());
1975 if (!m_PMHelper.discoverUnownedDevices(DISCOVERY_TIMEOUT,
1976 &m_UnownList, OC_STACK_OK))
1978 SET_FAILURE(m_PMHelper.getFailureMessage());
1982 if (!m_PMHelper.doOwnerShipTransfer((void*)g_ctx, &m_UnownList,
1983 PMCsdkHelper::ownershipTransferCB, OC_STACK_OK))
1985 SET_FAILURE(m_PMHelper.getFailureMessage());
1989 if(!m_PMHelper.discoverOwnedDevices(DISCOVERY_TIMEOUT, &m_OwnList, OC_STACK_OK))
1991 SET_FAILURE(m_PMHelper.getFailureMessage());
1995 OCProvisionDev_t* targetOwnedDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_OwnList, DEVICE_INDEX_ONE);
1997 if (!m_PMMotHelper.changeMOTMode((void*)ctxChangeMOTMode, targetOwnedDev, OIC_MULTIPLE_OWNER_ENABLE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
1999 SET_FAILURE(m_PMMotHelper.getFailureMessage());
2003 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
2004 &m_motEnabledDevList, OC_STACK_OK))
2006 SET_FAILURE(m_PMMotHelper.getFailureMessage());
2010 OCProvisionDev_t* targetMotDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, DEVICE_INDEX_ONE);
2012 if (!m_PMMotHelper.provisionPreconfPin((void*)ctxProvisionPreconfPin, targetMotDev, MOT_DEFAULT_PRE_CONFIG_PIN, OXM_PRECONFIG_PIN_MAX_SIZE, PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
2014 SET_FAILURE(m_PMMotHelper.getFailureMessage());
2018 if (!m_PMMotHelper.selectMOTMethod((void*)ctxSelectMOTMethod, targetMotDev, OIC_PRECONFIG_PIN, NULL, OC_STACK_INVALID_CALLBACK))
2020 SET_FAILURE(m_PMMotHelper.getFailureMessage());
2027 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
2028 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
2029 * @see OCStackResult OCInitPM(const char* dbPath)
2030 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
2031 * @see OCStackResult OCAddPreconfigPin(const OCProvisionDev_t *targetDeviceInfo, const char* preconfPIN, size_t preconfPINLen)
2032 * @see OCDoMultipleOwnershipTransfer(void* ctx,OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
2033 * @objective Test provision ACL positively with MOT device
2034 * @target OCStackResult OCProvisionACL(void *ctx, const OCProvisionDev_t *selectedDeviceInfo, OicSecAcl_t *acl, OCProvisionResultCB resultCallback)
2035 * @test_data regular data for the API
2036 * @pre_condition Start Mot Enabled justworks simulators
2037 * @procedure 1. call OCRegisterPersistentStorageHandler
2040 * 4. call OCDiscoverMultipleOwnerEnabledDevices
2041 * 5. call OCAddPreconfigPin
2042 * 6. call OCDoMultipleOwnershipTransfer
2043 * 7. call OCProvisionACL
2044 * @post_condition none
2045 * @expected OCProvisionACL will return OC_STACK_OK
2047 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
2048 TEST_F(PMCsdkMotTest_btc, ProvisionACLForMultipleOwnedDevices_RV_SRC_P)
2050 CommonUtil::launchApp(JUSTWORKS_SERVER7);
2051 CommonUtil::waitInSecond(DELAY_LONG);
2053 if (!m_PMMotHelper.initMotClient())
2055 SET_FAILURE(m_PMMotHelper.getFailureMessage());
2059 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
2060 &m_motEnabledDevList, OC_STACK_OK))
2062 SET_FAILURE(m_PMMotHelper.getFailureMessage());
2066 OCProvisionDev_t* targetDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, DEVICE_INDEX_ONE);
2068 if (!m_PMMotHelper.addPreconfigPIN(targetDev, MOT_DEFAULT_PRE_CONFIG_PIN, OXM_PRECONFIG_PIN_MAX_SIZE, OC_STACK_OK))
2070 SET_FAILURE(m_PMMotHelper.getFailureMessage());
2074 if (!m_PMMotHelper.doMultipleOwnershipTransfer((void*)MOT_CTX, m_motEnabledDevList,
2075 PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
2077 SET_FAILURE(m_PMMotHelper.getFailureMessage());
2081 if (!m_PMMotHelper.discoverMultipleOwnedDevices(DISCOVERY_TIMEOUT,
2082 &m_motOwnedDevList, OC_STACK_OK))
2084 SET_FAILURE(m_PMMotHelper.getFailureMessage());
2088 OCProvisionDev_t* targetMOTDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motOwnedDevList, DEVICE_INDEX_ONE);
2089 OicUuid_t deviceUuid = targetMOTDev->doxm->subOwners->uuid;
2091 m_Acl = createAclForLEDAccess(&deviceUuid);
2093 if (!m_PMHelper.provisionACL((void*)g_ctx, m_motOwnedDevList, m_Acl,
2094 m_PMHelper.provisionAclCB, OC_STACK_OK))
2096 SET_FAILURE(m_PMHelper.getFailureMessage());
2100 if (!m_PMHelper.deleteACLList(m_Acl))
2102 SET_FAILURE(m_PMHelper.getFailureMessage());
2110 * @see OCStackResult OCRegisterPersistentStorageHandler(OCPersistentStorage* persistentStorageHandler)
2111 * @see OCStackResult OCInit(const char *ipAddr, uint16_t port, OCMode mode)
2112 * @see OCStackResult OCInitPM(const char* dbPath)
2113 * @see OCStackResult OCDiscoverMultipleOwnerEnabledDevices(unsigned short timeout, OCProvisionDev_t **ppList)
2114 * @see OCStackResult OCAddPreconfigPin(const OCProvisionDev_t *targetDeviceInfo, const char* preconfPIN, size_t preconfPINLen)
2115 * @see OCStackResult OCDoMultipleOwnershipTransfer(void* ctx,OCProvisionDev_t *targetDevices, OCProvisionResultCB resultCallback)
2116 * @see OCStackResult OCDiscoverMultipleOwnedDevices(unsigned short timeout, OCProvisionDev_t **ppList)
2117 * @objective Test OCIsSubownerOfDevice positively with regular data
2118 * @target OCStackResult OCIsSubownerOfDevice(OCProvisionDev_t *device, bool *isSubowner)
2119 * @test_data regular data for the API
2120 * @pre_condition Start Mot Enabled justworks simulators
2121 * @procedure 1. call OCRegisterPersistentStorageHandler
2124 * 4. call OCDiscoverMultipleOwnerEnabledDevices
2125 * 5. call OCAddPreconfigPin
2126 * 6. call OCDoMultipleOwnershipTransfer
2127 * 7. call OCDiscoverMultipleOwnedDevices
2128 * 8. call OCIsSubownerOfDevice
2129 * @post_condition none
2130 * @expected OCIsSubownerOfDevice will return OC_STACK_OK
2132 #if defined(__LINUX__) || defined(__TIZEN__) || defined(__WINDOWS__)
2133 TEST_F(PMCsdkMotTest_btc, OCIsSubownerOfDevice_RV_SRC_P)
2135 CommonUtil::launchApp(JUSTWORKS_SERVER7);
2137 if (!m_PMMotHelper.initMotClient())
2139 SET_FAILURE(m_PMMotHelper.getFailureMessage());
2143 if (!m_PMMotHelper.discoverMultipleOwnerEnabledDevices(DISCOVERY_TIMEOUT,
2144 &m_motEnabledDevList, OC_STACK_OK))
2146 SET_FAILURE(m_PMMotHelper.getFailureMessage());
2150 OCProvisionDev_t* targetDev = PMCsdkUtilityHelper::getDevInst((OCProvisionDev_t*) m_motEnabledDevList, DEVICE_INDEX_ONE);
2152 if (!m_PMMotHelper.addPreconfigPIN(targetDev, MOT_DEFAULT_PRE_CONFIG_PIN, OXM_PRECONFIG_PIN_MAX_SIZE, OC_STACK_OK))
2154 SET_FAILURE(m_PMMotHelper.getFailureMessage());
2158 if (!m_PMMotHelper.doMultipleOwnershipTransfer((void*)MOT_CTX, m_motEnabledDevList,
2159 PMCsdkCallbackHelper::provisionPostCB, OC_STACK_OK))
2161 SET_FAILURE(m_PMMotHelper.getFailureMessage());
2165 if (!m_PMMotHelper.discoverMultipleOwnedDevices(DISCOVERY_TIMEOUT,
2166 &m_motOwnedDevList, OC_STACK_OK))
2168 SET_FAILURE(m_PMMotHelper.getFailureMessage());
2172 if (!m_PMMotHelper.isSubownerOfDevice(m_motOwnedDevList, &isSubowner, OC_STACK_OK,true))
2174 SET_FAILURE(m_PMMotHelper.getFailureMessage());