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"
29 #include "gtest/gtest.h"
30 #include <sys/types.h>
37 //-----------------------------------------------------------------------------
39 //-----------------------------------------------------------------------------
47 #define DEFAULT_CONTEXT_VALUE 0x99
48 //-----------------------------------------------------------------------------
50 //-----------------------------------------------------------------------------
51 static const char TAG[] = "TestHarness";
53 //-----------------------------------------------------------------------------
55 //-----------------------------------------------------------------------------
56 extern "C" OCStackApplicationResult asyncDoResourcesCallback(void* ctx, OCDoHandle handle, OCClientResponse * clientResponse)
58 OC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
60 EXPECT_EQ(OC_STACK_OK, clientResponse->result);
62 if(ctx == (void*)DEFAULT_CONTEXT_VALUE) {
63 OC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
65 OC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
67 return OC_STACK_KEEP_TRANSACTION;
70 //-----------------------------------------------------------------------------
72 //-----------------------------------------------------------------------------
73 OCEntityHandlerResult entityHandler(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest)
75 OC_LOG(INFO, TAG, "Entering entityHandler");
80 //-----------------------------------------------------------------------------
82 //-----------------------------------------------------------------------------
83 void InitStack(OCMode mode)
85 OC_LOG(INFO, TAG, "Entering InitStack");
87 uint16_t port = USE_RANDOM_PORT;
89 OCGetInterfaceAddress(NULL, 0, AF_INET, addr, sizeof(addr));
90 OC_LOG_V(INFO, TAG, "InitStack on address %s",addr);
92 EXPECT_EQ(OC_STACK_OK, OCInit((char *) addr, port, mode));
93 OC_LOG(INFO, TAG, "Leaving InitStack");
96 uint8_t InitNumExpectedResources()
99 // When presence is enabled, it is a resource and so is (currently) included
100 // in the returned resource count returned by the OCGetNumberOfResources API.
107 uint8_t InitResourceIndex()
110 // When presence is enabled, it is a resource and so is (currently) included
111 // in the returned resource count returned by the OCGetNumberOfResources API.
112 // The index of the presence resource is 0, so the first user app resource index
119 //-----------------------------------------------------------------------------
121 //-----------------------------------------------------------------------------
123 TEST(StackInit, StackInitNullAddr)
125 EXPECT_EQ(OC_STACK_OK, OCInit(0, 5683, OC_SERVER));
126 EXPECT_EQ(OC_STACK_OK, OCStop());
129 TEST(StackInit, StackInitNullPort)
131 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 0, OC_SERVER));
132 EXPECT_EQ(OC_STACK_OK, OCStop());
135 TEST(StackInit, StackInitNullAddrAndPort)
137 EXPECT_EQ(OC_STACK_OK, OCInit(0, 0, OC_SERVER));
138 EXPECT_EQ(OC_STACK_OK, OCStop());
141 TEST(StackInit, StackInitInvalidMode)
143 EXPECT_EQ(OC_STACK_ERROR, OCInit(0, 0, (OCMode)10));
144 EXPECT_EQ(OC_STACK_ERROR, OCStop());
147 TEST(StackStart, StackStartSuccessClient)
149 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
150 EXPECT_EQ(OC_STACK_OK, OCStop());
153 TEST(StackStart, StackStartSuccessServer)
155 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
156 EXPECT_EQ(OC_STACK_OK, OCStop());
159 TEST(StackStart, StackStartSuccessClientServer)
161 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
162 EXPECT_EQ(OC_STACK_OK, OCStop());
165 TEST(StackStart, StackStartSuccessiveInits)
167 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
168 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.2", 5683, OC_SERVER));
169 EXPECT_EQ(OC_STACK_OK, OCStop());
172 TEST(StackDiscovery, DoResourceDeviceDiscovery)
174 OCCallbackData cbData;
177 OC_LOG(INFO, TAG, "Starting DoResourceDeviceDiscovery test ");
178 InitStack(OC_CLIENT);
180 /* Start a discovery query*/
181 char szQueryUri[64] = { 0 };
182 strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
183 cbData.cb = asyncDoResourcesCallback;
184 cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
187 EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle, OC_REST_GET, szQueryUri, 0, 0, OC_LOW_QOS, &cbData, NULL, 0));
188 EXPECT_EQ(OC_STACK_OK, OCStop());
191 TEST(StackStop, StackStopWithoutInit)
193 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
194 EXPECT_EQ(OC_STACK_OK, OCStop());
195 EXPECT_EQ(OC_STACK_ERROR, OCStop());
198 TEST(StackResource, UpdateResourceNullURI)
200 OCCallbackData cbData;
203 OC_LOG(INFO, TAG, "Starting UpdateResourceNullURI test");
204 InitStack(OC_CLIENT);
206 /* Start a discovery query*/
207 char szQueryUri[64] = { 0 };
208 strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
209 cbData.cb = asyncDoResourcesCallback;
210 cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
212 EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle, OC_REST_GET, szQueryUri, 0, 0, OC_LOW_QOS, &cbData, NULL, 0));
213 EXPECT_EQ(OC_STACK_OK, OCStop());
216 TEST(StackResource, CreateResourceBadParams)
218 OC_LOG(INFO, TAG, "Starting CreateResourceBadParams test");
219 InitStack(OC_SERVER);
221 OCResourceHandle handle;
223 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(NULL, //&handle,
228 OC_DISCOVERABLE|OC_OBSERVABLE));
230 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
235 OC_DISCOVERABLE|OC_OBSERVABLE));
237 // Property bitmask out of range
238 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
243 128));// invalid bitmask for OCResourceProperty
245 EXPECT_EQ(OC_STACK_OK, OCStop());
249 TEST(StackResource, CreateResourceSuccess)
251 OC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
252 InitStack(OC_SERVER);
254 OCResourceHandle handle;
255 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
260 OC_DISCOVERABLE|OC_OBSERVABLE));
261 const char *url = OCGetResourceUri(handle);
262 EXPECT_STREQ("/a/led", url);
264 EXPECT_EQ(OC_STACK_OK, OCStop());
267 TEST(StackResource, CreateResourceFailDuplicateUri)
269 OC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
270 InitStack(OC_SERVER);
272 OCResourceHandle handle;
273 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
278 OC_DISCOVERABLE|OC_OBSERVABLE));
279 const char *url = OCGetResourceUri(handle);
280 EXPECT_STREQ("/a/led", url);
282 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
287 OC_DISCOVERABLE|OC_OBSERVABLE));
289 EXPECT_EQ(OC_STACK_OK, OCStop());
292 TEST(StackResource, CreateResourceMultipleResources)
294 OC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
295 InitStack(OC_SERVER);
297 OCResourceHandle handle1;
298 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
303 OC_DISCOVERABLE|OC_OBSERVABLE));
305 OCResourceHandle handle2;
306 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
311 OC_DISCOVERABLE|OC_OBSERVABLE));
312 OCResourceHandle handle3;
313 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
318 OC_DISCOVERABLE|OC_OBSERVABLE));
320 const char *url = OCGetResourceUri(handle1);
321 EXPECT_STREQ("/a/led1", url);
323 url = OCGetResourceUri(handle2);
324 EXPECT_STREQ("/a/led2", url);
326 url = OCGetResourceUri(handle3);
327 EXPECT_STREQ("/a/led3", url);
329 EXPECT_EQ(OC_STACK_OK, OCStop());
332 TEST(StackResource, CreateResourceBadResoureType)
334 OC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
335 InitStack(OC_SERVER);
337 OCResourceHandle handle;
338 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
343 OC_DISCOVERABLE|OC_OBSERVABLE));
345 EXPECT_EQ(OC_STACK_OK, OCStop());
348 TEST(StackResource, CreateResourceGoodResourceType)
350 OC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
351 InitStack(OC_SERVER);
353 OCResourceHandle handle;
354 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
359 OC_DISCOVERABLE|OC_OBSERVABLE));
361 EXPECT_EQ(OC_STACK_OK, OCStop());
364 TEST(StackResource, ResourceTypeName)
366 OC_LOG(INFO, TAG, "Starting ResourceTypeName test");
367 InitStack(OC_SERVER);
369 OCResourceHandle handle;
370 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
375 OC_DISCOVERABLE|OC_OBSERVABLE));
377 uint8_t numResourceTypes;
378 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
379 EXPECT_EQ(1, numResourceTypes);
380 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
381 EXPECT_STREQ("core.led", resourceTypeName);
383 // try getting resource type names with an invalid index
384 resourceTypeName = OCGetResourceTypeName(handle, 1);
385 EXPECT_STREQ(NULL, resourceTypeName);
386 // try getting resource type names with an invalid index
387 resourceTypeName = OCGetResourceTypeName(handle, 10);
388 EXPECT_STREQ(NULL, resourceTypeName);
390 EXPECT_EQ(OC_STACK_OK, OCStop());
393 TEST(StackResource, ResourceTypeAttrRepresentation)
395 OC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
396 InitStack(OC_SERVER);
398 OCResourceHandle handle;
399 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
404 OC_DISCOVERABLE|OC_OBSERVABLE));
406 uint8_t numResourceTypes;
407 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
408 EXPECT_EQ(1, numResourceTypes);
410 EXPECT_EQ(OC_STACK_OK, OCStop());
413 TEST(StackResource, ResourceTypeInterface)
415 OC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
416 InitStack(OC_SERVER);
418 OCResourceHandle handle;
419 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
424 OC_DISCOVERABLE|OC_OBSERVABLE));
426 uint8_t numResourceInterfaces;
427 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
428 EXPECT_EQ(1, numResourceInterfaces);
429 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
430 EXPECT_STREQ("core.rw", resourceInterfaceName);
432 // try getting resource interface names with an invalid index
433 resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
434 EXPECT_STREQ(NULL, resourceInterfaceName);
435 // try getting resource interface names with an invalid index
436 resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
437 EXPECT_STREQ(NULL, resourceInterfaceName);
439 EXPECT_EQ(OC_STACK_OK, OCStop());
442 TEST(StackResource, ResourceTypeInterfaceMethods)
444 OC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
445 InitStack(OC_SERVER);
447 OCResourceHandle handle;
448 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
453 OC_DISCOVERABLE|OC_OBSERVABLE));
455 uint8_t numResourceInterfaces;
456 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
457 EXPECT_EQ(1, numResourceInterfaces);
459 EXPECT_EQ(OC_STACK_OK, OCStop());
462 TEST(StackResource, GetResourceProperties)
464 OC_LOG(INFO, TAG, "Starting GetResourceProperties test");
465 InitStack(OC_SERVER);
467 OCResourceHandle handle;
468 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
473 OC_DISCOVERABLE|OC_OBSERVABLE));
475 EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
476 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
478 EXPECT_EQ(OC_STACK_OK, OCStop());
481 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
483 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
484 InitStack(OC_SERVER);
486 OCResourceHandle handle;
487 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
492 OC_DISCOVERABLE|OC_OBSERVABLE));
493 const char *url = OCGetResourceUri(handle);
494 EXPECT_STREQ("/a1/led", url);
496 //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
497 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
498 uint8_t numResources = 0;
499 uint8_t numExpectedResources = InitNumExpectedResources();
501 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
502 EXPECT_EQ(numExpectedResources, numResources);
504 EXPECT_EQ(OC_STACK_OK, OCStop());
507 TEST(StackResource, StackTestResourceDiscoverOneResource)
509 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
510 InitStack(OC_SERVER);
512 OCResourceHandle handle;
513 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
518 OC_DISCOVERABLE|OC_OBSERVABLE));
519 const char *url = OCGetResourceUri(handle);
520 EXPECT_STREQ("/a/led", url);
522 //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
523 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
525 EXPECT_EQ(OC_STACK_OK, OCStop());
528 TEST(StackResource, StackTestResourceDiscoverManyResources)
530 OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
531 InitStack(OC_SERVER);
533 OCResourceHandle handle1;
534 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
540 const char *url = OCGetResourceUri(handle1);
541 EXPECT_STREQ("/a/led1", url);
543 OCResourceHandle handle2;
544 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
549 OC_DISCOVERABLE|OC_OBSERVABLE));
550 url = OCGetResourceUri(handle2);
551 EXPECT_STREQ("/a/led2", url);
553 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
554 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
556 OCResourceHandle handle3;
557 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
562 OC_DISCOVERABLE|OC_OBSERVABLE));
563 url = OCGetResourceUri(handle3);
564 EXPECT_STREQ("/a/led3", url);
566 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, "oc.mi.ll"));
567 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, "oc.mi.b"));
569 OCResourceHandle handle4;
570 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
576 url = OCGetResourceUri(handle4);
577 EXPECT_STREQ("/a/led4", url);
579 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
580 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, "oc.mi.ll"));
581 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, "oc.mi.b"));
583 //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
585 EXPECT_EQ(OC_STACK_OK, OCStop());
588 TEST(StackBind, BindResourceTypeNameBad)
590 OC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
591 InitStack(OC_SERVER);
593 OCResourceHandle handle;
594 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
599 OC_DISCOVERABLE|OC_OBSERVABLE));
601 uint8_t numResourceTypes;
602 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
603 EXPECT_EQ(1, numResourceTypes);
604 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
605 EXPECT_STREQ("core.led", resourceTypeName);
607 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
609 EXPECT_EQ(OC_STACK_OK, OCStop());
612 TEST(StackBind, BindResourceTypeNameGood)
614 OC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
615 InitStack(OC_SERVER);
617 OCResourceHandle handle;
618 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
623 OC_DISCOVERABLE|OC_OBSERVABLE));
625 uint8_t numResourceTypes;
626 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
627 EXPECT_EQ(1, numResourceTypes);
628 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
629 EXPECT_STREQ("core.led", resourceTypeName);
631 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
632 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
633 EXPECT_EQ(2, numResourceTypes);
634 resourceTypeName = OCGetResourceTypeName(handle, 1);
635 EXPECT_STREQ("core.brightled", resourceTypeName);
637 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
638 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
639 EXPECT_EQ(3, numResourceTypes);
640 resourceTypeName = OCGetResourceTypeName(handle, 2);
641 EXPECT_STREQ("core.reallybrightled", resourceTypeName);
643 EXPECT_EQ(OC_STACK_OK, OCStop());
646 TEST(StackBind, BindResourceTypeAttribRepGood)
648 OC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
649 InitStack(OC_SERVER);
651 OCResourceHandle handle;
652 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
657 OC_DISCOVERABLE|OC_OBSERVABLE));
659 uint8_t numResourceTypes;
660 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
661 EXPECT_EQ(1, numResourceTypes);
663 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
664 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
665 EXPECT_EQ(2, numResourceTypes);
667 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
668 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
669 EXPECT_EQ(3, numResourceTypes);
671 EXPECT_EQ(OC_STACK_OK, OCStop());
675 TEST(StackBind, BindResourceInterfaceNameBad)
677 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
678 InitStack(OC_SERVER);
680 OCResourceHandle handle;
681 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
686 OC_DISCOVERABLE|OC_OBSERVABLE));
688 uint8_t numResourceInterfaces;
689 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
690 EXPECT_EQ(1, numResourceInterfaces);
691 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
692 EXPECT_STREQ("core.rw", resourceInterfaceName);
694 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
696 EXPECT_EQ(OC_STACK_OK, OCStop());
699 TEST(StackBind, BindResourceInterfaceNameGood)
701 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
702 InitStack(OC_SERVER);
704 OCResourceHandle handle;
705 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
710 OC_DISCOVERABLE|OC_OBSERVABLE));
712 uint8_t numResourceInterfaces;
713 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
714 EXPECT_EQ(1, numResourceInterfaces);
715 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
716 EXPECT_STREQ("core.rw", resourceInterfaceName);
718 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
720 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
721 EXPECT_EQ(2, numResourceInterfaces);
722 resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
723 EXPECT_STREQ("core.r", resourceInterfaceName);
725 EXPECT_EQ(OC_STACK_OK, OCStop());
728 TEST(StackBind, BindResourceInterfaceMethodsBad)
730 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
731 InitStack(OC_SERVER);
733 OCResourceHandle handle;
734 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
739 OC_DISCOVERABLE|OC_OBSERVABLE));
741 uint8_t numResourceInterfaces;
742 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
743 EXPECT_EQ(1, numResourceInterfaces);
745 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
747 EXPECT_EQ(OC_STACK_OK, OCStop());
750 TEST(StackBind, BindResourceInterfaceMethodsGood)
752 OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
753 InitStack(OC_SERVER);
755 OCResourceHandle handle;
756 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
761 OC_DISCOVERABLE|OC_OBSERVABLE));
763 uint8_t numResourceInterfaces;
764 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
765 EXPECT_EQ(1, numResourceInterfaces);
767 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
769 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
770 EXPECT_EQ(2, numResourceInterfaces);
772 EXPECT_EQ(OC_STACK_OK, OCStop());
775 TEST(StackBind, BindContainedResourceBad)
777 OC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
778 InitStack(OC_SERVER);
780 OCResourceHandle containerHandle;
781 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
786 OC_DISCOVERABLE|OC_OBSERVABLE));
788 OCResourceHandle handle0;
789 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
794 OC_DISCOVERABLE|OC_OBSERVABLE));
796 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
798 EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
800 EXPECT_EQ(OC_STACK_OK, OCStop());
803 TEST(StackBind, BindContainedResourceGood)
805 OC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
806 InitStack(OC_SERVER);
808 uint8_t numResources = 0;
809 uint8_t numExpectedResources = InitNumExpectedResources();
811 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
812 EXPECT_EQ(numExpectedResources, numResources);
814 OCResourceHandle containerHandle;
815 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
820 OC_DISCOVERABLE|OC_OBSERVABLE));
821 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
822 EXPECT_EQ(++numExpectedResources, numResources);
824 OCResourceHandle handle0;
825 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
830 OC_DISCOVERABLE|OC_OBSERVABLE));
831 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
832 EXPECT_EQ(++numExpectedResources, numResources);
834 OCResourceHandle handle1;
835 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
840 OC_DISCOVERABLE|OC_OBSERVABLE));
841 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
842 EXPECT_EQ(++numExpectedResources, numResources);
844 OCResourceHandle handle2;
845 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
850 OC_DISCOVERABLE|OC_OBSERVABLE));
851 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
852 EXPECT_EQ(++numExpectedResources, numResources);
854 OCResourceHandle handle3;
855 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
860 OC_DISCOVERABLE|OC_OBSERVABLE));
861 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
862 EXPECT_EQ(++numExpectedResources, numResources);
864 OCResourceHandle handle4;
865 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
870 OC_DISCOVERABLE|OC_OBSERVABLE));
871 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
872 EXPECT_EQ(++numExpectedResources, numResources);
874 OCResourceHandle handle5;
875 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
880 OC_DISCOVERABLE|OC_OBSERVABLE));
881 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
882 EXPECT_EQ(++numExpectedResources, numResources);
885 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
886 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
887 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
888 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
889 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
890 EXPECT_EQ(OC_STACK_ERROR, OCBindResource(containerHandle, handle5));
892 EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
893 EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
894 EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
895 EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
896 EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
898 EXPECT_EQ(NULL, OCGetResourceHandleFromCollection(containerHandle, 5));
900 EXPECT_EQ(OC_STACK_OK, OCStop());
904 TEST(StackBind, BindEntityHandlerBad)
906 OC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
907 InitStack(OC_SERVER);
909 OCResourceHandle handle;
910 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
915 OC_DISCOVERABLE|OC_OBSERVABLE));
917 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL));
919 EXPECT_EQ(OC_STACK_OK, OCStop());
922 TEST(StackBind, BindEntityHandlerGood)
924 OC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
925 InitStack(OC_SERVER);
927 OCResourceHandle handle;
928 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
933 OC_DISCOVERABLE|OC_OBSERVABLE));
935 OCEntityHandler myHandler = entityHandler;
937 EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler));
939 EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
941 EXPECT_EQ(OC_STACK_OK, OCStop());
944 TEST(StackResourceAccess, GetResourceByIndex)
946 OC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
947 InitStack(OC_SERVER);
949 uint8_t numResources = 0;
950 uint8_t numExpectedResources = InitNumExpectedResources();
951 uint8_t resourceIndex = InitResourceIndex();
953 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
954 EXPECT_EQ(numExpectedResources, numResources);
956 OCResourceHandle containerHandle;
957 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
962 OC_DISCOVERABLE|OC_OBSERVABLE));
963 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
964 EXPECT_EQ(++numExpectedResources, numResources);
966 OCResourceHandle handle0;
967 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
972 OC_DISCOVERABLE|OC_OBSERVABLE));
973 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
974 EXPECT_EQ(++numExpectedResources, numResources);
976 OCResourceHandle handle1;
977 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
982 OC_DISCOVERABLE|OC_OBSERVABLE));
983 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
984 EXPECT_EQ(++numExpectedResources, numResources);
986 OCResourceHandle handle2;
987 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
992 OC_DISCOVERABLE|OC_OBSERVABLE));
993 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
994 EXPECT_EQ(++numExpectedResources, numResources);
996 OCResourceHandle handle3;
997 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1002 OC_DISCOVERABLE|OC_OBSERVABLE));
1003 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1004 EXPECT_EQ(++numExpectedResources, numResources);
1006 OCResourceHandle handle4;
1007 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1012 OC_DISCOVERABLE|OC_OBSERVABLE));
1013 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1014 EXPECT_EQ(++numExpectedResources, numResources);
1016 OCResourceHandle handle5;
1017 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1022 OC_DISCOVERABLE|OC_OBSERVABLE));
1023 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1024 EXPECT_EQ(++numExpectedResources, numResources);
1026 EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1027 EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1028 EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1029 EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1030 EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1031 EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1032 EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1034 EXPECT_EQ(OC_STACK_OK, OCStop());
1037 TEST(StackResourceAccess, DeleteHeadResource)
1039 OC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1040 InitStack(OC_SERVER);
1042 uint8_t numResources = 0;
1043 uint8_t numExpectedResources = InitNumExpectedResources();
1045 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1046 EXPECT_EQ(numExpectedResources, numResources);
1048 OCResourceHandle handle0;
1049 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1054 OC_DISCOVERABLE|OC_OBSERVABLE));
1055 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1056 EXPECT_EQ(++numExpectedResources, numResources);
1058 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1059 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1060 EXPECT_EQ(--numExpectedResources, numResources);
1062 EXPECT_EQ(OC_STACK_OK, OCStop());
1065 TEST(StackResourceAccess, DeleteHeadResource2)
1067 OC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1068 InitStack(OC_SERVER);
1070 uint8_t numResources = 0;
1071 uint8_t numExpectedResources = InitNumExpectedResources();
1072 uint8_t resourceIndex = InitResourceIndex();
1074 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1075 EXPECT_EQ(numExpectedResources, numResources);
1077 OCResourceHandle handle0;
1078 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1083 OC_DISCOVERABLE|OC_OBSERVABLE));
1084 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1085 EXPECT_EQ(++numExpectedResources, numResources);
1087 OCResourceHandle handle1;
1088 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1093 OC_DISCOVERABLE|OC_OBSERVABLE));
1094 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1095 EXPECT_EQ(++numExpectedResources, numResources);
1097 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1098 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1099 EXPECT_EQ(--numExpectedResources, numResources);
1101 EXPECT_EQ(handle1, OCGetResourceHandle(resourceIndex));
1103 EXPECT_EQ(OC_STACK_OK, OCStop());
1107 TEST(StackResourceAccess, DeleteLastResource)
1109 OC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1110 InitStack(OC_SERVER);
1112 uint8_t numResources = 0;
1113 uint8_t numExpectedResources = InitNumExpectedResources();
1114 uint8_t resourceIndex = InitResourceIndex();
1116 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1117 EXPECT_EQ(numExpectedResources, numResources);
1119 OCResourceHandle handle0;
1120 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1125 OC_DISCOVERABLE|OC_OBSERVABLE));
1126 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1127 EXPECT_EQ(++numExpectedResources, numResources);
1129 OCResourceHandle handle1;
1130 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1135 OC_DISCOVERABLE|OC_OBSERVABLE));
1136 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1137 EXPECT_EQ(++numExpectedResources, numResources);
1139 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1140 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1141 EXPECT_EQ(--numExpectedResources, numResources);
1143 EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1145 OCResourceHandle handle2;
1146 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1151 OC_DISCOVERABLE|OC_OBSERVABLE));
1152 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1153 EXPECT_EQ(++numExpectedResources, numResources);
1155 EXPECT_EQ(OC_STACK_OK, OCStop());
1158 TEST(StackResourceAccess, DeleteMiddleResource)
1160 OC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1161 InitStack(OC_SERVER);
1163 uint8_t numResources = 0;
1164 uint8_t numExpectedResources = InitNumExpectedResources();
1165 uint8_t resourceIndex = InitResourceIndex();
1167 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1168 EXPECT_EQ(numExpectedResources, numResources);
1170 OCResourceHandle handle0;
1171 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1176 OC_DISCOVERABLE|OC_OBSERVABLE));
1177 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1178 EXPECT_EQ(++numExpectedResources, numResources);
1180 OCResourceHandle handle1;
1181 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1186 OC_DISCOVERABLE|OC_OBSERVABLE));
1187 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1188 EXPECT_EQ(++numExpectedResources, numResources);
1190 OCResourceHandle handle2;
1191 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1196 OC_DISCOVERABLE|OC_OBSERVABLE));
1197 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1198 EXPECT_EQ(++numExpectedResources, numResources);
1200 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1201 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1202 EXPECT_EQ(--numExpectedResources, numResources);
1204 EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1205 EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1207 // Make sure the resource elements are still correct
1208 uint8_t numResourceInterfaces;
1209 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1210 EXPECT_EQ(1, numResourceInterfaces);
1211 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0);
1212 EXPECT_STREQ("core.rw", resourceInterfaceName);
1214 EXPECT_EQ(OC_STACK_OK, OCStop());
1218 TEST(StackTest, StackTestResourceDiscoverIfFilteringBad) {
1220 uint16_t port = USE_RANDOM_PORT;
1221 uint8_t ifname[] = "eth0";
1222 char uri[] = "/oc/core";
1223 char query[] = "if";
1224 char req[1024] = {};
1225 char rsp[1024] = {};
1226 //OCServerRequestResult res;
1228 //EXPECT_EQ(OC_STACK_INVALID_QUERY, OCHandleServerRequest(&res, uri, query, req, rsp));
1231 TEST(StackTest, StackTestResourceDiscoverRtFilteringBad) {
1233 uint16_t port = USE_RANDOM_PORT;
1234 uint8_t ifname[] = "eth0";
1235 char uri[] = "/oc/core";
1236 char query[] = "rt";
1237 char req[1024] = {};
1238 char rsp[1024] = {};
1239 //OCServerRequestResult res;
1241 //EXPECT_EQ(OC_STACK_INVALID_QUERY, OCHandleServerRequest(&res, uri, query, req, rsp));
1243 TEST(StackTest, StackTestResourceDiscoverIfFiltering) {
1245 uint16_t port = USE_RANDOM_PORT;
1246 uint8_t ifname[] = "eth0";
1247 char uri[] = "/oc/core";
1248 char query[] = "if=oc.mi.ll";
1249 char req[1024] = {};
1250 char rsp[1024] = {};
1251 //OCServerRequestResult res;
1253 //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1256 TEST(StackTest, StackTestResourceDiscoverRtFiltering) {
1258 uint16_t port = USE_RANDOM_PORT;
1259 uint8_t ifname[] = "eth0";
1260 char uri[] = "/oc/core";
1261 char query[] = "rt=core.brightled";
1262 char req[1024] = {};
1263 char rsp[1024] = {};
1264 //OCServerRequestResult res;
1266 //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));