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(StackStart, SetPlatformInfoValid)
185 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
186 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
188 OCPlatformInfo info = {};
189 info.platformID = (char *) "platform_id";
190 info.manufacturerName = (char *) "manufac_name";
192 EXPECT_EQ(OC_STACK_OK, OCSetPlatformInfo(info));
193 EXPECT_EQ(OC_STACK_OK, OCStop());
196 TEST(StackStart, SetPlatformInfoWithNoPlatformID)
198 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
199 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
201 OCPlatformInfo info = {};
202 info.manufacturerName = (char *) "manufac_name";
204 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
205 EXPECT_EQ(OC_STACK_OK, OCStop());
208 TEST(StackStart, SetPlatformInfoWithNoManufacturerName)
210 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
211 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
213 OCPlatformInfo info = {};
214 info.platformID = (char *) "platform_id";
216 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
217 EXPECT_EQ(OC_STACK_OK, OCStop());
220 TEST(StackStart, SetPlatformInfoWithTooLongManufacName)
222 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
223 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
225 OCPlatformInfo info = {};
226 info.platformID = (char *) "platform_id";
227 info.manufacturerName = (char *) "extremelylongmanufacturername";
229 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
230 EXPECT_EQ(OC_STACK_OK, OCStop());
233 TEST(StackStart, SetPlatformInfoWithTooLongManufacURL)
235 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
236 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
238 OCPlatformInfo info = {};
239 info.platformID = (char *) "platform_id";
240 info.manufacturerName = (char *) "extremelylongmanufacturername";
241 info.manufacturerUrl = (char *)"www.foooooooooooooooo.baaaaaaaaaaaaar";
243 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
244 EXPECT_EQ(OC_STACK_OK, OCStop());
248 TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery)
250 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
251 OCCallbackData cbData;
254 OC_LOG(INFO, TAG, "Starting DoResourceDeviceDiscovery test ");
255 InitStack(OC_CLIENT);
257 /* Start a discovery query*/
258 char szQueryUri[64] = { 0 };
259 strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
260 cbData.cb = asyncDoResourcesCallback;
261 cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
263 EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
273 EXPECT_EQ(OC_STACK_OK, OCStop());
276 TEST(StackStop, StackStopWithoutInit)
278 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
279 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
280 EXPECT_EQ(OC_STACK_OK, OCStop());
281 EXPECT_EQ(OC_STACK_ERROR, OCStop());
284 TEST(StackResource, DISABLED_UpdateResourceNullURI)
286 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
287 OCCallbackData cbData;
290 OC_LOG(INFO, TAG, "Starting UpdateResourceNullURI test");
291 InitStack(OC_CLIENT);
293 /* Start a discovery query*/
294 char szQueryUri[64] = { 0 };
295 strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
296 cbData.cb = asyncDoResourcesCallback;
297 cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
299 EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
309 EXPECT_EQ(OC_STACK_OK, OCStop());
312 TEST(StackResource, CreateResourceBadParams)
314 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
315 OC_LOG(INFO, TAG, "Starting CreateResourceBadParams test");
316 InitStack(OC_SERVER);
318 OCResourceHandle handle;
320 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(NULL, //&handle,
325 OC_DISCOVERABLE|OC_OBSERVABLE));
327 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
332 OC_DISCOVERABLE|OC_OBSERVABLE));
334 // Property bitmask out of range
335 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
340 128));// invalid bitmask for OCResourceProperty
342 EXPECT_EQ(OC_STACK_OK, OCStop());
346 TEST(StackResource, CreateResourceSuccess)
348 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
349 OC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
350 InitStack(OC_SERVER);
352 OCResourceHandle handle;
353 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
358 OC_DISCOVERABLE|OC_OBSERVABLE));
359 const char *url = OCGetResourceUri(handle);
360 EXPECT_STREQ("/a/led", url);
362 EXPECT_EQ(OC_STACK_OK, OCStop());
365 TEST(StackResource, CreateResourceFailDuplicateUri)
367 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
368 OC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
369 InitStack(OC_SERVER);
371 OCResourceHandle handle;
372 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
377 OC_DISCOVERABLE|OC_OBSERVABLE));
378 const char *url = OCGetResourceUri(handle);
379 EXPECT_STREQ("/a/led", url);
381 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
386 OC_DISCOVERABLE|OC_OBSERVABLE));
388 EXPECT_EQ(OC_STACK_OK, OCStop());
391 TEST(StackResource, CreateResourceMultipleResources)
393 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
394 OC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
395 InitStack(OC_SERVER);
397 OCResourceHandle handle1;
398 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
403 OC_DISCOVERABLE|OC_OBSERVABLE));
405 OCResourceHandle handle2;
406 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
411 OC_DISCOVERABLE|OC_OBSERVABLE));
412 OCResourceHandle handle3;
413 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
418 OC_DISCOVERABLE|OC_OBSERVABLE));
420 const char *url = OCGetResourceUri(handle1);
421 EXPECT_STREQ("/a/led1", url);
423 url = OCGetResourceUri(handle2);
424 EXPECT_STREQ("/a/led2", url);
426 url = OCGetResourceUri(handle3);
427 EXPECT_STREQ("/a/led3", url);
429 EXPECT_EQ(OC_STACK_OK, OCStop());
432 TEST(StackResource, CreateResourceBadResoureType)
434 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
435 OC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
436 InitStack(OC_SERVER);
438 OCResourceHandle handle;
439 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
444 OC_DISCOVERABLE|OC_OBSERVABLE));
446 EXPECT_EQ(OC_STACK_OK, OCStop());
449 TEST(StackResource, CreateResourceGoodResourceType)
451 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
452 OC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
453 InitStack(OC_SERVER);
455 OCResourceHandle handle;
456 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
461 OC_DISCOVERABLE|OC_OBSERVABLE));
463 EXPECT_EQ(OC_STACK_OK, OCStop());
466 TEST(StackResource, ResourceTypeName)
468 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
469 OC_LOG(INFO, TAG, "Starting ResourceTypeName test");
470 InitStack(OC_SERVER);
472 OCResourceHandle handle;
473 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
478 OC_DISCOVERABLE|OC_OBSERVABLE));
480 uint8_t numResourceTypes;
481 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
482 EXPECT_EQ(1, numResourceTypes);
483 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
484 EXPECT_STREQ("core.led", resourceTypeName);
486 // try getting resource type names with an invalid index
487 resourceTypeName = OCGetResourceTypeName(handle, 1);
488 EXPECT_STREQ(NULL, resourceTypeName);
489 // try getting resource type names with an invalid index
490 resourceTypeName = OCGetResourceTypeName(handle, 10);
491 EXPECT_STREQ(NULL, resourceTypeName);
493 EXPECT_EQ(OC_STACK_OK, OCStop());
496 TEST(StackResource, ResourceTypeAttrRepresentation)
498 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
499 OC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
500 InitStack(OC_SERVER);
502 OCResourceHandle handle;
503 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
508 OC_DISCOVERABLE|OC_OBSERVABLE));
510 uint8_t numResourceTypes;
511 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
512 EXPECT_EQ(1, numResourceTypes);
514 EXPECT_EQ(OC_STACK_OK, OCStop());
517 TEST(StackResource, ResourceTypeInterface)
519 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
520 OC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
521 InitStack(OC_SERVER);
523 OCResourceHandle handle;
524 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
529 OC_DISCOVERABLE|OC_OBSERVABLE));
531 uint8_t numResourceInterfaces;
532 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
533 EXPECT_EQ(1, numResourceInterfaces);
534 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
535 EXPECT_STREQ("core.rw", resourceInterfaceName);
537 // try getting resource interface names with an invalid index
538 resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
539 EXPECT_STREQ(NULL, resourceInterfaceName);
540 // try getting resource interface names with an invalid index
541 resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
542 EXPECT_STREQ(NULL, resourceInterfaceName);
544 EXPECT_EQ(OC_STACK_OK, OCStop());
547 TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
549 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
551 OC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
553 InitStack(OC_SERVER);
555 OCResourceHandle handle;
556 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
561 OC_DISCOVERABLE|OC_OBSERVABLE));
562 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
563 OC_RSRVD_INTERFACE_DEFAULT));
564 uint8_t numResourceInterfaces;
565 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
566 EXPECT_EQ(2, numResourceInterfaces);
568 const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
569 EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
571 const char*interfaceName_2 = OCGetResourceInterfaceName(handle, 1);
572 EXPECT_STREQ("core.rw", interfaceName_2);
574 EXPECT_EQ(OC_STACK_OK, OCStop());
577 TEST(StackResource, ResourceDuplicateDefaultInterfaces)
579 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
581 OC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
583 InitStack(OC_SERVER);
585 OCResourceHandle handle;
586 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
591 OC_DISCOVERABLE|OC_OBSERVABLE));
593 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
594 OC_RSRVD_INTERFACE_DEFAULT));
595 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
596 OC_RSRVD_INTERFACE_DEFAULT));
598 uint8_t numResourceInterfaces;
599 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
600 EXPECT_EQ(2, numResourceInterfaces);
602 const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
603 EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
605 EXPECT_EQ(OC_STACK_OK, OCStop());
608 TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
610 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
612 OC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
614 InitStack(OC_SERVER);
616 OCResourceHandle handle;
617 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
622 OC_DISCOVERABLE|OC_OBSERVABLE));
624 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
626 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
629 uint8_t numResourceInterfaces;
630 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
631 EXPECT_EQ(1, numResourceInterfaces);
633 EXPECT_EQ(OC_STACK_OK, OCStop());
636 TEST(StackResource, ResourceTypeInterfaceMethods)
638 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
639 OC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
640 InitStack(OC_SERVER);
642 OCResourceHandle handle;
643 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
648 OC_DISCOVERABLE|OC_OBSERVABLE));
650 uint8_t numResourceInterfaces;
651 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
652 EXPECT_EQ(1, numResourceInterfaces);
654 EXPECT_EQ(OC_STACK_OK, OCStop());
657 TEST(StackResource, GetResourceProperties)
659 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
660 OC_LOG(INFO, TAG, "Starting GetResourceProperties test");
661 InitStack(OC_SERVER);
663 OCResourceHandle handle;
664 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
669 OC_DISCOVERABLE|OC_OBSERVABLE));
671 EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
672 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
674 EXPECT_EQ(OC_STACK_OK, OCStop());
677 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
679 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
680 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
681 InitStack(OC_SERVER);
683 OCResourceHandle handle;
684 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
689 OC_DISCOVERABLE|OC_OBSERVABLE));
690 const char *url = OCGetResourceUri(handle);
691 EXPECT_STREQ("/a1/led", url);
693 //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
694 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
695 uint8_t numResources = 0;
696 uint8_t numExpectedResources = InitNumExpectedResources();
698 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
699 EXPECT_EQ(numExpectedResources, numResources);
701 EXPECT_EQ(OC_STACK_OK, OCStop());
704 TEST(StackResource, StackTestResourceDiscoverOneResource)
706 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
707 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
708 InitStack(OC_SERVER);
710 OCResourceHandle handle;
711 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
716 OC_DISCOVERABLE|OC_OBSERVABLE));
717 const char *url = OCGetResourceUri(handle);
718 EXPECT_STREQ("/a/led", url);
720 //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
721 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
723 EXPECT_EQ(OC_STACK_OK, OCStop());
726 TEST(StackResource, StackTestResourceDiscoverManyResources)
728 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
729 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
730 InitStack(OC_SERVER);
732 OCResourceHandle handle1;
733 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
739 const char *url = OCGetResourceUri(handle1);
740 EXPECT_STREQ("/a/led1", url);
742 OCResourceHandle handle2;
743 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
748 OC_DISCOVERABLE|OC_OBSERVABLE));
749 url = OCGetResourceUri(handle2);
750 EXPECT_STREQ("/a/led2", url);
752 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
753 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
755 OCResourceHandle handle3;
756 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
761 OC_DISCOVERABLE|OC_OBSERVABLE));
762 url = OCGetResourceUri(handle3);
763 EXPECT_STREQ("/a/led3", url);
765 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
766 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
768 OCResourceHandle handle4;
769 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
775 url = OCGetResourceUri(handle4);
776 EXPECT_STREQ("/a/led4", url);
778 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
779 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
780 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
782 //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
784 EXPECT_EQ(OC_STACK_OK, OCStop());
787 TEST(StackBind, BindResourceTypeNameBad)
789 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
790 OC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
791 InitStack(OC_SERVER);
793 OCResourceHandle handle;
794 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
799 OC_DISCOVERABLE|OC_OBSERVABLE));
801 uint8_t numResourceTypes;
802 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
803 EXPECT_EQ(1, numResourceTypes);
804 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
805 EXPECT_STREQ("core.led", resourceTypeName);
807 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
809 EXPECT_EQ(OC_STACK_OK, OCStop());
812 TEST(StackBind, BindResourceTypeNameGood)
814 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
815 OC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
816 InitStack(OC_SERVER);
818 OCResourceHandle handle;
819 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
824 OC_DISCOVERABLE|OC_OBSERVABLE));
826 uint8_t numResourceTypes;
827 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
828 EXPECT_EQ(1, numResourceTypes);
829 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
830 EXPECT_STREQ("core.led", resourceTypeName);
832 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
833 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
834 EXPECT_EQ(2, numResourceTypes);
835 resourceTypeName = OCGetResourceTypeName(handle, 1);
836 EXPECT_STREQ("core.brightled", resourceTypeName);
838 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
839 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
840 EXPECT_EQ(3, numResourceTypes);
841 resourceTypeName = OCGetResourceTypeName(handle, 2);
842 EXPECT_STREQ("core.reallybrightled", resourceTypeName);
844 EXPECT_EQ(OC_STACK_OK, OCStop());
847 TEST(StackBind, BindResourceTypeAttribRepGood)
849 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
850 OC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
851 InitStack(OC_SERVER);
853 OCResourceHandle handle;
854 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
859 OC_DISCOVERABLE|OC_OBSERVABLE));
861 uint8_t numResourceTypes;
862 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
863 EXPECT_EQ(1, numResourceTypes);
865 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
866 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
867 EXPECT_EQ(2, numResourceTypes);
869 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
870 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
871 EXPECT_EQ(3, numResourceTypes);
873 EXPECT_EQ(OC_STACK_OK, OCStop());
877 TEST(StackBind, BindResourceInterfaceNameBad)
879 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
880 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
881 InitStack(OC_SERVER);
883 OCResourceHandle handle;
884 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
889 OC_DISCOVERABLE|OC_OBSERVABLE));
891 uint8_t numResourceInterfaces;
892 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
893 EXPECT_EQ(1, numResourceInterfaces);
894 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
895 EXPECT_STREQ("core.rw", resourceInterfaceName);
897 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
899 EXPECT_EQ(OC_STACK_OK, OCStop());
902 TEST(StackBind, BindResourceInterfaceNameGood)
904 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
905 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
906 InitStack(OC_SERVER);
908 OCResourceHandle handle;
909 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
914 OC_DISCOVERABLE|OC_OBSERVABLE));
916 uint8_t numResourceInterfaces;
917 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
918 EXPECT_EQ(1, numResourceInterfaces);
919 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
920 EXPECT_STREQ("core.rw", resourceInterfaceName);
922 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
924 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
925 EXPECT_EQ(2, numResourceInterfaces);
926 resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
927 EXPECT_STREQ("core.r", resourceInterfaceName);
929 EXPECT_EQ(OC_STACK_OK, OCStop());
932 TEST(StackBind, BindResourceInterfaceMethodsBad)
934 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
935 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
936 InitStack(OC_SERVER);
938 OCResourceHandle handle;
939 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
944 OC_DISCOVERABLE|OC_OBSERVABLE));
946 uint8_t numResourceInterfaces;
947 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
948 EXPECT_EQ(1, numResourceInterfaces);
950 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
952 EXPECT_EQ(OC_STACK_OK, OCStop());
955 TEST(StackBind, BindResourceInterfaceMethodsGood)
957 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
958 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
959 InitStack(OC_SERVER);
961 OCResourceHandle handle;
962 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
967 OC_DISCOVERABLE|OC_OBSERVABLE));
969 uint8_t numResourceInterfaces;
970 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
971 EXPECT_EQ(1, numResourceInterfaces);
973 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
975 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
976 EXPECT_EQ(2, numResourceInterfaces);
978 EXPECT_EQ(OC_STACK_OK, OCStop());
981 TEST(StackBind, BindContainedResourceBad)
983 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
984 OC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
985 InitStack(OC_SERVER);
987 OCResourceHandle containerHandle;
988 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
993 OC_DISCOVERABLE|OC_OBSERVABLE));
995 OCResourceHandle handle0;
996 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1001 OC_DISCOVERABLE|OC_OBSERVABLE));
1003 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1005 EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1007 EXPECT_EQ(OC_STACK_OK, OCStop());
1010 TEST(StackBind, BindContainedResourceGood)
1012 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1013 OC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1014 InitStack(OC_SERVER);
1016 uint8_t numResources = 0;
1017 uint8_t numExpectedResources = InitNumExpectedResources();
1019 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1020 EXPECT_EQ(numExpectedResources, numResources);
1022 OCResourceHandle containerHandle;
1023 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1028 OC_DISCOVERABLE|OC_OBSERVABLE));
1029 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1030 EXPECT_EQ(++numExpectedResources, numResources);
1032 OCResourceHandle handle0;
1033 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1038 OC_DISCOVERABLE|OC_OBSERVABLE));
1039 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1040 EXPECT_EQ(++numExpectedResources, numResources);
1042 OCResourceHandle handle1;
1043 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1048 OC_DISCOVERABLE|OC_OBSERVABLE));
1049 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1050 EXPECT_EQ(++numExpectedResources, numResources);
1052 OCResourceHandle handle2;
1053 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1058 OC_DISCOVERABLE|OC_OBSERVABLE));
1059 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1060 EXPECT_EQ(++numExpectedResources, numResources);
1062 OCResourceHandle handle3;
1063 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1068 OC_DISCOVERABLE|OC_OBSERVABLE));
1069 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1070 EXPECT_EQ(++numExpectedResources, numResources);
1072 OCResourceHandle handle4;
1073 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1078 OC_DISCOVERABLE|OC_OBSERVABLE));
1079 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1080 EXPECT_EQ(++numExpectedResources, numResources);
1082 OCResourceHandle handle5;
1083 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1088 OC_DISCOVERABLE|OC_OBSERVABLE));
1089 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1090 EXPECT_EQ(++numExpectedResources, numResources);
1093 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1094 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1095 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1096 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1097 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1098 EXPECT_EQ(OC_STACK_ERROR, OCBindResource(containerHandle, handle5));
1100 EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1101 EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1102 EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1103 EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1104 EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1106 EXPECT_EQ(NULL, OCGetResourceHandleFromCollection(containerHandle, 5));
1108 EXPECT_EQ(OC_STACK_OK, OCStop());
1112 TEST(StackBind, BindEntityHandlerBad)
1114 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1115 OC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1116 InitStack(OC_SERVER);
1118 OCResourceHandle handle;
1119 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1124 OC_DISCOVERABLE|OC_OBSERVABLE));
1126 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL));
1128 EXPECT_EQ(OC_STACK_OK, OCStop());
1131 TEST(StackBind, BindEntityHandlerGood)
1133 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1134 OC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1135 InitStack(OC_SERVER);
1137 OCResourceHandle handle;
1138 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1143 OC_DISCOVERABLE|OC_OBSERVABLE));
1145 OCEntityHandler myHandler = entityHandler;
1147 EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler));
1149 EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1151 EXPECT_EQ(OC_STACK_OK, OCStop());
1154 TEST(StackResourceAccess, GetResourceByIndex)
1156 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1157 OC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1158 InitStack(OC_SERVER);
1160 uint8_t numResources = 0;
1161 uint8_t numExpectedResources = InitNumExpectedResources();
1162 uint8_t resourceIndex = InitResourceIndex();
1164 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1165 EXPECT_EQ(numExpectedResources, numResources);
1167 OCResourceHandle containerHandle;
1168 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1173 OC_DISCOVERABLE|OC_OBSERVABLE));
1174 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1175 EXPECT_EQ(++numExpectedResources, numResources);
1177 OCResourceHandle handle0;
1178 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1183 OC_DISCOVERABLE|OC_OBSERVABLE));
1184 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1185 EXPECT_EQ(++numExpectedResources, numResources);
1187 OCResourceHandle handle1;
1188 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1193 OC_DISCOVERABLE|OC_OBSERVABLE));
1194 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1195 EXPECT_EQ(++numExpectedResources, numResources);
1197 OCResourceHandle handle2;
1198 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1203 OC_DISCOVERABLE|OC_OBSERVABLE));
1204 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1205 EXPECT_EQ(++numExpectedResources, numResources);
1207 OCResourceHandle handle3;
1208 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1213 OC_DISCOVERABLE|OC_OBSERVABLE));
1214 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1215 EXPECT_EQ(++numExpectedResources, numResources);
1217 OCResourceHandle handle4;
1218 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1223 OC_DISCOVERABLE|OC_OBSERVABLE));
1224 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1225 EXPECT_EQ(++numExpectedResources, numResources);
1227 OCResourceHandle handle5;
1228 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1233 OC_DISCOVERABLE|OC_OBSERVABLE));
1234 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1235 EXPECT_EQ(++numExpectedResources, numResources);
1237 EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1238 EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1239 EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1240 EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1241 EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1242 EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1243 EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1245 EXPECT_EQ(OC_STACK_OK, OCStop());
1248 TEST(StackResourceAccess, DeleteHeadResource)
1250 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1251 OC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1252 InitStack(OC_SERVER);
1254 uint8_t numResources = 0;
1255 uint8_t numExpectedResources = InitNumExpectedResources();
1257 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1258 EXPECT_EQ(numExpectedResources, numResources);
1260 OCResourceHandle handle0;
1261 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1266 OC_DISCOVERABLE|OC_OBSERVABLE));
1267 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1268 EXPECT_EQ(++numExpectedResources, numResources);
1270 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1271 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1272 EXPECT_EQ(--numExpectedResources, numResources);
1274 EXPECT_EQ(OC_STACK_OK, OCStop());
1277 TEST(StackResourceAccess, DeleteHeadResource2)
1279 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1280 OC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1281 InitStack(OC_SERVER);
1283 uint8_t numResources = 0;
1284 uint8_t numExpectedResources = InitNumExpectedResources();
1285 uint8_t resourceIndex = InitResourceIndex();
1287 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1288 EXPECT_EQ(numExpectedResources, numResources);
1290 OCResourceHandle handle0;
1291 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1296 OC_DISCOVERABLE|OC_OBSERVABLE));
1297 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1298 EXPECT_EQ(++numExpectedResources, numResources);
1300 OCResourceHandle handle1;
1301 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1306 OC_DISCOVERABLE|OC_OBSERVABLE));
1307 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1308 EXPECT_EQ(++numExpectedResources, numResources);
1310 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1311 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1312 EXPECT_EQ(--numExpectedResources, numResources);
1314 EXPECT_EQ(handle1, OCGetResourceHandle(resourceIndex));
1316 EXPECT_EQ(OC_STACK_OK, OCStop());
1320 TEST(StackResourceAccess, DeleteLastResource)
1322 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1323 OC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1324 InitStack(OC_SERVER);
1326 uint8_t numResources = 0;
1327 uint8_t numExpectedResources = InitNumExpectedResources();
1328 uint8_t resourceIndex = InitResourceIndex();
1330 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1331 EXPECT_EQ(numExpectedResources, numResources);
1333 OCResourceHandle handle0;
1334 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1339 OC_DISCOVERABLE|OC_OBSERVABLE));
1340 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1341 EXPECT_EQ(++numExpectedResources, numResources);
1343 OCResourceHandle handle1;
1344 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1349 OC_DISCOVERABLE|OC_OBSERVABLE));
1350 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1351 EXPECT_EQ(++numExpectedResources, numResources);
1353 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1354 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1355 EXPECT_EQ(--numExpectedResources, numResources);
1357 EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1359 OCResourceHandle handle2;
1360 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1365 OC_DISCOVERABLE|OC_OBSERVABLE));
1366 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1367 EXPECT_EQ(++numExpectedResources, numResources);
1369 EXPECT_EQ(OC_STACK_OK, OCStop());
1372 TEST(StackResourceAccess, DeleteMiddleResource)
1374 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1375 OC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1376 InitStack(OC_SERVER);
1378 uint8_t numResources = 0;
1379 uint8_t numExpectedResources = InitNumExpectedResources();
1380 uint8_t resourceIndex = InitResourceIndex();
1382 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1383 EXPECT_EQ(numExpectedResources, numResources);
1385 OCResourceHandle handle0;
1386 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1391 OC_DISCOVERABLE|OC_OBSERVABLE));
1392 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1393 EXPECT_EQ(++numExpectedResources, numResources);
1395 OCResourceHandle handle1;
1396 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1401 OC_DISCOVERABLE|OC_OBSERVABLE));
1402 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1403 EXPECT_EQ(++numExpectedResources, numResources);
1405 OCResourceHandle handle2;
1406 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1411 OC_DISCOVERABLE|OC_OBSERVABLE));
1412 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1413 EXPECT_EQ(++numExpectedResources, numResources);
1415 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1416 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1417 EXPECT_EQ(--numExpectedResources, numResources);
1419 EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1420 EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1422 // Make sure the resource elements are still correct
1423 uint8_t numResourceInterfaces;
1424 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1425 EXPECT_EQ(1, numResourceInterfaces);
1426 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0);
1427 EXPECT_STREQ("core.rw", resourceInterfaceName);
1429 EXPECT_EQ(OC_STACK_OK, OCStop());
1435 #endif // __cplusplus
1436 void parsePresencePayload(char* payload, uint32_t* seqNum, uint32_t* maxAge, char** resType);
1439 #endif // __cplusplus
1441 TEST(StackPresence, ParsePresencePayload)
1443 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1444 OC_LOG(INFO, TAG, "Starting ParsePresencePayload test");
1447 uint32_t seqNum = 0, maxAge = 0;
1448 char * resType = NULL;
1451 strncpy(payload, "{\"oc\":[100:99:presence]}", sizeof(payload));
1452 parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1453 EXPECT_TRUE(100 == seqNum);
1454 EXPECT_TRUE(99 == maxAge);
1455 EXPECT_STREQ("presence", resType);
1458 //Bad Scenario -- should not result in Seg Fault
1459 parsePresencePayload(payload, NULL, &maxAge, &resType);
1462 seqNum = 0; maxAge = 0; resType = NULL;
1463 strncpy(payload, "{abracadabra}", sizeof(payload));
1464 parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1465 EXPECT_TRUE(0 == seqNum);
1466 EXPECT_TRUE(0 == maxAge);
1467 EXPECT_EQ(NULL, resType);
1471 seqNum = 0; maxAge = 0; resType = NULL;
1472 strncpy(payload, "{\"oc\":[100]}", sizeof(payload));
1473 parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1474 EXPECT_TRUE(100 == seqNum);
1475 EXPECT_TRUE(0 == maxAge);
1476 EXPECT_EQ(NULL, resType);
1480 seqNum = 0; maxAge = 0; resType = NULL;
1481 strncpy(payload, "{\"oc\":[]}", sizeof(payload));
1482 parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1483 EXPECT_TRUE(0 == seqNum);
1484 EXPECT_TRUE(0 == maxAge);
1485 EXPECT_EQ(NULL, resType);
1489 strncpy(payload, "{:]}", sizeof(payload));
1490 parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1491 EXPECT_TRUE(0 == seqNum);
1492 EXPECT_TRUE(0 == maxAge);
1493 EXPECT_EQ(NULL, resType);
1497 strncpy(payload, "{:[presence}", sizeof(payload));
1498 parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1499 EXPECT_TRUE(0 == seqNum);
1500 EXPECT_TRUE(0 == maxAge);
1501 EXPECT_EQ(NULL, resType);
1505 TEST(PODTests, OCHeaderOption)
1507 EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1510 TEST(PODTests, OCCallbackData)
1512 EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);