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"
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)
84 OC_LOG(INFO, TAG, "Entering entityHandler");
89 //-----------------------------------------------------------------------------
91 //-----------------------------------------------------------------------------
92 void InitStack(OCMode mode)
94 OC_LOG(INFO, TAG, "Entering InitStack");
96 EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, mode));
97 OC_LOG(INFO, TAG, "Leaving InitStack");
100 uint8_t InitNumExpectedResources()
103 // When presence is enabled, it is a resource and so is (currently) included
104 // in the returned resource count returned by the OCGetNumberOfResources API.
111 uint8_t InitResourceIndex()
114 // When presence is enabled, it is a resource and so is (currently) included
115 // in the returned resource count returned by the OCGetNumberOfResources API.
116 // The index of the presence resource is 0, so the first user app resource index
123 //-----------------------------------------------------------------------------
125 //-----------------------------------------------------------------------------
127 TEST(StackInit, StackInitNullAddr)
129 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
130 EXPECT_EQ(OC_STACK_OK, OCInit(0, 5683, OC_SERVER));
131 EXPECT_EQ(OC_STACK_OK, OCStop());
134 TEST(StackInit, StackInitNullPort)
136 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
137 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 0, OC_SERVER));
138 EXPECT_EQ(OC_STACK_OK, OCStop());
141 TEST(StackInit, StackInitNullAddrAndPort)
143 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
144 EXPECT_EQ(OC_STACK_OK, OCInit(0, 0, OC_SERVER));
145 EXPECT_EQ(OC_STACK_OK, OCStop());
148 TEST(StackInit, StackInitInvalidMode)
150 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
151 EXPECT_EQ(OC_STACK_ERROR, OCInit(0, 0, (OCMode)10));
152 EXPECT_EQ(OC_STACK_ERROR, OCStop());
155 TEST(StackStart, StackStartSuccessClient)
157 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
158 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
159 EXPECT_EQ(OC_STACK_OK, OCStop());
162 TEST(StackStart, StackStartSuccessServer)
164 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
165 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
166 EXPECT_EQ(OC_STACK_OK, OCStop());
169 TEST(StackStart, StackStartSuccessClientServer)
171 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
172 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
173 EXPECT_EQ(OC_STACK_OK, OCStop());
176 TEST(StackStart, StackStartSuccessiveInits)
178 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
179 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
180 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.2", 5683, OC_SERVER));
181 EXPECT_EQ(OC_STACK_OK, OCStop());
184 TEST(StackStart, SetPlatformInfoValid)
186 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
187 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
189 OCPlatformInfo info = {};
190 info.platformID = (char *) "platform_id";
191 info.manufacturerName = (char *) "manufac_name";
193 EXPECT_EQ(OC_STACK_OK, OCSetPlatformInfo(info));
194 EXPECT_EQ(OC_STACK_OK, OCStop());
197 TEST(StackStart, SetPlatformInfoWithNoPlatformID)
199 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
200 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
202 OCPlatformInfo info = {};
203 info.manufacturerName = (char *) "manufac_name";
205 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
206 EXPECT_EQ(OC_STACK_OK, OCStop());
209 TEST(StackStart, SetPlatformInfoWithNoManufacturerName)
211 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
212 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
214 OCPlatformInfo info = {};
215 info.platformID = (char *) "platform_id";
217 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
218 EXPECT_EQ(OC_STACK_OK, OCStop());
221 TEST(StackStart, SetPlatformInfoWithTooLongManufacName)
223 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
224 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
226 OCPlatformInfo info = {};
227 info.platformID = (char *) "platform_id";
228 info.manufacturerName = (char *) "extremelylongmanufacturername";
230 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
231 EXPECT_EQ(OC_STACK_OK, OCStop());
234 TEST(StackStart, SetPlatformInfoWithTooLongManufacURL)
236 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
237 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
239 OCPlatformInfo info = {};
240 info.platformID = (char *) "platform_id";
241 info.manufacturerName = (char *) "extremelylongmanufacturername";
242 info.manufacturerUrl = (char *)"www.foooooooooooooooo.baaaaaaaaaaaaar";
244 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
245 EXPECT_EQ(OC_STACK_OK, OCStop());
249 TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery)
251 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
252 OCCallbackData cbData;
255 OC_LOG(INFO, TAG, "Starting DoResourceDeviceDiscovery test ");
256 InitStack(OC_CLIENT);
258 /* Start a discovery query*/
259 char szQueryUri[64] = { 0 };
260 strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
261 cbData.cb = asyncDoResourcesCallback;
262 cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
264 EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
274 EXPECT_EQ(OC_STACK_OK, OCStop());
277 TEST(StackStop, StackStopWithoutInit)
279 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
280 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
281 EXPECT_EQ(OC_STACK_OK, OCStop());
282 EXPECT_EQ(OC_STACK_ERROR, OCStop());
285 TEST(StackResource, DISABLED_UpdateResourceNullURI)
287 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
288 OCCallbackData cbData;
291 OC_LOG(INFO, TAG, "Starting UpdateResourceNullURI test");
292 InitStack(OC_CLIENT);
294 /* Start a discovery query*/
295 char szQueryUri[64] = { 0 };
296 strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
297 cbData.cb = asyncDoResourcesCallback;
298 cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
300 EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
310 EXPECT_EQ(OC_STACK_OK, OCStop());
313 TEST(StackResource, CreateResourceBadParams)
315 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
316 OC_LOG(INFO, TAG, "Starting CreateResourceBadParams test");
317 InitStack(OC_SERVER);
319 OCResourceHandle handle;
321 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(NULL, //&handle,
326 OC_DISCOVERABLE|OC_OBSERVABLE));
328 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
333 OC_DISCOVERABLE|OC_OBSERVABLE));
335 // Property bitmask out of range
336 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
341 128));// invalid bitmask for OCResourceProperty
343 EXPECT_EQ(OC_STACK_OK, OCStop());
347 TEST(StackResource, CreateResourceSuccess)
349 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
350 OC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
351 InitStack(OC_SERVER);
353 OCResourceHandle handle;
354 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
359 OC_DISCOVERABLE|OC_OBSERVABLE));
360 const char *url = OCGetResourceUri(handle);
361 EXPECT_STREQ("/a/led", url);
363 EXPECT_EQ(OC_STACK_OK, OCStop());
366 TEST(StackResource, CreateResourceFailDuplicateUri)
368 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
369 OC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
370 InitStack(OC_SERVER);
372 OCResourceHandle handle;
373 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
378 OC_DISCOVERABLE|OC_OBSERVABLE));
379 const char *url = OCGetResourceUri(handle);
380 EXPECT_STREQ("/a/led", url);
382 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
387 OC_DISCOVERABLE|OC_OBSERVABLE));
389 EXPECT_EQ(OC_STACK_OK, OCStop());
392 TEST(StackResource, CreateResourceMultipleResources)
394 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
395 OC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
396 InitStack(OC_SERVER);
398 OCResourceHandle handle1;
399 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
404 OC_DISCOVERABLE|OC_OBSERVABLE));
406 OCResourceHandle handle2;
407 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
412 OC_DISCOVERABLE|OC_OBSERVABLE));
413 OCResourceHandle handle3;
414 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
419 OC_DISCOVERABLE|OC_OBSERVABLE));
421 const char *url = OCGetResourceUri(handle1);
422 EXPECT_STREQ("/a/led1", url);
424 url = OCGetResourceUri(handle2);
425 EXPECT_STREQ("/a/led2", url);
427 url = OCGetResourceUri(handle3);
428 EXPECT_STREQ("/a/led3", url);
430 EXPECT_EQ(OC_STACK_OK, OCStop());
433 TEST(StackResource, CreateResourceBadResoureType)
435 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
436 OC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
437 InitStack(OC_SERVER);
439 OCResourceHandle handle;
440 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
445 OC_DISCOVERABLE|OC_OBSERVABLE));
447 EXPECT_EQ(OC_STACK_OK, OCStop());
450 TEST(StackResource, CreateResourceGoodResourceType)
452 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
453 OC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
454 InitStack(OC_SERVER);
456 OCResourceHandle handle;
457 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
462 OC_DISCOVERABLE|OC_OBSERVABLE));
464 EXPECT_EQ(OC_STACK_OK, OCStop());
467 TEST(StackResource, ResourceTypeName)
469 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
470 OC_LOG(INFO, TAG, "Starting ResourceTypeName test");
471 InitStack(OC_SERVER);
473 OCResourceHandle handle;
474 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
479 OC_DISCOVERABLE|OC_OBSERVABLE));
481 uint8_t numResourceTypes;
482 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
483 EXPECT_EQ(1, numResourceTypes);
484 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
485 EXPECT_STREQ("core.led", resourceTypeName);
487 // try getting resource type names with an invalid index
488 resourceTypeName = OCGetResourceTypeName(handle, 1);
489 EXPECT_STREQ(NULL, resourceTypeName);
490 // try getting resource type names with an invalid index
491 resourceTypeName = OCGetResourceTypeName(handle, 10);
492 EXPECT_STREQ(NULL, resourceTypeName);
494 EXPECT_EQ(OC_STACK_OK, OCStop());
497 TEST(StackResource, ResourceTypeAttrRepresentation)
499 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
500 OC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
501 InitStack(OC_SERVER);
503 OCResourceHandle handle;
504 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
509 OC_DISCOVERABLE|OC_OBSERVABLE));
511 uint8_t numResourceTypes;
512 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
513 EXPECT_EQ(1, numResourceTypes);
515 EXPECT_EQ(OC_STACK_OK, OCStop());
518 TEST(StackResource, ResourceTypeInterface)
520 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
521 OC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
522 InitStack(OC_SERVER);
524 OCResourceHandle handle;
525 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
530 OC_DISCOVERABLE|OC_OBSERVABLE));
532 uint8_t numResourceInterfaces;
533 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
534 EXPECT_EQ(1, numResourceInterfaces);
535 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
536 EXPECT_STREQ("core.rw", resourceInterfaceName);
538 // try getting resource interface names with an invalid index
539 resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
540 EXPECT_STREQ(NULL, resourceInterfaceName);
541 // try getting resource interface names with an invalid index
542 resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
543 EXPECT_STREQ(NULL, resourceInterfaceName);
545 EXPECT_EQ(OC_STACK_OK, OCStop());
548 TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
550 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
552 OC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
554 InitStack(OC_SERVER);
556 OCResourceHandle handle;
557 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
562 OC_DISCOVERABLE|OC_OBSERVABLE));
563 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
564 OC_RSRVD_INTERFACE_DEFAULT));
565 uint8_t numResourceInterfaces;
566 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
567 EXPECT_EQ(2, numResourceInterfaces);
569 const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
570 EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
572 const char*interfaceName_2 = OCGetResourceInterfaceName(handle, 1);
573 EXPECT_STREQ("core.rw", interfaceName_2);
575 EXPECT_EQ(OC_STACK_OK, OCStop());
578 TEST(StackResource, ResourceDuplicateDefaultInterfaces)
580 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
582 OC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
584 InitStack(OC_SERVER);
586 OCResourceHandle handle;
587 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
592 OC_DISCOVERABLE|OC_OBSERVABLE));
594 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
595 OC_RSRVD_INTERFACE_DEFAULT));
596 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
597 OC_RSRVD_INTERFACE_DEFAULT));
599 uint8_t numResourceInterfaces;
600 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
601 EXPECT_EQ(2, numResourceInterfaces);
603 const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
604 EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
606 EXPECT_EQ(OC_STACK_OK, OCStop());
609 TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
611 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
613 OC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
615 InitStack(OC_SERVER);
617 OCResourceHandle handle;
618 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
623 OC_DISCOVERABLE|OC_OBSERVABLE));
625 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
627 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
630 uint8_t numResourceInterfaces;
631 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
632 EXPECT_EQ(1, numResourceInterfaces);
634 EXPECT_EQ(OC_STACK_OK, OCStop());
637 TEST(StackResource, ResourceTypeInterfaceMethods)
639 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
640 OC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
641 InitStack(OC_SERVER);
643 OCResourceHandle handle;
644 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
649 OC_DISCOVERABLE|OC_OBSERVABLE));
651 uint8_t numResourceInterfaces;
652 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
653 EXPECT_EQ(1, numResourceInterfaces);
655 EXPECT_EQ(OC_STACK_OK, OCStop());
658 TEST(StackResource, GetResourceProperties)
660 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
661 OC_LOG(INFO, TAG, "Starting GetResourceProperties test");
662 InitStack(OC_SERVER);
664 OCResourceHandle handle;
665 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
670 OC_DISCOVERABLE|OC_OBSERVABLE));
672 EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
673 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
675 EXPECT_EQ(OC_STACK_OK, OCStop());
678 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
680 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
681 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
682 InitStack(OC_SERVER);
684 OCResourceHandle handle;
685 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
690 OC_DISCOVERABLE|OC_OBSERVABLE));
691 const char *url = OCGetResourceUri(handle);
692 EXPECT_STREQ("/a1/led", url);
694 //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
695 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
696 uint8_t numResources = 0;
697 uint8_t numExpectedResources = InitNumExpectedResources();
699 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
700 EXPECT_EQ(numExpectedResources, numResources);
702 EXPECT_EQ(OC_STACK_OK, OCStop());
705 TEST(StackResource, StackTestResourceDiscoverOneResource)
707 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
708 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
709 InitStack(OC_SERVER);
711 OCResourceHandle handle;
712 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
717 OC_DISCOVERABLE|OC_OBSERVABLE));
718 const char *url = OCGetResourceUri(handle);
719 EXPECT_STREQ("/a/led", url);
721 //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
722 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
724 EXPECT_EQ(OC_STACK_OK, OCStop());
727 TEST(StackResource, StackTestResourceDiscoverManyResources)
729 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
730 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
731 InitStack(OC_SERVER);
733 OCResourceHandle handle1;
734 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
740 const char *url = OCGetResourceUri(handle1);
741 EXPECT_STREQ("/a/led1", url);
743 OCResourceHandle handle2;
744 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
749 OC_DISCOVERABLE|OC_OBSERVABLE));
750 url = OCGetResourceUri(handle2);
751 EXPECT_STREQ("/a/led2", url);
753 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
754 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
756 OCResourceHandle handle3;
757 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
762 OC_DISCOVERABLE|OC_OBSERVABLE));
763 url = OCGetResourceUri(handle3);
764 EXPECT_STREQ("/a/led3", url);
766 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
767 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
769 OCResourceHandle handle4;
770 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
776 url = OCGetResourceUri(handle4);
777 EXPECT_STREQ("/a/led4", url);
779 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
780 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
781 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
783 //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
785 EXPECT_EQ(OC_STACK_OK, OCStop());
788 TEST(StackBind, BindResourceTypeNameBad)
790 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
791 OC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
792 InitStack(OC_SERVER);
794 OCResourceHandle handle;
795 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
800 OC_DISCOVERABLE|OC_OBSERVABLE));
802 uint8_t numResourceTypes;
803 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
804 EXPECT_EQ(1, numResourceTypes);
805 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
806 EXPECT_STREQ("core.led", resourceTypeName);
808 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
810 EXPECT_EQ(OC_STACK_OK, OCStop());
813 TEST(StackBind, BindResourceTypeNameGood)
815 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
816 OC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
817 InitStack(OC_SERVER);
819 OCResourceHandle handle;
820 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
825 OC_DISCOVERABLE|OC_OBSERVABLE));
827 uint8_t numResourceTypes;
828 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
829 EXPECT_EQ(1, numResourceTypes);
830 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
831 EXPECT_STREQ("core.led", resourceTypeName);
833 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
834 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
835 EXPECT_EQ(2, numResourceTypes);
836 resourceTypeName = OCGetResourceTypeName(handle, 1);
837 EXPECT_STREQ("core.brightled", resourceTypeName);
839 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
840 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
841 EXPECT_EQ(3, numResourceTypes);
842 resourceTypeName = OCGetResourceTypeName(handle, 2);
843 EXPECT_STREQ("core.reallybrightled", resourceTypeName);
845 EXPECT_EQ(OC_STACK_OK, OCStop());
848 TEST(StackBind, BindResourceTypeAttribRepGood)
850 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
851 OC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
852 InitStack(OC_SERVER);
854 OCResourceHandle handle;
855 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
860 OC_DISCOVERABLE|OC_OBSERVABLE));
862 uint8_t numResourceTypes;
863 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
864 EXPECT_EQ(1, numResourceTypes);
866 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
867 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
868 EXPECT_EQ(2, numResourceTypes);
870 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
871 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
872 EXPECT_EQ(3, numResourceTypes);
874 EXPECT_EQ(OC_STACK_OK, OCStop());
878 TEST(StackBind, BindResourceInterfaceNameBad)
880 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
881 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
882 InitStack(OC_SERVER);
884 OCResourceHandle handle;
885 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
890 OC_DISCOVERABLE|OC_OBSERVABLE));
892 uint8_t numResourceInterfaces;
893 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
894 EXPECT_EQ(1, numResourceInterfaces);
895 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
896 EXPECT_STREQ("core.rw", resourceInterfaceName);
898 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
900 EXPECT_EQ(OC_STACK_OK, OCStop());
903 TEST(StackBind, BindResourceInterfaceNameGood)
905 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
906 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
907 InitStack(OC_SERVER);
909 OCResourceHandle handle;
910 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
915 OC_DISCOVERABLE|OC_OBSERVABLE));
917 uint8_t numResourceInterfaces;
918 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
919 EXPECT_EQ(1, numResourceInterfaces);
920 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
921 EXPECT_STREQ("core.rw", resourceInterfaceName);
923 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
925 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
926 EXPECT_EQ(2, numResourceInterfaces);
927 resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
928 EXPECT_STREQ("core.r", resourceInterfaceName);
930 EXPECT_EQ(OC_STACK_OK, OCStop());
933 TEST(StackBind, BindResourceInterfaceMethodsBad)
935 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
936 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
937 InitStack(OC_SERVER);
939 OCResourceHandle handle;
940 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
945 OC_DISCOVERABLE|OC_OBSERVABLE));
947 uint8_t numResourceInterfaces;
948 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
949 EXPECT_EQ(1, numResourceInterfaces);
951 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
953 EXPECT_EQ(OC_STACK_OK, OCStop());
956 TEST(StackBind, BindResourceInterfaceMethodsGood)
958 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
959 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
960 InitStack(OC_SERVER);
962 OCResourceHandle handle;
963 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
968 OC_DISCOVERABLE|OC_OBSERVABLE));
970 uint8_t numResourceInterfaces;
971 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
972 EXPECT_EQ(1, numResourceInterfaces);
974 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
976 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
977 EXPECT_EQ(2, numResourceInterfaces);
979 EXPECT_EQ(OC_STACK_OK, OCStop());
982 TEST(StackBind, BindContainedResourceBad)
984 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
985 OC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
986 InitStack(OC_SERVER);
988 OCResourceHandle containerHandle;
989 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
994 OC_DISCOVERABLE|OC_OBSERVABLE));
996 OCResourceHandle handle0;
997 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1002 OC_DISCOVERABLE|OC_OBSERVABLE));
1004 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1006 EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1008 EXPECT_EQ(OC_STACK_OK, OCStop());
1011 TEST(StackBind, BindContainedResourceGood)
1013 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1014 OC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1015 InitStack(OC_SERVER);
1017 uint8_t numResources = 0;
1018 uint8_t numExpectedResources = InitNumExpectedResources();
1020 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1021 EXPECT_EQ(numExpectedResources, numResources);
1023 OCResourceHandle containerHandle;
1024 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1029 OC_DISCOVERABLE|OC_OBSERVABLE));
1030 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1031 EXPECT_EQ(++numExpectedResources, numResources);
1033 OCResourceHandle handle0;
1034 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1039 OC_DISCOVERABLE|OC_OBSERVABLE));
1040 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1041 EXPECT_EQ(++numExpectedResources, numResources);
1043 OCResourceHandle handle1;
1044 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1049 OC_DISCOVERABLE|OC_OBSERVABLE));
1050 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1051 EXPECT_EQ(++numExpectedResources, numResources);
1053 OCResourceHandle handle2;
1054 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1059 OC_DISCOVERABLE|OC_OBSERVABLE));
1060 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1061 EXPECT_EQ(++numExpectedResources, numResources);
1063 OCResourceHandle handle3;
1064 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1069 OC_DISCOVERABLE|OC_OBSERVABLE));
1070 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1071 EXPECT_EQ(++numExpectedResources, numResources);
1073 OCResourceHandle handle4;
1074 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1079 OC_DISCOVERABLE|OC_OBSERVABLE));
1080 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1081 EXPECT_EQ(++numExpectedResources, numResources);
1083 OCResourceHandle handle5;
1084 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1089 OC_DISCOVERABLE|OC_OBSERVABLE));
1090 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1091 EXPECT_EQ(++numExpectedResources, numResources);
1094 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1095 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1096 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1097 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1098 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1099 EXPECT_EQ(OC_STACK_ERROR, OCBindResource(containerHandle, handle5));
1101 EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1102 EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1103 EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1104 EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1105 EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1107 EXPECT_EQ(NULL, OCGetResourceHandleFromCollection(containerHandle, 5));
1109 EXPECT_EQ(OC_STACK_OK, OCStop());
1113 TEST(StackBind, BindEntityHandlerBad)
1115 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1116 OC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1117 InitStack(OC_SERVER);
1119 OCResourceHandle handle;
1120 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1125 OC_DISCOVERABLE|OC_OBSERVABLE));
1127 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL));
1129 EXPECT_EQ(OC_STACK_OK, OCStop());
1132 TEST(StackBind, BindEntityHandlerGood)
1134 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1135 OC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1136 InitStack(OC_SERVER);
1138 OCResourceHandle handle;
1139 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1144 OC_DISCOVERABLE|OC_OBSERVABLE));
1146 OCEntityHandler myHandler = entityHandler;
1148 EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler));
1150 EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1152 EXPECT_EQ(OC_STACK_OK, OCStop());
1155 TEST(StackResourceAccess, GetResourceByIndex)
1157 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1158 OC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1159 InitStack(OC_SERVER);
1161 uint8_t numResources = 0;
1162 uint8_t numExpectedResources = InitNumExpectedResources();
1163 uint8_t resourceIndex = InitResourceIndex();
1165 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1166 EXPECT_EQ(numExpectedResources, numResources);
1168 OCResourceHandle containerHandle;
1169 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1174 OC_DISCOVERABLE|OC_OBSERVABLE));
1175 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1176 EXPECT_EQ(++numExpectedResources, numResources);
1178 OCResourceHandle handle0;
1179 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1184 OC_DISCOVERABLE|OC_OBSERVABLE));
1185 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1186 EXPECT_EQ(++numExpectedResources, numResources);
1188 OCResourceHandle handle1;
1189 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1194 OC_DISCOVERABLE|OC_OBSERVABLE));
1195 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1196 EXPECT_EQ(++numExpectedResources, numResources);
1198 OCResourceHandle handle2;
1199 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1204 OC_DISCOVERABLE|OC_OBSERVABLE));
1205 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1206 EXPECT_EQ(++numExpectedResources, numResources);
1208 OCResourceHandle handle3;
1209 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1214 OC_DISCOVERABLE|OC_OBSERVABLE));
1215 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1216 EXPECT_EQ(++numExpectedResources, numResources);
1218 OCResourceHandle handle4;
1219 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1224 OC_DISCOVERABLE|OC_OBSERVABLE));
1225 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1226 EXPECT_EQ(++numExpectedResources, numResources);
1228 OCResourceHandle handle5;
1229 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1234 OC_DISCOVERABLE|OC_OBSERVABLE));
1235 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1236 EXPECT_EQ(++numExpectedResources, numResources);
1238 EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1239 EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1240 EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1241 EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1242 EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1243 EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1244 EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1246 EXPECT_EQ(OC_STACK_OK, OCStop());
1249 TEST(StackResourceAccess, DeleteHeadResource)
1251 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1252 OC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1253 InitStack(OC_SERVER);
1255 uint8_t numResources = 0;
1256 uint8_t numExpectedResources = InitNumExpectedResources();
1258 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1259 EXPECT_EQ(numExpectedResources, numResources);
1261 OCResourceHandle handle0;
1262 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1267 OC_DISCOVERABLE|OC_OBSERVABLE));
1268 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1269 EXPECT_EQ(++numExpectedResources, numResources);
1271 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1272 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1273 EXPECT_EQ(--numExpectedResources, numResources);
1275 EXPECT_EQ(OC_STACK_OK, OCStop());
1278 TEST(StackResourceAccess, DeleteHeadResource2)
1280 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1281 OC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1282 InitStack(OC_SERVER);
1284 uint8_t numResources = 0;
1285 uint8_t numExpectedResources = InitNumExpectedResources();
1286 uint8_t resourceIndex = InitResourceIndex();
1288 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1289 EXPECT_EQ(numExpectedResources, numResources);
1291 OCResourceHandle handle0;
1292 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1297 OC_DISCOVERABLE|OC_OBSERVABLE));
1298 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1299 EXPECT_EQ(++numExpectedResources, numResources);
1301 OCResourceHandle handle1;
1302 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1307 OC_DISCOVERABLE|OC_OBSERVABLE));
1308 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1309 EXPECT_EQ(++numExpectedResources, numResources);
1311 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1312 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1313 EXPECT_EQ(--numExpectedResources, numResources);
1315 EXPECT_EQ(handle1, OCGetResourceHandle(resourceIndex));
1317 EXPECT_EQ(OC_STACK_OK, OCStop());
1321 TEST(StackResourceAccess, DeleteLastResource)
1323 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1324 OC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1325 InitStack(OC_SERVER);
1327 uint8_t numResources = 0;
1328 uint8_t numExpectedResources = InitNumExpectedResources();
1329 uint8_t resourceIndex = InitResourceIndex();
1331 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1332 EXPECT_EQ(numExpectedResources, numResources);
1334 OCResourceHandle handle0;
1335 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1340 OC_DISCOVERABLE|OC_OBSERVABLE));
1341 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1342 EXPECT_EQ(++numExpectedResources, numResources);
1344 OCResourceHandle handle1;
1345 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1350 OC_DISCOVERABLE|OC_OBSERVABLE));
1351 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1352 EXPECT_EQ(++numExpectedResources, numResources);
1354 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1355 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1356 EXPECT_EQ(--numExpectedResources, numResources);
1358 EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1360 OCResourceHandle handle2;
1361 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1366 OC_DISCOVERABLE|OC_OBSERVABLE));
1367 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1368 EXPECT_EQ(++numExpectedResources, numResources);
1370 EXPECT_EQ(OC_STACK_OK, OCStop());
1373 TEST(StackResourceAccess, DeleteMiddleResource)
1375 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1376 OC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1377 InitStack(OC_SERVER);
1379 uint8_t numResources = 0;
1380 uint8_t numExpectedResources = InitNumExpectedResources();
1381 uint8_t resourceIndex = InitResourceIndex();
1383 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1384 EXPECT_EQ(numExpectedResources, numResources);
1386 OCResourceHandle handle0;
1387 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1392 OC_DISCOVERABLE|OC_OBSERVABLE));
1393 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1394 EXPECT_EQ(++numExpectedResources, numResources);
1396 OCResourceHandle handle1;
1397 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1402 OC_DISCOVERABLE|OC_OBSERVABLE));
1403 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1404 EXPECT_EQ(++numExpectedResources, numResources);
1406 OCResourceHandle handle2;
1407 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1412 OC_DISCOVERABLE|OC_OBSERVABLE));
1413 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1414 EXPECT_EQ(++numExpectedResources, numResources);
1416 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1417 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1418 EXPECT_EQ(--numExpectedResources, numResources);
1420 EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1421 EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1423 // Make sure the resource elements are still correct
1424 uint8_t numResourceInterfaces;
1425 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1426 EXPECT_EQ(1, numResourceInterfaces);
1427 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0);
1428 EXPECT_STREQ("core.rw", resourceInterfaceName);
1430 EXPECT_EQ(OC_STACK_OK, OCStop());
1436 #endif // __cplusplus
1437 void parsePresencePayload(char* payload, uint32_t* seqNum,
1438 uint32_t* maxAge, OCPresenceTrigger* presenceTrigger, char** resType);
1441 #endif // __cplusplus
1443 TEST(StackPresence, ParsePresencePayload)
1445 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1446 OC_LOG(INFO, TAG, "Starting ParsePresencePayload test");
1449 uint32_t seqNum = 0, maxAge = 0;
1450 OCPresenceTrigger presenceTrigger = OC_PRESENCE_TRIGGER_CHANGE;
1451 char * resType = NULL;
1454 strncpy(payload, "{\"oic\":[{\"ttl\":99,\"non\":100,\"trg\":"
1455 "\"delete\",\"rt\":\"presence\"}]}", sizeof(payload));
1456 parsePresencePayload(payload, &seqNum, &maxAge,
1457 &presenceTrigger, &resType);
1458 EXPECT_TRUE(100 == seqNum);
1459 EXPECT_TRUE(99 == maxAge);
1460 EXPECT_TRUE(OC_PRESENCE_TRIGGER_DELETE == presenceTrigger);
1461 EXPECT_TRUE(NULL != resType);
1462 EXPECT_STREQ("presence", resType);
1465 presenceTrigger = OC_PRESENCE_TRIGGER_CHANGE;
1467 //Bad Scenario -- should not result in Seg Fault
1468 parsePresencePayload(payload, NULL, &maxAge, &presenceTrigger, &resType);
1471 seqNum = 0; maxAge = 0; resType = NULL;
1472 strncpy(payload, "{abracadabra}", sizeof(payload));
1473 parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1474 EXPECT_TRUE(0 == seqNum);
1475 EXPECT_TRUE(0 == maxAge);
1476 EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1477 EXPECT_TRUE(NULL == resType);
1478 EXPECT_EQ(NULL, resType);
1482 seqNum = 0; maxAge = 0; resType = NULL;
1483 strncpy(payload, "{\"oic\":[100]}", sizeof(payload));
1484 parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1485 EXPECT_TRUE(0 == seqNum);
1486 EXPECT_TRUE(0 == maxAge);
1487 EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1488 EXPECT_TRUE(NULL == resType);
1489 EXPECT_EQ(NULL, resType);
1493 seqNum = 0; maxAge = 0; resType = NULL;
1494 strncpy(payload, "{\"oic\":[]}", sizeof(payload));
1495 parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1496 EXPECT_TRUE(0 == seqNum);
1497 EXPECT_TRUE(0 == maxAge);
1498 EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1499 EXPECT_TRUE(NULL == resType);
1500 EXPECT_EQ(NULL, resType);
1504 strncpy(payload, "{:]}", sizeof(payload));
1505 parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1506 EXPECT_TRUE(0 == seqNum);
1507 EXPECT_TRUE(0 == maxAge);
1508 EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1509 EXPECT_TRUE(NULL == resType);
1510 EXPECT_EQ(NULL, resType);
1514 strncpy(payload, "{:[presence}", sizeof(payload));
1515 parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1516 EXPECT_TRUE(0 == seqNum);
1517 EXPECT_TRUE(0 == maxAge);
1518 EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1519 EXPECT_TRUE(NULL == resType);
1520 EXPECT_EQ(NULL, resType);
1524 TEST(PODTests, OCHeaderOption)
1526 EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1529 TEST(PODTests, OCCallbackData)
1531 EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);