1 //******************************************************************
3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
29 #include "gtest/gtest.h"
30 #include <sys/types.h>
37 //-----------------------------------------------------------------------------
39 //-----------------------------------------------------------------------------
46 #include "gtest_helper.h"
50 namespace itst = iotivity::test;
52 #define DEFAULT_CONTEXT_VALUE 0x99
54 //-----------------------------------------------------------------------------
56 //-----------------------------------------------------------------------------
57 static const char TAG[] = "TestHarness";
59 std::chrono::seconds const SHORT_TEST_TIMEOUT = std::chrono::seconds(5);
61 //-----------------------------------------------------------------------------
63 //-----------------------------------------------------------------------------
64 extern "C" OCStackApplicationResult asyncDoResourcesCallback(void* ctx, OCDoHandle handle, OCClientResponse * clientResponse)
66 OC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
68 EXPECT_EQ(OC_STACK_OK, clientResponse->result);
70 if(ctx == (void*)DEFAULT_CONTEXT_VALUE) {
71 OC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
73 OC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
75 return OC_STACK_KEEP_TRANSACTION;
78 //-----------------------------------------------------------------------------
80 //-----------------------------------------------------------------------------
81 OCEntityHandlerResult entityHandler(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest)
83 OC_LOG(INFO, TAG, "Entering entityHandler");
88 //-----------------------------------------------------------------------------
90 //-----------------------------------------------------------------------------
91 void InitStack(OCMode mode)
93 OC_LOG(INFO, TAG, "Entering InitStack");
95 EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, mode));
96 OC_LOG(INFO, TAG, "Leaving InitStack");
99 uint8_t InitNumExpectedResources()
102 // When presence is enabled, it is a resource and so is (currently) included
103 // in the returned resource count returned by the OCGetNumberOfResources API.
110 uint8_t InitResourceIndex()
113 // When presence is enabled, it is a resource and so is (currently) included
114 // in the returned resource count returned by the OCGetNumberOfResources API.
115 // The index of the presence resource is 0, so the first user app resource index
122 //-----------------------------------------------------------------------------
124 //-----------------------------------------------------------------------------
126 TEST(StackInit, StackInitNullAddr)
128 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
129 EXPECT_EQ(OC_STACK_OK, OCInit(0, 5683, OC_SERVER));
130 EXPECT_EQ(OC_STACK_OK, OCStop());
133 TEST(StackInit, StackInitNullPort)
135 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
136 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 0, OC_SERVER));
137 EXPECT_EQ(OC_STACK_OK, OCStop());
140 TEST(StackInit, StackInitNullAddrAndPort)
142 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
143 EXPECT_EQ(OC_STACK_OK, OCInit(0, 0, OC_SERVER));
144 EXPECT_EQ(OC_STACK_OK, OCStop());
147 TEST(StackInit, StackInitInvalidMode)
149 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
150 EXPECT_EQ(OC_STACK_ERROR, OCInit(0, 0, (OCMode)10));
151 EXPECT_EQ(OC_STACK_ERROR, OCStop());
154 TEST(StackStart, StackStartSuccessClient)
156 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
157 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
158 EXPECT_EQ(OC_STACK_OK, OCStop());
161 TEST(StackStart, StackStartSuccessServer)
163 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
164 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
165 EXPECT_EQ(OC_STACK_OK, OCStop());
168 TEST(StackStart, StackStartSuccessClientServer)
170 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
171 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
172 EXPECT_EQ(OC_STACK_OK, OCStop());
175 TEST(StackStart, StackStartSuccessiveInits)
177 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
178 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
179 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.2", 5683, OC_SERVER));
180 EXPECT_EQ(OC_STACK_OK, OCStop());
183 TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery)
185 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
186 OCCallbackData cbData;
189 OC_LOG(INFO, TAG, "Starting DoResourceDeviceDiscovery test ");
190 InitStack(OC_CLIENT);
192 /* Start a discovery query*/
193 char szQueryUri[64] = { 0 };
194 strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
195 cbData.cb = asyncDoResourcesCallback;
196 cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
198 EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
208 EXPECT_EQ(OC_STACK_OK, OCStop());
211 TEST(StackStop, StackStopWithoutInit)
213 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
214 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
215 EXPECT_EQ(OC_STACK_OK, OCStop());
216 EXPECT_EQ(OC_STACK_ERROR, OCStop());
219 TEST(StackResource, DISABLED_UpdateResourceNullURI)
221 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
222 OCCallbackData cbData;
225 OC_LOG(INFO, TAG, "Starting UpdateResourceNullURI test");
226 InitStack(OC_CLIENT);
228 /* Start a discovery query*/
229 char szQueryUri[64] = { 0 };
230 strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
231 cbData.cb = asyncDoResourcesCallback;
232 cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
234 EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
244 EXPECT_EQ(OC_STACK_OK, OCStop());
247 TEST(StackResource, CreateResourceBadParams)
249 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
250 OC_LOG(INFO, TAG, "Starting CreateResourceBadParams test");
251 InitStack(OC_SERVER);
253 OCResourceHandle handle;
255 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(NULL, //&handle,
260 OC_DISCOVERABLE|OC_OBSERVABLE));
262 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
267 OC_DISCOVERABLE|OC_OBSERVABLE));
269 // Property bitmask out of range
270 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
275 128));// invalid bitmask for OCResourceProperty
277 EXPECT_EQ(OC_STACK_OK, OCStop());
281 TEST(StackResource, CreateResourceSuccess)
283 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
284 OC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
285 InitStack(OC_SERVER);
287 OCResourceHandle handle;
288 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
293 OC_DISCOVERABLE|OC_OBSERVABLE));
294 const char *url = OCGetResourceUri(handle);
295 EXPECT_STREQ("/a/led", url);
297 EXPECT_EQ(OC_STACK_OK, OCStop());
300 TEST(StackResource, CreateResourceFailDuplicateUri)
302 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
303 OC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
304 InitStack(OC_SERVER);
306 OCResourceHandle handle;
307 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
312 OC_DISCOVERABLE|OC_OBSERVABLE));
313 const char *url = OCGetResourceUri(handle);
314 EXPECT_STREQ("/a/led", url);
316 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
321 OC_DISCOVERABLE|OC_OBSERVABLE));
323 EXPECT_EQ(OC_STACK_OK, OCStop());
326 TEST(StackResource, CreateResourceMultipleResources)
328 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
329 OC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
330 InitStack(OC_SERVER);
332 OCResourceHandle handle1;
333 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
338 OC_DISCOVERABLE|OC_OBSERVABLE));
340 OCResourceHandle handle2;
341 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
346 OC_DISCOVERABLE|OC_OBSERVABLE));
347 OCResourceHandle handle3;
348 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
353 OC_DISCOVERABLE|OC_OBSERVABLE));
355 const char *url = OCGetResourceUri(handle1);
356 EXPECT_STREQ("/a/led1", url);
358 url = OCGetResourceUri(handle2);
359 EXPECT_STREQ("/a/led2", url);
361 url = OCGetResourceUri(handle3);
362 EXPECT_STREQ("/a/led3", url);
364 EXPECT_EQ(OC_STACK_OK, OCStop());
367 TEST(StackResource, CreateResourceBadResoureType)
369 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
370 OC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
371 InitStack(OC_SERVER);
373 OCResourceHandle handle;
374 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
379 OC_DISCOVERABLE|OC_OBSERVABLE));
381 EXPECT_EQ(OC_STACK_OK, OCStop());
384 TEST(StackResource, CreateResourceGoodResourceType)
386 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
387 OC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
388 InitStack(OC_SERVER);
390 OCResourceHandle handle;
391 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
396 OC_DISCOVERABLE|OC_OBSERVABLE));
398 EXPECT_EQ(OC_STACK_OK, OCStop());
401 TEST(StackResource, ResourceTypeName)
403 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
404 OC_LOG(INFO, TAG, "Starting ResourceTypeName test");
405 InitStack(OC_SERVER);
407 OCResourceHandle handle;
408 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
413 OC_DISCOVERABLE|OC_OBSERVABLE));
415 uint8_t numResourceTypes;
416 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
417 EXPECT_EQ(1, numResourceTypes);
418 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
419 EXPECT_STREQ("core.led", resourceTypeName);
421 // try getting resource type names with an invalid index
422 resourceTypeName = OCGetResourceTypeName(handle, 1);
423 EXPECT_STREQ(NULL, resourceTypeName);
424 // try getting resource type names with an invalid index
425 resourceTypeName = OCGetResourceTypeName(handle, 10);
426 EXPECT_STREQ(NULL, resourceTypeName);
428 EXPECT_EQ(OC_STACK_OK, OCStop());
431 TEST(StackResource, ResourceTypeAttrRepresentation)
433 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
434 OC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
435 InitStack(OC_SERVER);
437 OCResourceHandle handle;
438 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
443 OC_DISCOVERABLE|OC_OBSERVABLE));
445 uint8_t numResourceTypes;
446 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
447 EXPECT_EQ(1, numResourceTypes);
449 EXPECT_EQ(OC_STACK_OK, OCStop());
452 TEST(StackResource, ResourceTypeInterface)
454 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
455 OC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
456 InitStack(OC_SERVER);
458 OCResourceHandle handle;
459 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
464 OC_DISCOVERABLE|OC_OBSERVABLE));
466 uint8_t numResourceInterfaces;
467 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
468 EXPECT_EQ(1, numResourceInterfaces);
469 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
470 EXPECT_STREQ("core.rw", resourceInterfaceName);
472 // try getting resource interface names with an invalid index
473 resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
474 EXPECT_STREQ(NULL, resourceInterfaceName);
475 // try getting resource interface names with an invalid index
476 resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
477 EXPECT_STREQ(NULL, resourceInterfaceName);
479 EXPECT_EQ(OC_STACK_OK, OCStop());
482 TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
484 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
486 OC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
488 InitStack(OC_SERVER);
490 OCResourceHandle handle;
491 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
496 OC_DISCOVERABLE|OC_OBSERVABLE));
497 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
498 OC_RSRVD_INTERFACE_DEFAULT));
499 uint8_t numResourceInterfaces;
500 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
501 EXPECT_EQ(2, numResourceInterfaces);
503 const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
504 EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
506 const char*interfaceName_2 = OCGetResourceInterfaceName(handle, 1);
507 EXPECT_STREQ("core.rw", interfaceName_2);
509 EXPECT_EQ(OC_STACK_OK, OCStop());
512 TEST(StackResource, ResourceDuplicateDefaultInterfaces)
514 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
516 OC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
518 InitStack(OC_SERVER);
520 OCResourceHandle handle;
521 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
526 OC_DISCOVERABLE|OC_OBSERVABLE));
528 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
529 OC_RSRVD_INTERFACE_DEFAULT));
530 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
531 OC_RSRVD_INTERFACE_DEFAULT));
533 uint8_t numResourceInterfaces;
534 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
535 EXPECT_EQ(2, numResourceInterfaces);
537 const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
538 EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
540 EXPECT_EQ(OC_STACK_OK, OCStop());
543 TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
545 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
547 OC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
549 InitStack(OC_SERVER);
551 OCResourceHandle handle;
552 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
557 OC_DISCOVERABLE|OC_OBSERVABLE));
559 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
561 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
564 uint8_t numResourceInterfaces;
565 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
566 EXPECT_EQ(1, numResourceInterfaces);
568 EXPECT_EQ(OC_STACK_OK, OCStop());
571 TEST(StackResource, ResourceTypeInterfaceMethods)
573 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
574 OC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
575 InitStack(OC_SERVER);
577 OCResourceHandle handle;
578 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
583 OC_DISCOVERABLE|OC_OBSERVABLE));
585 uint8_t numResourceInterfaces;
586 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
587 EXPECT_EQ(1, numResourceInterfaces);
589 EXPECT_EQ(OC_STACK_OK, OCStop());
592 TEST(StackResource, GetResourceProperties)
594 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
595 OC_LOG(INFO, TAG, "Starting GetResourceProperties test");
596 InitStack(OC_SERVER);
598 OCResourceHandle handle;
599 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
604 OC_DISCOVERABLE|OC_OBSERVABLE));
606 EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
607 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
609 EXPECT_EQ(OC_STACK_OK, OCStop());
612 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
614 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
615 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
616 InitStack(OC_SERVER);
618 OCResourceHandle handle;
619 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
624 OC_DISCOVERABLE|OC_OBSERVABLE));
625 const char *url = OCGetResourceUri(handle);
626 EXPECT_STREQ("/a1/led", url);
628 //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
629 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
630 uint8_t numResources = 0;
631 uint8_t numExpectedResources = InitNumExpectedResources();
633 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
634 EXPECT_EQ(numExpectedResources, numResources);
636 EXPECT_EQ(OC_STACK_OK, OCStop());
639 TEST(StackResource, StackTestResourceDiscoverOneResource)
641 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
642 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
643 InitStack(OC_SERVER);
645 OCResourceHandle handle;
646 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
651 OC_DISCOVERABLE|OC_OBSERVABLE));
652 const char *url = OCGetResourceUri(handle);
653 EXPECT_STREQ("/a/led", url);
655 //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
656 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
658 EXPECT_EQ(OC_STACK_OK, OCStop());
661 TEST(StackResource, StackTestResourceDiscoverManyResources)
663 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
664 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
665 InitStack(OC_SERVER);
667 OCResourceHandle handle1;
668 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
674 const char *url = OCGetResourceUri(handle1);
675 EXPECT_STREQ("/a/led1", url);
677 OCResourceHandle handle2;
678 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
683 OC_DISCOVERABLE|OC_OBSERVABLE));
684 url = OCGetResourceUri(handle2);
685 EXPECT_STREQ("/a/led2", url);
687 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
688 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
690 OCResourceHandle handle3;
691 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
696 OC_DISCOVERABLE|OC_OBSERVABLE));
697 url = OCGetResourceUri(handle3);
698 EXPECT_STREQ("/a/led3", url);
700 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
701 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
703 OCResourceHandle handle4;
704 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
710 url = OCGetResourceUri(handle4);
711 EXPECT_STREQ("/a/led4", url);
713 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
714 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
715 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
717 //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
719 EXPECT_EQ(OC_STACK_OK, OCStop());
722 TEST(StackBind, BindResourceTypeNameBad)
724 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
725 OC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
726 InitStack(OC_SERVER);
728 OCResourceHandle handle;
729 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
734 OC_DISCOVERABLE|OC_OBSERVABLE));
736 uint8_t numResourceTypes;
737 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
738 EXPECT_EQ(1, numResourceTypes);
739 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
740 EXPECT_STREQ("core.led", resourceTypeName);
742 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
744 EXPECT_EQ(OC_STACK_OK, OCStop());
747 TEST(StackBind, BindResourceTypeNameGood)
749 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
750 OC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
751 InitStack(OC_SERVER);
753 OCResourceHandle handle;
754 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
759 OC_DISCOVERABLE|OC_OBSERVABLE));
761 uint8_t numResourceTypes;
762 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
763 EXPECT_EQ(1, numResourceTypes);
764 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
765 EXPECT_STREQ("core.led", resourceTypeName);
767 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
768 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
769 EXPECT_EQ(2, numResourceTypes);
770 resourceTypeName = OCGetResourceTypeName(handle, 1);
771 EXPECT_STREQ("core.brightled", resourceTypeName);
773 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
774 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
775 EXPECT_EQ(3, numResourceTypes);
776 resourceTypeName = OCGetResourceTypeName(handle, 2);
777 EXPECT_STREQ("core.reallybrightled", resourceTypeName);
779 EXPECT_EQ(OC_STACK_OK, OCStop());
782 TEST(StackBind, BindResourceTypeAttribRepGood)
784 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
785 OC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
786 InitStack(OC_SERVER);
788 OCResourceHandle handle;
789 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
794 OC_DISCOVERABLE|OC_OBSERVABLE));
796 uint8_t numResourceTypes;
797 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
798 EXPECT_EQ(1, numResourceTypes);
800 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
801 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
802 EXPECT_EQ(2, numResourceTypes);
804 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
805 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
806 EXPECT_EQ(3, numResourceTypes);
808 EXPECT_EQ(OC_STACK_OK, OCStop());
812 TEST(StackBind, BindResourceInterfaceNameBad)
814 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
815 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
816 InitStack(OC_SERVER);
818 OCResourceHandle handle;
819 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
824 OC_DISCOVERABLE|OC_OBSERVABLE));
826 uint8_t numResourceInterfaces;
827 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
828 EXPECT_EQ(1, numResourceInterfaces);
829 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
830 EXPECT_STREQ("core.rw", resourceInterfaceName);
832 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
834 EXPECT_EQ(OC_STACK_OK, OCStop());
837 TEST(StackBind, BindResourceInterfaceNameGood)
839 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
840 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
841 InitStack(OC_SERVER);
843 OCResourceHandle handle;
844 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
849 OC_DISCOVERABLE|OC_OBSERVABLE));
851 uint8_t numResourceInterfaces;
852 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
853 EXPECT_EQ(1, numResourceInterfaces);
854 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
855 EXPECT_STREQ("core.rw", resourceInterfaceName);
857 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
859 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
860 EXPECT_EQ(2, numResourceInterfaces);
861 resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
862 EXPECT_STREQ("core.r", resourceInterfaceName);
864 EXPECT_EQ(OC_STACK_OK, OCStop());
867 TEST(StackBind, BindResourceInterfaceMethodsBad)
869 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
870 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
871 InitStack(OC_SERVER);
873 OCResourceHandle handle;
874 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
879 OC_DISCOVERABLE|OC_OBSERVABLE));
881 uint8_t numResourceInterfaces;
882 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
883 EXPECT_EQ(1, numResourceInterfaces);
885 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
887 EXPECT_EQ(OC_STACK_OK, OCStop());
890 TEST(StackBind, BindResourceInterfaceMethodsGood)
892 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
893 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
894 InitStack(OC_SERVER);
896 OCResourceHandle handle;
897 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
902 OC_DISCOVERABLE|OC_OBSERVABLE));
904 uint8_t numResourceInterfaces;
905 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
906 EXPECT_EQ(1, numResourceInterfaces);
908 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
910 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
911 EXPECT_EQ(2, numResourceInterfaces);
913 EXPECT_EQ(OC_STACK_OK, OCStop());
916 TEST(StackBind, BindContainedResourceBad)
918 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
919 OC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
920 InitStack(OC_SERVER);
922 OCResourceHandle containerHandle;
923 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
928 OC_DISCOVERABLE|OC_OBSERVABLE));
930 OCResourceHandle handle0;
931 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
936 OC_DISCOVERABLE|OC_OBSERVABLE));
938 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
940 EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
942 EXPECT_EQ(OC_STACK_OK, OCStop());
945 TEST(StackBind, BindContainedResourceGood)
947 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
948 OC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
949 InitStack(OC_SERVER);
951 uint8_t numResources = 0;
952 uint8_t numExpectedResources = InitNumExpectedResources();
954 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
955 EXPECT_EQ(numExpectedResources, numResources);
957 OCResourceHandle containerHandle;
958 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
963 OC_DISCOVERABLE|OC_OBSERVABLE));
964 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
965 EXPECT_EQ(++numExpectedResources, numResources);
967 OCResourceHandle handle0;
968 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
973 OC_DISCOVERABLE|OC_OBSERVABLE));
974 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
975 EXPECT_EQ(++numExpectedResources, numResources);
977 OCResourceHandle handle1;
978 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
983 OC_DISCOVERABLE|OC_OBSERVABLE));
984 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
985 EXPECT_EQ(++numExpectedResources, numResources);
987 OCResourceHandle handle2;
988 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
993 OC_DISCOVERABLE|OC_OBSERVABLE));
994 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
995 EXPECT_EQ(++numExpectedResources, numResources);
997 OCResourceHandle handle3;
998 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1003 OC_DISCOVERABLE|OC_OBSERVABLE));
1004 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1005 EXPECT_EQ(++numExpectedResources, numResources);
1007 OCResourceHandle handle4;
1008 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1013 OC_DISCOVERABLE|OC_OBSERVABLE));
1014 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1015 EXPECT_EQ(++numExpectedResources, numResources);
1017 OCResourceHandle handle5;
1018 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1023 OC_DISCOVERABLE|OC_OBSERVABLE));
1024 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1025 EXPECT_EQ(++numExpectedResources, numResources);
1028 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1029 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1030 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1031 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1032 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1033 EXPECT_EQ(OC_STACK_ERROR, OCBindResource(containerHandle, handle5));
1035 EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1036 EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1037 EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1038 EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1039 EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1041 EXPECT_EQ(NULL, OCGetResourceHandleFromCollection(containerHandle, 5));
1043 EXPECT_EQ(OC_STACK_OK, OCStop());
1047 TEST(StackBind, BindEntityHandlerBad)
1049 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1050 OC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1051 InitStack(OC_SERVER);
1053 OCResourceHandle handle;
1054 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1059 OC_DISCOVERABLE|OC_OBSERVABLE));
1061 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL));
1063 EXPECT_EQ(OC_STACK_OK, OCStop());
1066 TEST(StackBind, BindEntityHandlerGood)
1068 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1069 OC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1070 InitStack(OC_SERVER);
1072 OCResourceHandle handle;
1073 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1078 OC_DISCOVERABLE|OC_OBSERVABLE));
1080 OCEntityHandler myHandler = entityHandler;
1082 EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler));
1084 EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1086 EXPECT_EQ(OC_STACK_OK, OCStop());
1089 TEST(StackResourceAccess, GetResourceByIndex)
1091 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1092 OC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1093 InitStack(OC_SERVER);
1095 uint8_t numResources = 0;
1096 uint8_t numExpectedResources = InitNumExpectedResources();
1097 uint8_t resourceIndex = InitResourceIndex();
1099 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1100 EXPECT_EQ(numExpectedResources, numResources);
1102 OCResourceHandle containerHandle;
1103 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1108 OC_DISCOVERABLE|OC_OBSERVABLE));
1109 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1110 EXPECT_EQ(++numExpectedResources, numResources);
1112 OCResourceHandle handle0;
1113 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1118 OC_DISCOVERABLE|OC_OBSERVABLE));
1119 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1120 EXPECT_EQ(++numExpectedResources, numResources);
1122 OCResourceHandle handle1;
1123 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1128 OC_DISCOVERABLE|OC_OBSERVABLE));
1129 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1130 EXPECT_EQ(++numExpectedResources, numResources);
1132 OCResourceHandle handle2;
1133 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1138 OC_DISCOVERABLE|OC_OBSERVABLE));
1139 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1140 EXPECT_EQ(++numExpectedResources, numResources);
1142 OCResourceHandle handle3;
1143 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1148 OC_DISCOVERABLE|OC_OBSERVABLE));
1149 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1150 EXPECT_EQ(++numExpectedResources, numResources);
1152 OCResourceHandle handle4;
1153 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1158 OC_DISCOVERABLE|OC_OBSERVABLE));
1159 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1160 EXPECT_EQ(++numExpectedResources, numResources);
1162 OCResourceHandle handle5;
1163 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1168 OC_DISCOVERABLE|OC_OBSERVABLE));
1169 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1170 EXPECT_EQ(++numExpectedResources, numResources);
1172 EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1173 EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1174 EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1175 EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1176 EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1177 EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1178 EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1180 EXPECT_EQ(OC_STACK_OK, OCStop());
1183 TEST(StackResourceAccess, DeleteHeadResource)
1185 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1186 OC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1187 InitStack(OC_SERVER);
1189 uint8_t numResources = 0;
1190 uint8_t numExpectedResources = InitNumExpectedResources();
1192 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1193 EXPECT_EQ(numExpectedResources, numResources);
1195 OCResourceHandle handle0;
1196 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1201 OC_DISCOVERABLE|OC_OBSERVABLE));
1202 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1203 EXPECT_EQ(++numExpectedResources, numResources);
1205 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1206 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1207 EXPECT_EQ(--numExpectedResources, numResources);
1209 EXPECT_EQ(OC_STACK_OK, OCStop());
1212 TEST(StackResourceAccess, DeleteHeadResource2)
1214 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1215 OC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1216 InitStack(OC_SERVER);
1218 uint8_t numResources = 0;
1219 uint8_t numExpectedResources = InitNumExpectedResources();
1220 uint8_t resourceIndex = InitResourceIndex();
1222 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1223 EXPECT_EQ(numExpectedResources, numResources);
1225 OCResourceHandle handle0;
1226 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1231 OC_DISCOVERABLE|OC_OBSERVABLE));
1232 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1233 EXPECT_EQ(++numExpectedResources, numResources);
1235 OCResourceHandle handle1;
1236 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1241 OC_DISCOVERABLE|OC_OBSERVABLE));
1242 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1243 EXPECT_EQ(++numExpectedResources, numResources);
1245 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1246 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1247 EXPECT_EQ(--numExpectedResources, numResources);
1249 EXPECT_EQ(handle1, OCGetResourceHandle(resourceIndex));
1251 EXPECT_EQ(OC_STACK_OK, OCStop());
1255 TEST(StackResourceAccess, DeleteLastResource)
1257 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1258 OC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1259 InitStack(OC_SERVER);
1261 uint8_t numResources = 0;
1262 uint8_t numExpectedResources = InitNumExpectedResources();
1263 uint8_t resourceIndex = InitResourceIndex();
1265 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1266 EXPECT_EQ(numExpectedResources, numResources);
1268 OCResourceHandle handle0;
1269 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1274 OC_DISCOVERABLE|OC_OBSERVABLE));
1275 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1276 EXPECT_EQ(++numExpectedResources, numResources);
1278 OCResourceHandle handle1;
1279 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1284 OC_DISCOVERABLE|OC_OBSERVABLE));
1285 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1286 EXPECT_EQ(++numExpectedResources, numResources);
1288 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1289 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1290 EXPECT_EQ(--numExpectedResources, numResources);
1292 EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1294 OCResourceHandle handle2;
1295 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1300 OC_DISCOVERABLE|OC_OBSERVABLE));
1301 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1302 EXPECT_EQ(++numExpectedResources, numResources);
1304 EXPECT_EQ(OC_STACK_OK, OCStop());
1307 TEST(StackResourceAccess, DeleteMiddleResource)
1309 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1310 OC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1311 InitStack(OC_SERVER);
1313 uint8_t numResources = 0;
1314 uint8_t numExpectedResources = InitNumExpectedResources();
1315 uint8_t resourceIndex = InitResourceIndex();
1317 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1318 EXPECT_EQ(numExpectedResources, numResources);
1320 OCResourceHandle handle0;
1321 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1326 OC_DISCOVERABLE|OC_OBSERVABLE));
1327 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1328 EXPECT_EQ(++numExpectedResources, numResources);
1330 OCResourceHandle handle1;
1331 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1336 OC_DISCOVERABLE|OC_OBSERVABLE));
1337 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1338 EXPECT_EQ(++numExpectedResources, numResources);
1340 OCResourceHandle handle2;
1341 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1346 OC_DISCOVERABLE|OC_OBSERVABLE));
1347 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1348 EXPECT_EQ(++numExpectedResources, numResources);
1350 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1351 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1352 EXPECT_EQ(--numExpectedResources, numResources);
1354 EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1355 EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1357 // Make sure the resource elements are still correct
1358 uint8_t numResourceInterfaces;
1359 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1360 EXPECT_EQ(1, numResourceInterfaces);
1361 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0);
1362 EXPECT_STREQ("core.rw", resourceInterfaceName);
1364 EXPECT_EQ(OC_STACK_OK, OCStop());
1370 #endif // __cplusplus
1371 void parsePresencePayload(char* payload, uint32_t* seqNum, uint32_t* maxAge, char** resType);
1374 #endif // __cplusplus
1376 TEST(StackPresence, ParsePresencePayload)
1378 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1379 OC_LOG(INFO, TAG, "Starting ParsePresencePayload test");
1382 uint32_t seqNum = 0, maxAge = 0;
1383 char * resType = NULL;
1386 strncpy(payload, "{\"oc\":[100:99:presence]}", sizeof(payload));
1387 parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1388 EXPECT_TRUE(100 == seqNum);
1389 EXPECT_TRUE(99 == maxAge);
1390 EXPECT_STREQ("presence", resType);
1393 //Bad Scenario -- should not result in Seg Fault
1394 parsePresencePayload(payload, NULL, &maxAge, &resType);
1397 seqNum = 0; maxAge = 0; resType = NULL;
1398 strncpy(payload, "{abracadabra}", sizeof(payload));
1399 parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1400 EXPECT_TRUE(0 == seqNum);
1401 EXPECT_TRUE(0 == maxAge);
1402 EXPECT_EQ(NULL, resType);
1406 seqNum = 0; maxAge = 0; resType = NULL;
1407 strncpy(payload, "{\"oc\":[100]}", sizeof(payload));
1408 parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1409 EXPECT_TRUE(100 == seqNum);
1410 EXPECT_TRUE(0 == maxAge);
1411 EXPECT_EQ(NULL, resType);
1415 seqNum = 0; maxAge = 0; resType = NULL;
1416 strncpy(payload, "{\"oc\":[]}", sizeof(payload));
1417 parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1418 EXPECT_TRUE(0 == seqNum);
1419 EXPECT_TRUE(0 == maxAge);
1420 EXPECT_EQ(NULL, resType);
1424 strncpy(payload, "{:]}", sizeof(payload));
1425 parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1426 EXPECT_TRUE(0 == seqNum);
1427 EXPECT_TRUE(0 == maxAge);
1428 EXPECT_EQ(NULL, resType);
1432 strncpy(payload, "{:[presence}", sizeof(payload));
1433 parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1434 EXPECT_TRUE(0 == seqNum);
1435 EXPECT_TRUE(0 == maxAge);
1436 EXPECT_EQ(NULL, resType);