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 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
25 #include "ocstackinternal.h"
27 #include "oic_malloc.h"
30 #include "gtest/gtest.h"
31 #include <sys/types.h>
38 //-----------------------------------------------------------------------------
40 //-----------------------------------------------------------------------------
47 #include "gtest_helper.h"
51 namespace itst = iotivity::test;
53 #define DEFAULT_CONTEXT_VALUE 0x99
55 //-----------------------------------------------------------------------------
57 //-----------------------------------------------------------------------------
58 static const char TAG[] = "TestHarness";
60 std::chrono::seconds const SHORT_TEST_TIMEOUT = std::chrono::seconds(5);
62 //-----------------------------------------------------------------------------
64 //-----------------------------------------------------------------------------
65 extern "C" OCStackApplicationResult asyncDoResourcesCallback(void* ctx, OCDoHandle handle, OCClientResponse * clientResponse)
67 OC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
69 EXPECT_EQ(OC_STACK_OK, clientResponse->result);
71 if(ctx == (void*)DEFAULT_CONTEXT_VALUE) {
72 OC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
74 OC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
76 return OC_STACK_KEEP_TRANSACTION;
79 //-----------------------------------------------------------------------------
81 //-----------------------------------------------------------------------------
82 OCEntityHandlerResult entityHandler(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest,
85 OC_LOG(INFO, TAG, "Entering entityHandler");
90 //-----------------------------------------------------------------------------
92 //-----------------------------------------------------------------------------
93 void InitStack(OCMode mode)
95 OC_LOG(INFO, TAG, "Entering InitStack");
97 EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, mode));
98 OC_LOG(INFO, TAG, "Leaving InitStack");
101 uint8_t InitNumExpectedResources()
104 // When presence is enabled, it is a resource and so is (currently) included
105 // in the returned resource count returned by the OCGetNumberOfResources API.
112 uint8_t InitResourceIndex()
115 // When presence is enabled, it is a resource and so is (currently) included
116 // in the returned resource count returned by the OCGetNumberOfResources API.
117 // The index of the presence resource is 0, so the first user app resource index
124 //-----------------------------------------------------------------------------
126 //-----------------------------------------------------------------------------
128 TEST(StackInit, StackInitNullAddr)
130 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
131 EXPECT_EQ(OC_STACK_OK, OCInit(0, 5683, OC_SERVER));
132 EXPECT_EQ(OC_STACK_OK, OCStop());
135 TEST(StackInit, StackInitNullPort)
137 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
138 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 0, OC_SERVER));
139 EXPECT_EQ(OC_STACK_OK, OCStop());
142 TEST(StackInit, StackInitNullAddrAndPort)
144 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
145 EXPECT_EQ(OC_STACK_OK, OCInit(0, 0, OC_SERVER));
146 EXPECT_EQ(OC_STACK_OK, OCStop());
149 TEST(StackInit, StackInitInvalidMode)
151 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
152 EXPECT_EQ(OC_STACK_ERROR, OCInit(0, 0, (OCMode)10));
153 EXPECT_EQ(OC_STACK_ERROR, OCStop());
156 TEST(StackStart, StackStartSuccessClient)
158 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
159 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
160 EXPECT_EQ(OC_STACK_OK, OCStop());
163 TEST(StackStart, StackStartSuccessServer)
165 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
166 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
167 EXPECT_EQ(OC_STACK_OK, OCStop());
170 TEST(StackStart, StackStartSuccessClientServer)
172 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
173 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
174 EXPECT_EQ(OC_STACK_OK, OCStop());
177 TEST(StackStart, StackStartSuccessiveInits)
179 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
180 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
181 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.2", 5683, OC_SERVER));
182 EXPECT_EQ(OC_STACK_OK, OCStop());
185 TEST(StackStart, SetPlatformInfoValid)
187 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
188 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
190 OCPlatformInfo info = {};
191 info.platformID = (char *) "platform_id";
192 info.manufacturerName = (char *) "manufac_name";
194 EXPECT_EQ(OC_STACK_OK, OCSetPlatformInfo(info));
195 EXPECT_EQ(OC_STACK_OK, OCStop());
198 TEST(StackStart, SetPlatformInfoWithNoPlatformID)
200 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
201 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
203 OCPlatformInfo info = {};
204 info.manufacturerName = (char *) "manufac_name";
206 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
207 EXPECT_EQ(OC_STACK_OK, OCStop());
210 TEST(StackStart, SetPlatformInfoWithNoManufacturerName)
212 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
213 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
215 OCPlatformInfo info = {};
216 info.platformID = (char *) "platform_id";
218 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
219 EXPECT_EQ(OC_STACK_OK, OCStop());
222 TEST(StackStart, SetPlatformInfoWithZeroLengthManufacturerName)
224 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
225 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
227 OCPlatformInfo info = {};
228 info.platformID = (char *) "platform_id";
229 info.manufacturerName = (char *) "";
231 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
232 EXPECT_EQ(OC_STACK_OK, OCStop());
235 TEST(StackStart, SetPlatformInfoWithTooLongManufacName)
237 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
238 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
240 OCPlatformInfo info = {};
241 info.platformID = (char *) "platform_id";
242 info.manufacturerName = (char *) "extremelylongmanufacturername";
244 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
245 EXPECT_EQ(OC_STACK_OK, OCStop());
248 TEST(StackStart, SetPlatformInfoWithTooLongManufacURL)
250 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
251 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
253 OCPlatformInfo info = {};
254 info.platformID = (char *) "platform_id";
255 info.manufacturerName = (char *) "extremelylongmanufacturername";
256 info.manufacturerUrl = (char *)"www.foooooooooooooooo.baaaaaaaaaaaaar";
258 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
259 EXPECT_EQ(OC_STACK_OK, OCStop());
263 TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery)
265 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
266 OCCallbackData cbData;
269 OC_LOG(INFO, TAG, "Starting DoResourceDeviceDiscovery test ");
270 InitStack(OC_CLIENT);
272 /* Start a discovery query*/
273 char szQueryUri[64] = { 0 };
274 strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
275 cbData.cb = asyncDoResourcesCallback;
276 cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
278 EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
288 EXPECT_EQ(OC_STACK_OK, OCStop());
291 TEST(StackStop, StackStopWithoutInit)
293 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
294 EXPECT_EQ(OC_STACK_ERROR, OCStop());
297 TEST(StackStop, StackStopRepeated)
299 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
300 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
301 EXPECT_EQ(OC_STACK_OK, OCStop());
302 EXPECT_EQ(OC_STACK_ERROR, OCStop());
305 TEST(StackResource, DISABLED_UpdateResourceNullURI)
307 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
308 OCCallbackData cbData;
311 OC_LOG(INFO, TAG, "Starting UpdateResourceNullURI test");
312 InitStack(OC_CLIENT);
314 /* Start a discovery query*/
315 char szQueryUri[64] = { 0 };
316 strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
317 cbData.cb = asyncDoResourcesCallback;
318 cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
320 EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
330 EXPECT_EQ(OC_STACK_OK, OCStop());
333 TEST(StackResource, CreateResourceBadParams)
335 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
336 OC_LOG(INFO, TAG, "Starting CreateResourceBadParams test");
337 InitStack(OC_SERVER);
339 OCResourceHandle handle;
341 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(NULL, //&handle,
347 OC_DISCOVERABLE|OC_OBSERVABLE));
349 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
355 OC_DISCOVERABLE|OC_OBSERVABLE));
357 // Property bitmask out of range
358 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
364 128));// invalid bitmask for OCResourceProperty
366 EXPECT_EQ(OC_STACK_OK, OCStop());
369 TEST(StackResource, CreateResourceBadUri)
371 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
372 OC_LOG(INFO, TAG, "Starting CreateResourceBadUri test");
373 InitStack(OC_SERVER);
375 const char *uri65 = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKL";
377 OCResourceHandle handle;
379 EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
385 OC_DISCOVERABLE|OC_OBSERVABLE));
387 EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
393 OC_DISCOVERABLE|OC_OBSERVABLE));
395 EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
401 OC_DISCOVERABLE|OC_OBSERVABLE));
403 EXPECT_EQ(OC_STACK_OK, OCStop());
406 TEST(StackResource, CreateResourceSuccess)
408 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
409 OC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
410 InitStack(OC_SERVER);
412 OCResourceHandle handle;
413 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
419 OC_DISCOVERABLE|OC_OBSERVABLE));
420 const char *url = OCGetResourceUri(handle);
421 EXPECT_STREQ("/a/led", url);
423 EXPECT_EQ(OC_STACK_OK, OCStop());
426 TEST(StackResource, CreateResourceWithClientStackMode)
428 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
429 OC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
430 InitStack(OC_CLIENT);
432 OCResourceHandle handle;
433 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
439 OC_DISCOVERABLE|OC_OBSERVABLE));
441 EXPECT_EQ(OC_STACK_OK, OCStop());
444 TEST(StackResource, CreateResourceFailDuplicateUri)
446 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
447 OC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
448 InitStack(OC_SERVER);
450 OCResourceHandle handle;
451 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
457 OC_DISCOVERABLE|OC_OBSERVABLE));
458 const char *url = OCGetResourceUri(handle);
459 EXPECT_STREQ("/a/led", url);
461 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
467 OC_DISCOVERABLE|OC_OBSERVABLE));
469 EXPECT_EQ(OC_STACK_OK, OCStop());
472 TEST(StackResource, CreateResourceMultipleResources)
474 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
475 OC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
476 InitStack(OC_SERVER);
478 OCResourceHandle handle1;
479 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
485 OC_DISCOVERABLE|OC_OBSERVABLE));
487 OCResourceHandle handle2;
488 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
494 OC_DISCOVERABLE|OC_OBSERVABLE));
495 OCResourceHandle handle3;
496 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
502 OC_DISCOVERABLE|OC_OBSERVABLE));
504 const char *url = OCGetResourceUri(handle1);
505 EXPECT_STREQ("/a/led1", url);
507 url = OCGetResourceUri(handle2);
508 EXPECT_STREQ("/a/led2", url);
510 url = OCGetResourceUri(handle3);
511 EXPECT_STREQ("/a/led3", url);
513 EXPECT_EQ(OC_STACK_OK, OCStop());
516 TEST(StackResource, CreateResourceBadResoureType)
518 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
519 OC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
520 InitStack(OC_SERVER);
522 OCResourceHandle handle;
523 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
529 OC_DISCOVERABLE|OC_OBSERVABLE));
531 OCResourceHandle handle2;
532 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle2,
538 OC_DISCOVERABLE|OC_OBSERVABLE));
540 EXPECT_EQ(OC_STACK_OK, OCStop());
543 TEST(StackResource, CreateResourceGoodResourceType)
545 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
546 OC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
547 InitStack(OC_SERVER);
549 OCResourceHandle handle;
550 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
556 OC_DISCOVERABLE|OC_OBSERVABLE));
558 EXPECT_EQ(OC_STACK_OK, OCStop());
561 TEST(StackResource, ResourceTypeName)
563 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
564 OC_LOG(INFO, TAG, "Starting ResourceTypeName test");
565 InitStack(OC_SERVER);
567 OCResourceHandle handle;
568 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
574 OC_DISCOVERABLE|OC_OBSERVABLE));
576 uint8_t numResourceTypes;
577 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
578 EXPECT_EQ(1, numResourceTypes);
579 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
580 EXPECT_STREQ("core.led", resourceTypeName);
582 // try getting resource type names with an invalid index
583 resourceTypeName = OCGetResourceTypeName(handle, 1);
584 EXPECT_STREQ(NULL, resourceTypeName);
585 // try getting resource type names with an invalid index
586 resourceTypeName = OCGetResourceTypeName(handle, 10);
587 EXPECT_STREQ(NULL, resourceTypeName);
589 EXPECT_EQ(OC_STACK_OK, OCStop());
592 TEST(StackResource, ResourceTypeAttrRepresentation)
594 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
595 OC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
596 InitStack(OC_SERVER);
598 OCResourceHandle handle;
599 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
605 OC_DISCOVERABLE|OC_OBSERVABLE));
607 uint8_t numResourceTypes;
608 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
609 EXPECT_EQ(1, numResourceTypes);
611 EXPECT_EQ(OC_STACK_OK, OCStop());
614 TEST(StackResource, ResourceTypeInterface)
616 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
617 OC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
618 InitStack(OC_SERVER);
620 OCResourceHandle handle;
621 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
627 OC_DISCOVERABLE|OC_OBSERVABLE));
629 uint8_t numResourceInterfaces;
630 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
631 EXPECT_EQ(1, numResourceInterfaces);
632 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
633 EXPECT_STREQ("core.rw", resourceInterfaceName);
635 // try getting resource interface names with an invalid index
636 resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
637 EXPECT_STREQ(NULL, resourceInterfaceName);
638 // try getting resource interface names with an invalid index
639 resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
640 EXPECT_STREQ(NULL, resourceInterfaceName);
642 EXPECT_EQ(OC_STACK_OK, OCStop());
645 TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
647 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
649 OC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
651 InitStack(OC_SERVER);
653 OCResourceHandle handle;
654 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
660 OC_DISCOVERABLE|OC_OBSERVABLE));
661 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
662 OC_RSRVD_INTERFACE_DEFAULT));
663 uint8_t numResourceInterfaces;
664 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
665 EXPECT_EQ(2, numResourceInterfaces);
667 const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
668 EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
670 const char*interfaceName_2 = OCGetResourceInterfaceName(handle, 1);
671 EXPECT_STREQ("core.rw", interfaceName_2);
673 EXPECT_EQ(OC_STACK_OK, OCStop());
676 TEST(StackResource, ResourceDuplicateDefaultInterfaces)
678 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
680 OC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
682 InitStack(OC_SERVER);
684 OCResourceHandle handle;
685 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
691 OC_DISCOVERABLE|OC_OBSERVABLE));
693 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
694 OC_RSRVD_INTERFACE_DEFAULT));
695 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
696 OC_RSRVD_INTERFACE_DEFAULT));
698 uint8_t numResourceInterfaces;
699 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
700 EXPECT_EQ(2, numResourceInterfaces);
702 const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
703 EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
705 EXPECT_EQ(OC_STACK_OK, OCStop());
708 TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
710 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
712 OC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
714 InitStack(OC_SERVER);
716 OCResourceHandle handle;
717 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
723 OC_DISCOVERABLE|OC_OBSERVABLE));
725 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
727 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
730 uint8_t numResourceInterfaces;
731 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
732 EXPECT_EQ(1, numResourceInterfaces);
734 EXPECT_EQ(OC_STACK_OK, OCStop());
737 TEST(StackResource, ResourceTypeInterfaceMethods)
739 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
740 OC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
741 InitStack(OC_SERVER);
743 OCResourceHandle handle;
744 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
750 OC_DISCOVERABLE|OC_OBSERVABLE));
752 uint8_t numResourceInterfaces;
753 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
754 EXPECT_EQ(1, numResourceInterfaces);
756 EXPECT_EQ(OC_STACK_OK, OCStop());
759 TEST(StackResource, GetResourceProperties)
761 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
762 OC_LOG(INFO, TAG, "Starting GetResourceProperties test");
763 InitStack(OC_SERVER);
765 OCResourceHandle handle;
766 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
772 OC_DISCOVERABLE|OC_OBSERVABLE));
774 EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
775 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
777 EXPECT_EQ(OC_STACK_OK, OCStop());
780 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
782 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
783 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
784 InitStack(OC_SERVER);
785 uint8_t numResources = 0;
786 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
788 OCResourceHandle handle;
789 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
795 OC_DISCOVERABLE|OC_OBSERVABLE));
796 const char *url = OCGetResourceUri(handle);
797 EXPECT_STREQ("/a1/led", url);
799 //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
800 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
801 uint8_t numExpectedResources = 0;
803 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
804 EXPECT_EQ(numExpectedResources, numResources);
806 EXPECT_EQ(OC_STACK_OK, OCStop());
809 TEST(StackResource, StackTestResourceDiscoverOneResource)
811 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
812 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
813 InitStack(OC_SERVER);
815 OCResourceHandle handle;
816 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
822 OC_DISCOVERABLE|OC_OBSERVABLE));
823 const char *url = OCGetResourceUri(handle);
824 EXPECT_STREQ("/a/led", url);
826 //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
827 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
829 EXPECT_EQ(OC_STACK_OK, OCStop());
832 TEST(StackResource, StackTestResourceDiscoverManyResources)
834 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
835 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
836 InitStack(OC_SERVER);
838 OCResourceHandle handle1;
839 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
846 const char *url = OCGetResourceUri(handle1);
847 EXPECT_STREQ("/a/led1", url);
849 OCResourceHandle handle2;
850 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
856 OC_DISCOVERABLE|OC_OBSERVABLE));
857 url = OCGetResourceUri(handle2);
858 EXPECT_STREQ("/a/led2", url);
860 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
861 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
863 OCResourceHandle handle3;
864 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
870 OC_DISCOVERABLE|OC_OBSERVABLE));
871 url = OCGetResourceUri(handle3);
872 EXPECT_STREQ("/a/led3", url);
874 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
875 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
877 OCResourceHandle handle4;
878 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
885 url = OCGetResourceUri(handle4);
886 EXPECT_STREQ("/a/led4", url);
888 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
889 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
890 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
892 //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
894 EXPECT_EQ(OC_STACK_OK, OCStop());
897 TEST(StackBind, BindResourceTypeNameBad)
899 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
900 OC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
901 InitStack(OC_SERVER);
903 OCResourceHandle handle;
904 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
910 OC_DISCOVERABLE|OC_OBSERVABLE));
912 uint8_t numResourceTypes;
913 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
914 EXPECT_EQ(1, numResourceTypes);
915 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
916 EXPECT_STREQ("core.led", resourceTypeName);
918 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
920 EXPECT_EQ(OC_STACK_OK, OCStop());
923 TEST(StackBind, BindResourceTypeNameGood)
925 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
926 OC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
927 InitStack(OC_SERVER);
929 OCResourceHandle handle;
930 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
936 OC_DISCOVERABLE|OC_OBSERVABLE));
938 uint8_t numResourceTypes;
939 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
940 EXPECT_EQ(1, numResourceTypes);
941 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
942 EXPECT_STREQ("core.led", resourceTypeName);
944 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
945 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
946 EXPECT_EQ(2, numResourceTypes);
947 resourceTypeName = OCGetResourceTypeName(handle, 1);
948 EXPECT_STREQ("core.brightled", resourceTypeName);
950 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
951 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
952 EXPECT_EQ(3, numResourceTypes);
953 resourceTypeName = OCGetResourceTypeName(handle, 2);
954 EXPECT_STREQ("core.reallybrightled", resourceTypeName);
956 EXPECT_EQ(OC_STACK_OK, OCStop());
959 TEST(StackBind, BindResourceTypeAttribRepGood)
961 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
962 OC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
963 InitStack(OC_SERVER);
965 OCResourceHandle handle;
966 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
972 OC_DISCOVERABLE|OC_OBSERVABLE));
974 uint8_t numResourceTypes;
975 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
976 EXPECT_EQ(1, numResourceTypes);
978 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
979 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
980 EXPECT_EQ(2, numResourceTypes);
982 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
983 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
984 EXPECT_EQ(3, numResourceTypes);
986 EXPECT_EQ(OC_STACK_OK, OCStop());
990 TEST(StackBind, BindResourceInterfaceNameBad)
992 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
993 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
994 InitStack(OC_SERVER);
996 OCResourceHandle handle;
997 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1003 OC_DISCOVERABLE|OC_OBSERVABLE));
1005 uint8_t numResourceInterfaces;
1006 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1007 EXPECT_EQ(1, numResourceInterfaces);
1008 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
1009 EXPECT_STREQ("core.rw", resourceInterfaceName);
1011 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
1013 EXPECT_EQ(OC_STACK_OK, OCStop());
1016 TEST(StackBind, BindResourceInterfaceNameGood)
1018 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1019 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
1020 InitStack(OC_SERVER);
1022 OCResourceHandle handle;
1023 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1029 OC_DISCOVERABLE|OC_OBSERVABLE));
1031 uint8_t numResourceInterfaces;
1032 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1033 EXPECT_EQ(1, numResourceInterfaces);
1034 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
1035 EXPECT_STREQ("core.rw", resourceInterfaceName);
1037 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1039 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1040 EXPECT_EQ(2, numResourceInterfaces);
1041 resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1042 EXPECT_STREQ("core.r", resourceInterfaceName);
1044 EXPECT_EQ(OC_STACK_OK, OCStop());
1047 TEST(StackBind, BindResourceInterfaceMethodsBad)
1049 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1050 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
1051 InitStack(OC_SERVER);
1053 OCResourceHandle handle;
1054 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1060 OC_DISCOVERABLE|OC_OBSERVABLE));
1062 uint8_t numResourceInterfaces;
1063 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1064 EXPECT_EQ(1, numResourceInterfaces);
1066 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
1068 EXPECT_EQ(OC_STACK_OK, OCStop());
1071 TEST(StackBind, BindResourceInterfaceMethodsGood)
1073 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1074 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
1075 InitStack(OC_SERVER);
1077 OCResourceHandle handle;
1078 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1084 OC_DISCOVERABLE|OC_OBSERVABLE));
1086 uint8_t numResourceInterfaces;
1087 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1088 EXPECT_EQ(1, numResourceInterfaces);
1090 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1092 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1093 EXPECT_EQ(2, numResourceInterfaces);
1095 EXPECT_EQ(OC_STACK_OK, OCStop());
1098 TEST(StackBind, BindContainedResourceBad)
1100 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1101 OC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
1102 InitStack(OC_SERVER);
1104 OCResourceHandle containerHandle;
1105 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1111 OC_DISCOVERABLE|OC_OBSERVABLE));
1113 OCResourceHandle handle0;
1114 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1120 OC_DISCOVERABLE|OC_OBSERVABLE));
1122 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1124 EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1126 EXPECT_EQ(OC_STACK_OK, OCStop());
1129 TEST(StackBind, BindContainedResourceGood)
1131 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1132 OC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1133 InitStack(OC_SERVER);
1135 uint8_t numResources = 0;
1136 uint8_t numExpectedResources = 0;
1138 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1140 OCResourceHandle containerHandle;
1141 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1147 OC_DISCOVERABLE|OC_OBSERVABLE));
1148 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1149 EXPECT_EQ(++numExpectedResources, numResources);
1151 OCResourceHandle handle0;
1152 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1158 OC_DISCOVERABLE|OC_OBSERVABLE));
1159 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1160 EXPECT_EQ(++numExpectedResources, numResources);
1162 OCResourceHandle handle1;
1163 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1169 OC_DISCOVERABLE|OC_OBSERVABLE));
1170 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1171 EXPECT_EQ(++numExpectedResources, numResources);
1173 OCResourceHandle handle2;
1174 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1180 OC_DISCOVERABLE|OC_OBSERVABLE));
1181 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1182 EXPECT_EQ(++numExpectedResources, numResources);
1184 OCResourceHandle handle3;
1185 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1191 OC_DISCOVERABLE|OC_OBSERVABLE));
1192 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1193 EXPECT_EQ(++numExpectedResources, numResources);
1195 OCResourceHandle handle4;
1196 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1202 OC_DISCOVERABLE|OC_OBSERVABLE));
1203 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1204 EXPECT_EQ(++numExpectedResources, numResources);
1206 OCResourceHandle handle5;
1207 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1213 OC_DISCOVERABLE|OC_OBSERVABLE));
1214 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1215 EXPECT_EQ(++numExpectedResources, numResources);
1218 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1219 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1220 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1221 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1222 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1223 EXPECT_EQ(OC_STACK_ERROR, OCBindResource(containerHandle, handle5));
1225 EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1226 EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1227 EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1228 EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1229 EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1231 EXPECT_EQ(NULL, OCGetResourceHandleFromCollection(containerHandle, 5));
1233 EXPECT_EQ(OC_STACK_OK, OCStop());
1237 TEST(StackBind, BindEntityHandlerBad)
1239 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1240 OC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1241 InitStack(OC_SERVER);
1243 OCResourceHandle handle;
1244 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1250 OC_DISCOVERABLE|OC_OBSERVABLE));
1252 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
1254 EXPECT_EQ(OC_STACK_OK, OCStop());
1257 TEST(StackBind, BindEntityHandlerGood)
1259 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1260 OC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1261 InitStack(OC_SERVER);
1263 OCResourceHandle handle;
1264 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1270 OC_DISCOVERABLE|OC_OBSERVABLE));
1272 OCEntityHandler myHandler = entityHandler;
1274 EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
1276 EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1278 EXPECT_EQ(OC_STACK_OK, OCStop());
1281 TEST(StackResourceAccess, GetResourceByIndex)
1283 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1284 OC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1285 InitStack(OC_SERVER);
1287 uint8_t numResources = 0;
1288 uint8_t numExpectedResources = 0;
1289 uint8_t resourceIndex = 0;
1290 uint8_t prevResources = 0;
1291 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1292 prevResources = numExpectedResources;
1293 OCResourceHandle containerHandle;
1294 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1300 OC_DISCOVERABLE|OC_OBSERVABLE));
1301 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1302 EXPECT_EQ(++numExpectedResources, numResources);
1304 OCResourceHandle handle0;
1305 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1311 OC_DISCOVERABLE|OC_OBSERVABLE));
1312 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1313 EXPECT_EQ(++numExpectedResources, numResources);
1315 OCResourceHandle handle1;
1316 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1322 OC_DISCOVERABLE|OC_OBSERVABLE));
1323 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1324 EXPECT_EQ(++numExpectedResources, numResources);
1326 OCResourceHandle handle2;
1327 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1333 OC_DISCOVERABLE|OC_OBSERVABLE));
1334 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1335 EXPECT_EQ(++numExpectedResources, numResources);
1337 OCResourceHandle handle3;
1338 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1344 OC_DISCOVERABLE|OC_OBSERVABLE));
1345 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1346 EXPECT_EQ(++numExpectedResources, numResources);
1348 OCResourceHandle handle4;
1349 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1355 OC_DISCOVERABLE|OC_OBSERVABLE));
1356 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1357 EXPECT_EQ(++numExpectedResources, numResources);
1359 OCResourceHandle handle5;
1360 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1366 OC_DISCOVERABLE|OC_OBSERVABLE));
1367 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1368 EXPECT_EQ(++numExpectedResources, numResources);
1369 resourceIndex += prevResources;
1370 EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1371 EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1372 EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1373 EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1374 EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1375 EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1376 EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1378 EXPECT_EQ(OC_STACK_OK, OCStop());
1381 TEST(StackResourceAccess, DeleteHeadResource)
1383 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1384 OC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1385 InitStack(OC_SERVER);
1387 uint8_t numResources = 0;
1388 uint8_t numExpectedResources = 0;
1390 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1392 OCResourceHandle handle0;
1393 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1399 OC_DISCOVERABLE|OC_OBSERVABLE));
1400 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1401 EXPECT_EQ(++numExpectedResources, numResources);
1403 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1404 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1405 EXPECT_EQ(--numExpectedResources, numResources);
1407 EXPECT_EQ(OC_STACK_OK, OCStop());
1410 TEST(StackResourceAccess, DeleteHeadResource2)
1412 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1413 OC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1414 InitStack(OC_SERVER);
1416 uint8_t numResources = 0;
1417 uint8_t numExpectedResources = 0;
1419 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1420 OCResourceHandle handle0;
1421 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1427 OC_DISCOVERABLE|OC_OBSERVABLE));
1428 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1429 EXPECT_EQ(++numExpectedResources, numResources);
1431 OCResourceHandle handle1;
1432 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1438 OC_DISCOVERABLE|OC_OBSERVABLE));
1439 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1440 EXPECT_EQ(++numExpectedResources, numResources);
1442 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1443 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1444 EXPECT_EQ(--numExpectedResources, numResources);
1446 EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
1448 EXPECT_EQ(OC_STACK_OK, OCStop());
1452 TEST(StackResourceAccess, DeleteLastResource)
1454 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1455 OC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1456 InitStack(OC_SERVER);
1458 uint8_t numResources = 0;
1459 uint8_t numExpectedResources = 0;
1461 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1463 OCResourceHandle handle0;
1464 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1470 OC_DISCOVERABLE|OC_OBSERVABLE));
1471 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1472 EXPECT_EQ(++numExpectedResources, numResources);
1474 OCResourceHandle handle1;
1475 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1481 OC_DISCOVERABLE|OC_OBSERVABLE));
1482 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1483 EXPECT_EQ(++numExpectedResources, numResources);
1485 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1486 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1487 EXPECT_EQ(--numExpectedResources, numResources);
1489 EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
1491 OCResourceHandle handle2;
1492 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1498 OC_DISCOVERABLE|OC_OBSERVABLE));
1499 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1500 EXPECT_EQ(++numExpectedResources, numResources);
1502 EXPECT_EQ(OC_STACK_OK, OCStop());
1505 TEST(StackResourceAccess, DeleteMiddleResource)
1507 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1508 OC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1509 InitStack(OC_SERVER);
1511 uint8_t numResources = 0;
1512 uint8_t numExpectedResources = 0;
1513 uint8_t resourceIndex = InitResourceIndex();
1515 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1516 resourceIndex = numExpectedResources;
1517 OCResourceHandle handle0;
1518 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1524 OC_DISCOVERABLE|OC_OBSERVABLE));
1525 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1526 EXPECT_EQ(++numExpectedResources, numResources);
1528 OCResourceHandle handle1;
1529 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1535 OC_DISCOVERABLE|OC_OBSERVABLE));
1536 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1537 EXPECT_EQ(++numExpectedResources, numResources);
1539 OCResourceHandle handle2;
1540 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1546 OC_DISCOVERABLE|OC_OBSERVABLE));
1547 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1548 EXPECT_EQ(++numExpectedResources, numResources);
1550 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1551 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1552 EXPECT_EQ(--numExpectedResources, numResources);
1554 EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1555 EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1557 // Make sure the resource elements are still correct
1558 uint8_t numResourceInterfaces;
1559 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1560 EXPECT_EQ(1, numResourceInterfaces);
1561 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0);
1562 EXPECT_STREQ("core.rw", resourceInterfaceName);
1564 EXPECT_EQ(OC_STACK_OK, OCStop());
1570 #endif // __cplusplus
1571 void parsePresencePayload(char* payload, uint32_t* seqNum,
1572 uint32_t* maxAge, OCPresenceTrigger* presenceTrigger, char** resType);
1575 #endif // __cplusplus
1577 TEST(StackPresence, ParsePresencePayload)
1579 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1580 OC_LOG(INFO, TAG, "Starting ParsePresencePayload test");
1583 uint32_t seqNum = 0, maxAge = 0;
1584 OCPresenceTrigger presenceTrigger = OC_PRESENCE_TRIGGER_CHANGE;
1585 char * resType = NULL;
1588 strncpy(payload, "{\"oic\":[{\"ttl\":99,\"non\":100,\"trg\":"
1589 "\"delete\",\"rt\":\"presence\"}]}", sizeof(payload));
1590 parsePresencePayload(payload, &seqNum, &maxAge,
1591 &presenceTrigger, &resType);
1592 EXPECT_TRUE(100 == seqNum);
1593 EXPECT_TRUE(99 == maxAge);
1594 EXPECT_TRUE(OC_PRESENCE_TRIGGER_DELETE == presenceTrigger);
1595 EXPECT_TRUE(NULL != resType);
1596 EXPECT_STREQ("presence", resType);
1599 presenceTrigger = OC_PRESENCE_TRIGGER_CHANGE;
1601 //Bad Scenario -- should not result in Seg Fault
1602 parsePresencePayload(payload, NULL, &maxAge, &presenceTrigger, &resType);
1605 seqNum = 0; maxAge = 0; resType = NULL;
1606 strncpy(payload, "{abracadabra}", sizeof(payload));
1607 parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1608 EXPECT_TRUE(0 == seqNum);
1609 EXPECT_TRUE(0 == maxAge);
1610 EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1611 EXPECT_TRUE(NULL == resType);
1612 EXPECT_EQ(NULL, resType);
1616 seqNum = 0; maxAge = 0; resType = NULL;
1617 strncpy(payload, "{\"oic\":[100]}", sizeof(payload));
1618 parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1619 EXPECT_TRUE(0 == seqNum);
1620 EXPECT_TRUE(0 == maxAge);
1621 EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1622 EXPECT_TRUE(NULL == resType);
1623 EXPECT_EQ(NULL, resType);
1627 seqNum = 0; maxAge = 0; resType = NULL;
1628 strncpy(payload, "{\"oic\":[]}", sizeof(payload));
1629 parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1630 EXPECT_TRUE(0 == seqNum);
1631 EXPECT_TRUE(0 == maxAge);
1632 EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1633 EXPECT_TRUE(NULL == resType);
1634 EXPECT_EQ(NULL, resType);
1638 strncpy(payload, "{:]}", sizeof(payload));
1639 parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1640 EXPECT_TRUE(0 == seqNum);
1641 EXPECT_TRUE(0 == maxAge);
1642 EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1643 EXPECT_TRUE(NULL == resType);
1644 EXPECT_EQ(NULL, resType);
1648 strncpy(payload, "{:[presence}", sizeof(payload));
1649 parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1650 EXPECT_TRUE(0 == seqNum);
1651 EXPECT_TRUE(0 == maxAge);
1652 EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1653 EXPECT_TRUE(NULL == resType);
1654 EXPECT_EQ(NULL, resType);
1658 TEST(PODTests, OCHeaderOption)
1660 EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1663 TEST(PODTests, OCCallbackData)
1665 EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);