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 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
24 #include "ocpayload.h"
26 #include "ocstackinternal.h"
28 #include "oic_malloc.h"
29 #include "oic_string.h"
33 #include "gtest/gtest.h"
34 #include <sys/types.h>
43 //-----------------------------------------------------------------------------
45 //-----------------------------------------------------------------------------
52 #include "gtest_helper.h"
56 namespace itst = iotivity::test;
58 #define DEFAULT_CONTEXT_VALUE 0x99
60 //-----------------------------------------------------------------------------
62 //-----------------------------------------------------------------------------
63 static const char TAG[] = "TestHarness";
65 char gDeviceUUID[] = "myDeviceUUID";
66 char gManufacturerName[] = "myName";
68 static char pinNumber;
69 static OCDPDev_t peer;
71 std::chrono::seconds const SHORT_TEST_TIMEOUT = std::chrono::seconds(5);
72 std::chrono::seconds const LONG_TEST_TIMEOUT = std::chrono::seconds(300);
74 //-----------------------------------------------------------------------------
76 //-----------------------------------------------------------------------------
77 extern "C" OCStackApplicationResult asyncDoResourcesCallback(void* ctx,
78 OCDoHandle /*handle*/, OCClientResponse * clientResponse)
80 OIC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
82 EXPECT_EQ(OC_STACK_OK, clientResponse->result);
84 if(ctx == (void*)DEFAULT_CONTEXT_VALUE) {
85 OIC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
87 OIC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
89 return OC_STACK_KEEP_TRANSACTION;
92 static void resultCallback(void *UNUSED1, OCDPDev_t *UNUSED2, OCStackResult UNUSED3)
99 extern "C" OCStackApplicationResult discoveryCallback(void* ctx,
100 OCDoHandle /*handle*/, OCClientResponse * clientResponse)
102 OIC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
104 EXPECT_EQ(OC_STACK_OK, clientResponse->result);
106 if(ctx == (void*)DEFAULT_CONTEXT_VALUE)
108 OIC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
111 OIC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
113 OCDiscoveryPayload *discoveryPayload = ((OCDiscoveryPayload *) clientResponse->payload);
114 EXPECT_TRUE(discoveryPayload != NULL);
115 OCResourcePayload *res = discoveryPayload->resources;
117 for (OCResourcePayload *res1 = discoveryPayload->resources; res1; res1 = res1->next)
122 EXPECT_EQ("/a/led1", res->uri);
124 EXPECT_EQ("/a/led2", res->uri);
126 EXPECT_EQ("/a/led3", res->uri);
128 EXPECT_TRUE(res == NULL);
130 return OC_STACK_KEEP_TRANSACTION;
133 //-----------------------------------------------------------------------------
135 //-----------------------------------------------------------------------------
136 OCEntityHandlerResult entityHandler(OCEntityHandlerFlag /*flag*/,
137 OCEntityHandlerRequest * /*entityHandlerRequest*/,
138 void* /*callbackParam*/)
140 OIC_LOG(INFO, TAG, "Entering entityHandler");
145 //-----------------------------------------------------------------------------
147 //-----------------------------------------------------------------------------
148 void InitStack(OCMode mode)
150 OIC_LOG(INFO, TAG, "Entering InitStack");
152 EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, mode));
153 OIC_LOG(INFO, TAG, "Leaving InitStack");
156 uint8_t InitNumExpectedResources()
159 // When presence is enabled, it is a resource and so is (currently) included
160 // in the returned resource count returned by the OCGetNumberOfResources API.
167 uint8_t InitResourceIndex()
170 // When presence is enabled, it is a resource and so is (currently) included
171 // in the returned resource count returned by the OCGetNumberOfResources API.
172 // The index of the presence resource is 0, so the first user app resource index
183 Callback(OCClientResponseHandler cb) : m_cb(cb), m_called(false)
185 m_cbData.cb = &Callback::handler;
187 m_cbData.context = this;
189 void Wait(long waitTime)
191 uint64_t startTime = OICGetCurrentTime(TIME_IN_MS);
194 uint64_t currTime = OICGetCurrentTime(TIME_IN_MS);
195 long elapsed = (long)((currTime - startTime) / MS_PER_SEC);
196 if (elapsed > waitTime)
203 operator OCCallbackData *()
208 OCCallbackData m_cbData;
209 OCClientResponseHandler m_cb;
211 static OCStackApplicationResult handler(void *ctx, OCDoHandle handle, OCClientResponse *clientResponse)
213 Callback *callback = (Callback *) ctx;
214 OCStackApplicationResult result = callback->m_cb(NULL, handle, clientResponse);
215 callback->m_called = true;
220 class OCDiscoverTests : public testing::Test
225 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
228 virtual void TearDown()
233 //-----------------------------------------------------------------------------
235 //-----------------------------------------------------------------------------
237 TEST(StackInit, StackInitNullAddr)
239 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
240 EXPECT_EQ(OC_STACK_OK, OCInit(0, 5683, OC_SERVER));
241 EXPECT_EQ(OC_STACK_OK, OCStop());
244 TEST(StackInit, StackInitNullPort)
246 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
247 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 0, OC_SERVER));
248 EXPECT_EQ(OC_STACK_OK, OCStop());
251 TEST(StackInit, StackInitNullAddrAndPort)
253 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
254 EXPECT_EQ(OC_STACK_OK, OCInit(0, 0, OC_SERVER));
255 EXPECT_EQ(OC_STACK_OK, OCStop());
258 TEST(StackInit, StackInitInvalidMode)
260 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
261 EXPECT_EQ(OC_STACK_ERROR, OCInit(0, 0, (OCMode)10));
262 EXPECT_EQ(OC_STACK_ERROR, OCStop());
265 TEST(StackStart, StackStartSuccessClient)
267 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
268 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
269 EXPECT_EQ(OC_STACK_OK, OCStop());
272 TEST(StackStart, StackStartSuccessServer)
274 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
275 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
276 EXPECT_EQ(OC_STACK_OK, OCStop());
279 TEST(StackStart, StackStartSuccessClientServer)
281 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
282 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
283 EXPECT_EQ(OC_STACK_OK, OCStop());
286 TEST(StackStart, StackStartSuccessServerThenClient)
288 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
289 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
290 EXPECT_EQ(OC_STACK_OK, OCStop());
291 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
292 EXPECT_EQ(OC_STACK_OK, OCStop());
295 TEST(StackStart, StackStartSuccessClientThenServer)
297 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
298 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
299 EXPECT_EQ(OC_STACK_OK, OCStop());
300 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
301 EXPECT_EQ(OC_STACK_OK, OCStop());
304 TEST(StackStart, StackStartSuccessiveInits)
306 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
307 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
308 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.2", 5683, OC_SERVER));
309 EXPECT_EQ(OC_STACK_OK, OCStop());
312 TEST(StackStart, SetPlatformInfoValid)
314 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
315 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
317 OCPlatformInfo info =
321 0, 0, 0, 0, 0, 0, 0, 0, 0
323 EXPECT_EQ(OC_STACK_OK, OCSetPlatformInfo(info));
324 EXPECT_EQ(OC_STACK_OK, OCStop());
327 TEST(StackStart, SetPlatformInfoWithClientMode)
329 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
330 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
332 OCPlatformInfo info =
336 0, 0, 0, 0, 0, 0, 0, 0, 0
338 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
339 EXPECT_EQ(OC_STACK_OK, OCStop());
342 TEST(StackStart, SetPlatformInfoWithNoPlatformID)
344 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
345 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
347 OCPlatformInfo info =
351 0, 0, 0, 0, 0, 0, 0, 0, 0
354 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
355 EXPECT_EQ(OC_STACK_OK, OCStop());
358 TEST(StackStart, SetPlatformInfoWithNoManufacturerName)
360 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
361 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
363 OCPlatformInfo info =
366 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
369 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
370 EXPECT_EQ(OC_STACK_OK, OCStop());
373 TEST(StackStart, SetPlatformInfoWithZeroLengthManufacturerName)
375 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
376 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
378 OCPlatformInfo info =
381 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
383 info.manufacturerName = (char *) "";
385 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
386 EXPECT_EQ(OC_STACK_OK, OCStop());
389 TEST(StackStart, SetPlatformInfoWithTooLongManufacName)
391 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
392 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
393 char gTooLongManufacturerName[MAX_PLATFORM_NAME_LENGTH+2];
394 for (int i = 0; i <= MAX_PLATFORM_NAME_LENGTH; i++ )
396 gTooLongManufacturerName[i] = 'a';
398 gTooLongManufacturerName[MAX_PLATFORM_NAME_LENGTH+1] = '\0';
399 OCPlatformInfo info =
402 gTooLongManufacturerName,
403 0, 0, 0, 0, 0, 0, 0, 0, 0
406 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
407 EXPECT_EQ(OC_STACK_OK, OCStop());
410 TEST(StackStart, SetPlatformInfoWithTooLongManufacURL)
412 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
413 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
414 char gManufacturerUrl[MAX_PLATFORM_URL_LENGTH+2];
415 for (int i = 0; i <= MAX_PLATFORM_URL_LENGTH; i++ )
417 gManufacturerUrl[i] = 'a';
419 gManufacturerUrl[MAX_PLATFORM_URL_LENGTH+1] = '\0';
420 OCPlatformInfo info =
425 0, 0, 0, 0, 0, 0, 0, 0
428 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
429 EXPECT_EQ(OC_STACK_OK, OCStop());
432 TEST(StackStart, SetPlatformInfoWithOCSetPropertyValueAPI)
434 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
435 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
436 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, gDeviceUUID));
437 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, gManufacturerName));
438 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, "http://www.iotivity.org"));
439 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, "S777"));
440 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, "15 Nov, 2016"));
441 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, "1.1"));
442 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, "14"));
443 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, "0.1"));
444 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, "0.1"));
445 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, "http://www.iotivity.org"));
446 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, ""));
447 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", "value"));
448 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, NULL, ""));
449 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL));
450 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL));
451 EXPECT_EQ(OC_STACK_OK, OCStop());
454 TEST(StackStart, GetPlatformInfoWithOCGetPropertyValueAPI)
456 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
457 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
458 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, gDeviceUUID));
459 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, gManufacturerName));
460 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, "http://www.iotivity.org"));
461 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, "S777"));
462 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, "15 Nov, 2016"));
463 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, "1.1"));
464 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, "14"));
465 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, "0.1"));
466 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, "0.1"));
467 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, "http://www.iotivity.org"));
468 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, ""));
469 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", "value"));
472 EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, &value));
473 ASSERT_TRUE(value != NULL);
474 EXPECT_STREQ(gDeviceUUID, (char *)value);
478 EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, &value));
479 ASSERT_TRUE(value != NULL);
480 EXPECT_STREQ(gManufacturerName, (char *)value);
484 EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, &value));
485 ASSERT_TRUE(value != NULL);
486 EXPECT_STREQ("http://www.iotivity.org", (char *)value);
490 EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, &value));
491 ASSERT_TRUE(value != NULL);
492 EXPECT_STREQ("S777", (char *)value);
496 EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, &value));
497 ASSERT_TRUE(value != NULL);
498 EXPECT_STREQ("15 Nov, 2016", (char *)value);
502 EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, &value));
503 ASSERT_TRUE(value != NULL);
504 EXPECT_STREQ("1.1", (char *)value);
508 EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, &value));
509 ASSERT_TRUE(value != NULL);
510 EXPECT_STREQ("14", (char *)value);
514 EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, &value));
515 ASSERT_TRUE(value != NULL);
516 EXPECT_STREQ("0.1", (char *)value);
520 EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, &value));
521 ASSERT_TRUE(value != NULL);
522 EXPECT_STREQ("0.1", (char *)value);
526 EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, &value));
527 ASSERT_TRUE(value != NULL);
528 EXPECT_STREQ("http://www.iotivity.org", (char *)value);
532 EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, &value));
533 ASSERT_TRUE(value != NULL);
534 EXPECT_STREQ("", (char *)value);
538 EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", &value));
539 ASSERT_TRUE(value != NULL);
540 EXPECT_STREQ("value", (char *)value);
543 EXPECT_EQ(OC_STACK_OK, OCStop());
546 TEST(StackStart, SetDeviceInfoAPI)
548 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
549 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
550 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, "Sample"));
551 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, "specVersion"));
552 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", "value"));
553 OCStringLL *dataModelVersions = OCCreateOCStringLL("Data Model Version");
554 EXPECT_TRUE(dataModelVersions != NULL);
555 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION, dataModelVersions));
556 OCFreeOCStringLL(dataModelVersions);
557 OCResourceHandle handle = OCGetResourceHandleAtUri(OC_RSRVD_DEVICE_URI);
558 EXPECT_TRUE(handle != NULL);
559 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "oic.wk.tv"));
560 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL));
561 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, "", NULL));
562 EXPECT_EQ(OC_STACK_OK, OCStop());
565 TEST(StackStart, GetDeviceInfoAPI)
567 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
568 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
569 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, "Sample"));
570 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, "specVersion"));
571 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", "value"));
572 OCStringLL *dataModelVersions = OCCreateOCStringLL("Data Model Version");
573 EXPECT_TRUE(dataModelVersions != NULL);
574 EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION, dataModelVersions));
575 OCFreeOCStringLL(dataModelVersions);
576 OCResourceHandle handle = OCGetResourceHandleAtUri(OC_RSRVD_DEVICE_URI);
577 EXPECT_TRUE(handle != NULL);
578 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "oic.wk.tv"));
581 EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, &value));
582 ASSERT_TRUE(value != NULL);
583 EXPECT_STREQ("Sample", (char *)value);
587 EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, &value));
588 ASSERT_TRUE(value != NULL);
589 EXPECT_STREQ("specVersion", (char *)value);
593 EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", &value));
594 ASSERT_TRUE(value != NULL);
595 EXPECT_STREQ("value", (char *)value);
599 EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION, &value));
600 ASSERT_TRUE(value != NULL);
601 ASSERT_TRUE(((OCStringLL *)value)->value);
602 EXPECT_STREQ("Data Model Version", ((OCStringLL *)value)->value);
603 OCFreeOCStringLL((OCStringLL *) value);
606 EXPECT_STREQ("oic.wk.d", OCGetResourceTypeName(handle, 0));
607 EXPECT_STREQ("oic.wk.tv", OCGetResourceTypeName(handle, 1));
609 EXPECT_EQ(OC_STACK_OK, OCStop());
612 TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery)
614 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
615 OCCallbackData cbData;
618 OIC_LOG(INFO, TAG, "Starting DoResourceDeviceDiscovery test ");
619 InitStack(OC_CLIENT);
621 /* Start a discovery query*/
622 char szQueryUri[MAX_QUERY_LENGTH] = { 0 };
623 OICStrcpy(szQueryUri, MAX_QUERY_LENGTH, OC_RSRVD_WELL_KNOWN_URI);
624 cbData.cb = asyncDoResourcesCallback;
625 cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
627 EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
637 EXPECT_EQ(OC_STACK_OK, OCStop());
640 TEST(StackStop, StackStopWithoutInit)
642 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
643 EXPECT_EQ(OC_STACK_ERROR, OCStop());
646 TEST(StackStop, StackStopRepeated)
648 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
649 EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
650 EXPECT_EQ(OC_STACK_OK, OCStop());
651 EXPECT_EQ(OC_STACK_ERROR, OCStop());
654 TEST(StackResource, DISABLED_UpdateResourceNullURI)
656 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
657 OCCallbackData cbData;
660 OIC_LOG(INFO, TAG, "Starting UpdateResourceNullURI test");
661 InitStack(OC_CLIENT);
663 /* Start a discovery query*/
664 char szQueryUri[MAX_QUERY_LENGTH] = { 0 };
665 OICStrcpy(szQueryUri, MAX_QUERY_LENGTH, OC_RSRVD_WELL_KNOWN_URI);
666 cbData.cb = asyncDoResourcesCallback;
667 cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
669 EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
679 EXPECT_EQ(OC_STACK_OK, OCStop());
682 TEST(StackResource, CreateResourceBadParams)
684 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
685 OIC_LOG(INFO, TAG, "Starting CreateResourceBadParams test");
686 InitStack(OC_SERVER);
688 OCResourceHandle handle;
690 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(NULL, //&handle,
696 OC_DISCOVERABLE|OC_OBSERVABLE));
698 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
704 OC_DISCOVERABLE|OC_OBSERVABLE));
706 // Property bitmask out of range
707 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
713 255));// invalid bitmask for OCResourceProperty
715 EXPECT_EQ(OC_STACK_OK, OCStop());
718 TEST(StackResource, CreateResourceBadUri)
720 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
721 OIC_LOG(INFO, TAG, "Starting CreateResourceBadUri test");
722 InitStack(OC_SERVER);
724 const char *uri257 = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVW";
726 OCResourceHandle handle;
728 EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
734 OC_DISCOVERABLE|OC_OBSERVABLE));
736 EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
742 OC_DISCOVERABLE|OC_OBSERVABLE));
744 EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
750 OC_DISCOVERABLE|OC_OBSERVABLE));
752 EXPECT_EQ(OC_STACK_OK, OCStop());
755 TEST(StackResource, CreateResourceSuccess)
757 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
758 OIC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
759 InitStack(OC_SERVER);
761 OCResourceHandle handle;
762 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
768 OC_DISCOVERABLE|OC_OBSERVABLE));
769 const char *url = OCGetResourceUri(handle);
770 EXPECT_STREQ("/a/led", url);
772 EXPECT_EQ(OC_STACK_OK, OCStop());
775 TEST(StackResource, CreateResourceSuccessWithResourcePolicyPropNone)
777 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
778 OIC_LOG(INFO, TAG, "Starting CreateResourceSuccessWithResourcePolicyPropNone test");
779 InitStack(OC_SERVER);
781 OCResourceHandle handle;
782 // the resource is non-discoverable & non-observable by the client.
783 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
789 OC_RES_PROP_NONE));// the resource is non-discoverable &
790 // non-observable by the client.
791 const char* url = OCGetResourceUri(handle);
792 EXPECT_STREQ("/a/led", url);
794 EXPECT_EQ(OC_STACK_OK, OCStop());
797 TEST(StackResource, CreateResourceWithClientStackMode)
799 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
800 OIC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
801 InitStack(OC_CLIENT);
803 OCResourceHandle handle;
804 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
810 OC_DISCOVERABLE|OC_OBSERVABLE));
812 EXPECT_EQ(OC_STACK_OK, OCStop());
815 TEST(StackResource, CreateResourceFailDuplicateUri)
817 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
818 OIC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
819 InitStack(OC_SERVER);
821 OCResourceHandle handle;
822 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
828 OC_DISCOVERABLE|OC_OBSERVABLE));
829 const char *url = OCGetResourceUri(handle);
830 EXPECT_STREQ("/a/led", url);
832 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
838 OC_DISCOVERABLE|OC_OBSERVABLE));
840 EXPECT_EQ(OC_STACK_OK, OCStop());
843 TEST(StackResource, CreateResourceMultipleResources)
845 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
846 OIC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
847 InitStack(OC_SERVER);
849 OCResourceHandle handle1;
850 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
856 OC_DISCOVERABLE|OC_OBSERVABLE));
858 OCResourceHandle handle2;
859 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
865 OC_DISCOVERABLE|OC_OBSERVABLE));
866 OCResourceHandle handle3;
867 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
873 OC_DISCOVERABLE|OC_OBSERVABLE));
875 const char *url = OCGetResourceUri(handle1);
876 EXPECT_STREQ("/a/led1", url);
878 url = OCGetResourceUri(handle2);
879 EXPECT_STREQ("/a/led2", url);
881 url = OCGetResourceUri(handle3);
882 EXPECT_STREQ("/a/led3", url);
884 EXPECT_EQ(OC_STACK_OK, OCStop());
887 TEST(StackResource, CreateResourceBadResoureType)
889 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
890 OIC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
891 InitStack(OC_SERVER);
893 OCResourceHandle handle;
894 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
900 OC_DISCOVERABLE|OC_OBSERVABLE));
902 OCResourceHandle handle2;
903 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle2,
909 OC_DISCOVERABLE|OC_OBSERVABLE));
911 EXPECT_EQ(OC_STACK_OK, OCStop());
914 TEST(StackResource, CreateResourceGoodResourceType)
916 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
917 OIC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
918 InitStack(OC_SERVER);
920 OCResourceHandle handle;
921 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
927 OC_DISCOVERABLE|OC_OBSERVABLE));
929 EXPECT_EQ(OC_STACK_OK, OCStop());
932 TEST(StackResource, ResourceTypeName)
934 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
935 OIC_LOG(INFO, TAG, "Starting ResourceTypeName test");
936 InitStack(OC_SERVER);
938 OCResourceHandle handle;
939 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
945 OC_DISCOVERABLE|OC_OBSERVABLE));
947 uint8_t numResourceTypes;
948 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
949 EXPECT_EQ(1, numResourceTypes);
950 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
951 EXPECT_STREQ("core.led", resourceTypeName);
953 // try getting resource type names with an invalid index
954 resourceTypeName = OCGetResourceTypeName(handle, 1);
955 EXPECT_STREQ(NULL, resourceTypeName);
956 // try getting resource type names with an invalid index
957 resourceTypeName = OCGetResourceTypeName(handle, 10);
958 EXPECT_STREQ(NULL, resourceTypeName);
960 EXPECT_EQ(OC_STACK_OK, OCStop());
963 TEST(StackResource, ResourceTypeAttrRepresentation)
965 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
966 OIC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
967 InitStack(OC_SERVER);
969 OCResourceHandle handle;
970 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
976 OC_DISCOVERABLE|OC_OBSERVABLE));
978 uint8_t numResourceTypes;
979 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
980 EXPECT_EQ(1, numResourceTypes);
982 EXPECT_EQ(OC_STACK_OK, OCStop());
985 TEST(StackResource, ResourceTypeInterface)
987 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
988 OIC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
989 InitStack(OC_SERVER);
991 OCResourceHandle handle;
992 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
998 OC_DISCOVERABLE|OC_OBSERVABLE));
1000 uint8_t numResourceInterfaces;
1001 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1002 EXPECT_EQ(2, numResourceInterfaces);
1003 const char *resourceInterfaceName1 = OCGetResourceInterfaceName(handle, 0);
1004 EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, resourceInterfaceName1);
1005 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1006 EXPECT_STREQ("core.rw", resourceInterfaceName);
1008 // try getting resource interface names with an invalid index
1009 resourceInterfaceName = OCGetResourceInterfaceName(handle, 2);
1010 EXPECT_STREQ(NULL, resourceInterfaceName);
1011 // try getting resource interface names with an invalid index
1012 resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
1013 EXPECT_STREQ(NULL, resourceInterfaceName);
1015 EXPECT_EQ(OC_STACK_OK, OCStop());
1018 TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
1020 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1022 OIC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
1024 InitStack(OC_SERVER);
1026 OCResourceHandle handle;
1027 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1033 OC_DISCOVERABLE|OC_OBSERVABLE));
1034 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1035 OC_RSRVD_INTERFACE_DEFAULT));
1036 uint8_t numResourceInterfaces;
1037 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1038 EXPECT_EQ(2, numResourceInterfaces);
1040 const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
1041 EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
1043 const char*interfaceName_2 = OCGetResourceInterfaceName(handle, 1);
1044 EXPECT_STREQ("core.rw", interfaceName_2);
1046 EXPECT_EQ(OC_STACK_OK, OCStop());
1049 TEST(StackResource, ResourceDuplicateDefaultInterfaces)
1051 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1053 OIC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
1055 InitStack(OC_SERVER);
1057 OCResourceHandle handle;
1058 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1064 OC_DISCOVERABLE|OC_OBSERVABLE));
1066 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1067 OC_RSRVD_INTERFACE_DEFAULT));
1068 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1069 OC_RSRVD_INTERFACE_DEFAULT));
1071 uint8_t numResourceInterfaces;
1072 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1073 EXPECT_EQ(2, numResourceInterfaces);
1075 const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
1076 EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
1078 EXPECT_EQ(OC_STACK_OK, OCStop());
1081 TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
1083 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1085 OIC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
1087 InitStack(OC_SERVER);
1089 OCResourceHandle handle;
1090 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1096 OC_DISCOVERABLE|OC_OBSERVABLE));
1098 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1100 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1103 uint8_t numResourceInterfaces;
1104 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1105 EXPECT_EQ(2, numResourceInterfaces);
1107 EXPECT_EQ(OC_STACK_OK, OCStop());
1110 TEST(StackResource, ResourceTypeInterfaceMethods)
1112 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1113 OIC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
1114 InitStack(OC_SERVER);
1116 OCResourceHandle handle;
1117 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1123 OC_DISCOVERABLE|OC_OBSERVABLE));
1125 uint8_t numResourceInterfaces;
1126 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1127 EXPECT_EQ(2, numResourceInterfaces);
1129 EXPECT_EQ(OC_STACK_OK, OCStop());
1132 TEST(StackResource, GetResourceProperties)
1134 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1135 OIC_LOG(INFO, TAG, "Starting GetResourceProperties test");
1136 InitStack(OC_SERVER);
1138 OCResourceHandle handle;
1139 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1145 OC_DISCOVERABLE|OC_OBSERVABLE));
1148 EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE|OC_MQ_PUBLISHER, OCGetResourceProperties(handle));
1150 EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
1152 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1154 EXPECT_EQ(OC_STACK_OK, OCStop());
1157 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
1159 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1160 OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
1161 InitStack(OC_SERVER);
1162 uint8_t numResources = 0;
1163 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1165 OCResourceHandle handle;
1166 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1172 OC_DISCOVERABLE|OC_OBSERVABLE));
1173 const char *url = OCGetResourceUri(handle);
1174 EXPECT_STREQ("/a1/led", url);
1176 //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
1177 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1178 uint8_t numExpectedResources = 0;
1180 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1181 EXPECT_EQ(numExpectedResources, numResources);
1183 EXPECT_EQ(OC_STACK_OK, OCStop());
1186 TEST(StackResource, StackTestResourceDiscoverOneResource)
1188 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1189 OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
1190 InitStack(OC_SERVER);
1192 OCResourceHandle handle;
1193 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1199 OC_DISCOVERABLE|OC_OBSERVABLE));
1200 const char *url = OCGetResourceUri(handle);
1201 EXPECT_STREQ("/a/led", url);
1203 //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1204 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1206 EXPECT_EQ(OC_STACK_OK, OCStop());
1209 TEST(StackResource, StackTestResourceDiscoverManyResources)
1211 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1212 OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
1213 InitStack(OC_SERVER);
1215 OCResourceHandle handle1;
1216 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1223 const char *url = OCGetResourceUri(handle1);
1224 EXPECT_STREQ("/a/led1", url);
1226 OCResourceHandle handle2;
1227 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1233 OC_DISCOVERABLE|OC_OBSERVABLE));
1234 url = OCGetResourceUri(handle2);
1235 EXPECT_STREQ("/a/led2", url);
1237 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
1238 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
1240 OCResourceHandle handle3;
1241 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1247 OC_DISCOVERABLE|OC_OBSERVABLE));
1248 url = OCGetResourceUri(handle3);
1249 EXPECT_STREQ("/a/led3", url);
1251 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
1252 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
1254 OCResourceHandle handle4;
1255 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1262 url = OCGetResourceUri(handle4);
1263 EXPECT_STREQ("/a/led4", url);
1265 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
1266 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
1267 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
1269 //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1271 EXPECT_EQ(OC_STACK_OK, OCStop());
1274 TEST(StackBind, BindResourceTypeNameBad)
1276 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1277 OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
1278 InitStack(OC_SERVER);
1280 OCResourceHandle handle;
1281 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1287 OC_DISCOVERABLE|OC_OBSERVABLE));
1289 uint8_t numResourceTypes;
1290 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1291 EXPECT_EQ(1, numResourceTypes);
1292 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1293 EXPECT_STREQ("core.led", resourceTypeName);
1295 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
1296 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, "core.nameBad"));
1297 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, "core.name bad"));
1299 EXPECT_EQ(OC_STACK_OK, OCStop());
1302 TEST(StackBind, BindResourceTypeNameGood)
1304 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1305 OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
1306 InitStack(OC_SERVER);
1308 OCResourceHandle handle;
1309 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1315 OC_DISCOVERABLE|OC_OBSERVABLE));
1317 uint8_t numResourceTypes;
1318 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1319 EXPECT_EQ(1, numResourceTypes);
1320 const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1321 EXPECT_STREQ("core.led", resourceTypeName);
1323 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1324 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1325 EXPECT_EQ(2, numResourceTypes);
1326 resourceTypeName = OCGetResourceTypeName(handle, 1);
1327 EXPECT_STREQ("core.brightled", resourceTypeName);
1329 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1330 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1331 EXPECT_EQ(3, numResourceTypes);
1332 resourceTypeName = OCGetResourceTypeName(handle, 2);
1333 EXPECT_STREQ("core.reallybrightled", resourceTypeName);
1335 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "x.ReallyReallyBrightLED"));
1336 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1337 EXPECT_EQ(4, numResourceTypes);
1338 resourceTypeName = OCGetResourceTypeName(handle, 3);
1339 EXPECT_STREQ("x.ReallyReallyBrightLED", resourceTypeName);
1341 EXPECT_EQ(OC_STACK_OK, OCStop());
1344 TEST(StackBind, BindResourceTypeAttribRepGood)
1346 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1347 OIC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
1348 InitStack(OC_SERVER);
1350 OCResourceHandle handle;
1351 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1357 OC_DISCOVERABLE|OC_OBSERVABLE));
1359 uint8_t numResourceTypes;
1360 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1361 EXPECT_EQ(1, numResourceTypes);
1363 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1364 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1365 EXPECT_EQ(2, numResourceTypes);
1367 EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1368 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1369 EXPECT_EQ(3, numResourceTypes);
1371 EXPECT_EQ(OC_STACK_OK, OCStop());
1375 TEST(StackBind, BindResourceInterfaceNameBad)
1377 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1378 OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
1379 InitStack(OC_SERVER);
1381 OCResourceHandle handle;
1382 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1388 OC_DISCOVERABLE|OC_OBSERVABLE));
1390 uint8_t numResourceInterfaces;
1391 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1392 EXPECT_EQ(2, numResourceInterfaces);
1393 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1394 EXPECT_STREQ("core.rw", resourceInterfaceName);
1396 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
1398 EXPECT_EQ(OC_STACK_OK, OCStop());
1401 TEST(StackBind, BindResourceInterfaceNameGood)
1403 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1404 OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
1405 InitStack(OC_SERVER);
1407 OCResourceHandle handle;
1408 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1414 OC_DISCOVERABLE|OC_OBSERVABLE));
1416 uint8_t numResourceInterfaces;
1417 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1418 EXPECT_EQ(2, numResourceInterfaces);
1419 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1420 EXPECT_STREQ("core.rw", resourceInterfaceName);
1422 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1424 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1425 EXPECT_EQ(3, numResourceInterfaces);
1426 resourceInterfaceName = OCGetResourceInterfaceName(handle, 2);
1427 EXPECT_STREQ("core.r", resourceInterfaceName);
1429 EXPECT_EQ(OC_STACK_OK, OCStop());
1432 TEST(StackBind, BindResourceInterfaceMethodsBad)
1434 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1435 OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
1436 InitStack(OC_SERVER);
1438 OCResourceHandle handle;
1439 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1445 OC_DISCOVERABLE|OC_OBSERVABLE));
1447 uint8_t numResourceInterfaces;
1448 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1449 EXPECT_EQ(2, numResourceInterfaces);
1451 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
1453 EXPECT_EQ(OC_STACK_OK, OCStop());
1456 TEST(StackBind, BindResourceInterfaceMethodsGood)
1458 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1459 OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
1460 InitStack(OC_SERVER);
1462 OCResourceHandle handle;
1463 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1469 OC_DISCOVERABLE|OC_OBSERVABLE));
1471 uint8_t numResourceInterfaces;
1472 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1473 EXPECT_EQ(2, numResourceInterfaces);
1475 EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1477 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1478 EXPECT_EQ(3, numResourceInterfaces);
1480 EXPECT_EQ(OC_STACK_OK, OCStop());
1483 TEST(StackBind, BindContainedResourceBad)
1485 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1486 OIC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
1487 InitStack(OC_SERVER);
1489 OCResourceHandle containerHandle;
1490 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1496 OC_DISCOVERABLE|OC_OBSERVABLE));
1498 OCResourceHandle handle0;
1499 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1505 OC_DISCOVERABLE|OC_OBSERVABLE));
1507 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1509 EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1511 EXPECT_EQ(OC_STACK_OK, OCStop());
1514 TEST(StackBind, BindContainedResourceGood)
1516 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1517 OIC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1518 InitStack(OC_SERVER);
1520 uint8_t numResources = 0;
1521 uint8_t numExpectedResources = 0;
1523 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1525 OCResourceHandle containerHandle;
1526 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1532 OC_DISCOVERABLE|OC_OBSERVABLE));
1533 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1534 EXPECT_EQ(++numExpectedResources, numResources);
1536 OCResourceHandle handle0;
1537 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1543 OC_DISCOVERABLE|OC_OBSERVABLE));
1544 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1545 EXPECT_EQ(++numExpectedResources, numResources);
1547 OCResourceHandle handle1;
1548 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1554 OC_DISCOVERABLE|OC_OBSERVABLE));
1555 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1556 EXPECT_EQ(++numExpectedResources, numResources);
1558 OCResourceHandle handle2;
1559 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1565 OC_DISCOVERABLE|OC_OBSERVABLE));
1566 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1567 EXPECT_EQ(++numExpectedResources, numResources);
1569 OCResourceHandle handle3;
1570 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1576 OC_DISCOVERABLE|OC_OBSERVABLE));
1577 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1578 EXPECT_EQ(++numExpectedResources, numResources);
1580 OCResourceHandle handle4;
1581 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1587 OC_DISCOVERABLE|OC_OBSERVABLE));
1588 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1589 EXPECT_EQ(++numExpectedResources, numResources);
1591 OCResourceHandle handle5;
1592 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1598 OC_DISCOVERABLE|OC_OBSERVABLE));
1599 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1600 EXPECT_EQ(++numExpectedResources, numResources);
1603 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1604 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1605 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1606 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1607 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1608 EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle5));
1610 EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1611 EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1612 EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1613 EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1614 EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1615 EXPECT_EQ(handle5, OCGetResourceHandleFromCollection(containerHandle, 5));
1617 EXPECT_EQ(OC_STACK_OK, OCStop());
1621 TEST(StackBind, BindEntityHandlerBad)
1623 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1624 OIC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1625 InitStack(OC_SERVER);
1627 OCResourceHandle handle;
1628 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1634 OC_DISCOVERABLE|OC_OBSERVABLE));
1636 EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
1638 EXPECT_EQ(OC_STACK_OK, OCStop());
1641 TEST(StackBind, BindEntityHandlerGood)
1643 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1644 OIC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1645 InitStack(OC_SERVER);
1647 OCResourceHandle handle;
1648 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1654 OC_DISCOVERABLE|OC_OBSERVABLE));
1656 OCEntityHandler myHandler = entityHandler;
1658 EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
1660 EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1662 EXPECT_EQ(OC_STACK_OK, OCStop());
1665 TEST(StackResourceAccess, GetResourceByIndex)
1667 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1668 OIC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1669 InitStack(OC_SERVER);
1671 uint8_t numResources = 0;
1672 uint8_t numExpectedResources = 0;
1673 uint8_t resourceIndex = 0;
1674 uint8_t prevResources = 0;
1675 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1676 prevResources = numExpectedResources;
1677 OCResourceHandle containerHandle;
1678 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1684 OC_DISCOVERABLE|OC_OBSERVABLE));
1685 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1686 EXPECT_EQ(++numExpectedResources, numResources);
1688 OCResourceHandle handle0;
1689 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1695 OC_DISCOVERABLE|OC_OBSERVABLE));
1696 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1697 EXPECT_EQ(++numExpectedResources, numResources);
1699 OCResourceHandle handle1;
1700 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1706 OC_DISCOVERABLE|OC_OBSERVABLE));
1707 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1708 EXPECT_EQ(++numExpectedResources, numResources);
1710 OCResourceHandle handle2;
1711 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1717 OC_DISCOVERABLE|OC_OBSERVABLE));
1718 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1719 EXPECT_EQ(++numExpectedResources, numResources);
1721 OCResourceHandle handle3;
1722 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1728 OC_DISCOVERABLE|OC_OBSERVABLE));
1729 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1730 EXPECT_EQ(++numExpectedResources, numResources);
1732 OCResourceHandle handle4;
1733 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1739 OC_DISCOVERABLE|OC_OBSERVABLE));
1740 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1741 EXPECT_EQ(++numExpectedResources, numResources);
1743 OCResourceHandle handle5;
1744 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1750 OC_DISCOVERABLE|OC_OBSERVABLE));
1751 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1752 EXPECT_EQ(++numExpectedResources, numResources);
1753 resourceIndex += prevResources;
1754 EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1755 EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1756 EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1757 EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1758 EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1759 EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1760 EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1762 EXPECT_EQ(OC_STACK_OK, OCStop());
1765 TEST(StackResourceAccess, DeleteHeadResource)
1767 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1768 OIC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1769 InitStack(OC_SERVER);
1771 uint8_t numResources = 0;
1772 uint8_t numExpectedResources = 0;
1774 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1776 OCResourceHandle handle0;
1777 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1783 OC_DISCOVERABLE|OC_OBSERVABLE));
1784 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1785 EXPECT_EQ(++numExpectedResources, numResources);
1787 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1788 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1789 EXPECT_EQ(--numExpectedResources, numResources);
1791 EXPECT_EQ(OC_STACK_OK, OCStop());
1794 TEST(StackResourceAccess, DeleteHeadResource2)
1796 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1797 OIC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1798 InitStack(OC_SERVER);
1800 uint8_t numResources = 0;
1801 uint8_t numExpectedResources = 0;
1803 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1804 OCResourceHandle handle0;
1805 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1811 OC_DISCOVERABLE|OC_OBSERVABLE));
1812 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1813 EXPECT_EQ(++numExpectedResources, numResources);
1815 OCResourceHandle handle1;
1816 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1822 OC_DISCOVERABLE|OC_OBSERVABLE));
1823 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1824 EXPECT_EQ(++numExpectedResources, numResources);
1826 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1827 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1828 EXPECT_EQ(--numExpectedResources, numResources);
1830 EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
1832 EXPECT_EQ(OC_STACK_OK, OCStop());
1836 TEST(StackResourceAccess, DeleteLastResource)
1838 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1839 OIC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1840 InitStack(OC_SERVER);
1842 uint8_t numResources = 0;
1843 uint8_t numExpectedResources = 0;
1845 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1847 OCResourceHandle handle0;
1848 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1854 OC_DISCOVERABLE|OC_OBSERVABLE));
1855 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1856 EXPECT_EQ(++numExpectedResources, numResources);
1858 OCResourceHandle handle1;
1859 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1865 OC_DISCOVERABLE|OC_OBSERVABLE));
1866 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1867 EXPECT_EQ(++numExpectedResources, numResources);
1869 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1870 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1871 EXPECT_EQ(--numExpectedResources, numResources);
1873 EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
1875 OCResourceHandle handle2;
1876 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1882 OC_DISCOVERABLE|OC_OBSERVABLE));
1883 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1884 EXPECT_EQ(++numExpectedResources, numResources);
1886 EXPECT_EQ(OC_STACK_OK, OCStop());
1889 TEST(StackResourceAccess, DeleteMiddleResource)
1891 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1892 OIC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1893 InitStack(OC_SERVER);
1895 uint8_t numResources = 0;
1896 uint8_t numExpectedResources = 0;
1897 uint8_t resourceIndex = InitResourceIndex();
1899 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1900 resourceIndex = numExpectedResources;
1901 OCResourceHandle handle0;
1902 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1908 OC_DISCOVERABLE|OC_OBSERVABLE));
1909 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1910 EXPECT_EQ(++numExpectedResources, numResources);
1912 OCResourceHandle handle1;
1913 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1919 OC_DISCOVERABLE|OC_OBSERVABLE));
1920 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1921 EXPECT_EQ(++numExpectedResources, numResources);
1923 OCResourceHandle handle2;
1924 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1930 OC_DISCOVERABLE|OC_OBSERVABLE));
1931 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1932 EXPECT_EQ(++numExpectedResources, numResources);
1934 EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1935 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1936 EXPECT_EQ(--numExpectedResources, numResources);
1938 EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1939 EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1941 // Make sure the resource elements are still correct
1942 uint8_t numResourceInterfaces;
1943 EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1944 EXPECT_EQ(2, numResourceInterfaces);
1945 const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 1);
1946 EXPECT_STREQ("core.rw", resourceInterfaceName);
1948 EXPECT_EQ(OC_STACK_OK, OCStop());
1951 // Visual Studio versions earlier than 2015 have bugs in is_pod and report the wrong answer.
1952 #if !defined(_MSC_VER) || (_MSC_VER >= 1900)
1953 TEST(PODTests, OCHeaderOption)
1955 EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1958 TEST(PODTests, OCCallbackData)
1960 EXPECT_TRUE(std::is_pod<OCCallbackData>::value);
1964 TEST(OCDoDirectPairingTests, Nullpeer)
1966 EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, NULL, pmSel, &pinNumber, &resultCallback));
1969 TEST(OCDoDirectPairingTests, NullCallback)
1971 EXPECT_EQ(OC_STACK_INVALID_CALLBACK,OCDoDirectPairing(NULL, &peer, pmSel, &pinNumber, NULL));
1974 TEST(OCDoDirectPairingTests, NullpinNumber)
1976 EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, &peer, pmSel, NULL, &resultCallback));
1979 TEST(StackResource, MultipleResourcesDiscovery)
1981 itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1982 OIC_LOG(INFO, TAG, "Starting MultipleResourcesDiscovery test");
1983 InitStack(OC_SERVER);
1985 OCResourceHandle handle1;
1986 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1992 OC_DISCOVERABLE|OC_OBSERVABLE));
1994 OCResourceHandle handle2;
1995 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
2001 OC_DISCOVERABLE|OC_OBSERVABLE));
2002 OCResourceHandle handle3;
2003 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
2009 OC_DISCOVERABLE|OC_OBSERVABLE));
2010 /* Start a discovery query*/
2011 char szQueryUri[MAX_QUERY_LENGTH] = "/oic/res?if=oic.if.ll";
2012 OCCallbackData cbData;
2013 cbData.cb = discoveryCallback;
2014 cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
2018 EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
2029 EXPECT_EQ(OC_STACK_OK, OCStop());
2032 TEST(StackPayload, CloneByteString)
2034 uint8_t bytes[] = { 0, 1, 2, 3 };
2035 OCByteString byteString;
2036 byteString.bytes = bytes;
2037 byteString.len = sizeof(bytes);
2039 OCRepPayload *original = OCRepPayloadCreate();
2040 ASSERT_TRUE(original != NULL);
2041 EXPECT_TRUE(OCRepPayloadSetPropByteString(original, "name", byteString));
2043 OCRepPayload *clone = OCRepPayloadClone(original);
2044 ASSERT_TRUE(clone != NULL);
2046 OCRepPayloadDestroy(original);
2048 OCByteString cloneByteString;
2049 EXPECT_TRUE(OCRepPayloadGetPropByteString(clone, "name", &cloneByteString));
2050 ASSERT_TRUE(cloneByteString.bytes != NULL);
2051 EXPECT_EQ(sizeof(bytes), cloneByteString.len);
2052 EXPECT_TRUE(0 == memcmp(bytes, cloneByteString.bytes, sizeof(bytes)));
2053 OICFree(cloneByteString.bytes);
2055 OCRepPayloadDestroy(clone);
2058 TEST(StackUri, Rfc6874_Noop_1)
2060 char validIPv6Address[] = "FF01:0:0:0:0:0:0:FB";
2061 char bytes[100] = {0};
2062 strncpy(bytes, validIPv6Address, sizeof(bytes));
2064 OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2066 // No % sign, should do nothing
2067 EXPECT_STREQ(bytes, validIPv6Address);
2068 EXPECT_EQ(OC_STACK_OK, result);
2071 TEST(StackUri, Rfc6874_Noop_2)
2073 char validIPv6Address[] = "3812:a61::4:1";
2074 char bytes[100] = {0};
2076 OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2078 // No % sign, should do nothing
2079 EXPECT_STREQ(bytes, validIPv6Address);
2080 EXPECT_EQ(OC_STACK_OK, result);
2083 TEST(StackUri, Rfc6874_WithEncoding)
2085 char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0";
2086 char validIPv6AddressEncoded[] = "fe80::dafe:e3ff:fe00:ebfa%25wlan0";
2087 char bytes[100] = "";
2088 strncpy(bytes, validIPv6Address, sizeof(bytes));
2090 OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2092 // Encoding should have occured
2093 EXPECT_STREQ(bytes, validIPv6AddressEncoded);
2094 EXPECT_EQ(OC_STACK_OK, result);
2097 TEST(StackUri, Rfc6874_WithEncoding_ExtraPercent)
2099 char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%%wlan0";
2100 char bytes[100] = {0};
2102 OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2104 // Encoding should have failed due to extra '%' character
2105 EXPECT_STREQ(bytes, "");
2106 EXPECT_EQ(OC_STACK_ERROR, result);
2109 TEST(StackUri, Rfc6874_AlreadyEncoded)
2111 char validIPv6AddressEncoded[] = "fe80::dafe:e3ff:fe00:ebfa%25wlan0";
2112 char bytes[100] = {0};
2114 OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6AddressEncoded);
2116 // Encoding should have failed due to extra '%' character
2117 EXPECT_STREQ(bytes, "");
2118 EXPECT_EQ(OC_STACK_ERROR, result);
2121 TEST(StackUri, Rfc6874_NoOverflow)
2123 char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0";
2124 char addrBuffer[100];
2125 char bytes[100] = {0};
2126 memset(addrBuffer, sizeof(addrBuffer), '_');
2128 // Just enough room to encode
2129 addrBuffer[sizeof(addrBuffer) - sizeof(validIPv6Address) - 3] = '\0';
2130 strcat(addrBuffer, validIPv6Address);
2132 OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), addrBuffer);
2134 // Encoding should have succeeded
2135 EXPECT_EQ(OC_STACK_OK, result);
2138 TEST(StackUri, Rfc6874_NoOverflow_2)
2140 char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0";
2141 char addrBuffer[100];
2142 char bytes[100] = {0};
2143 memset(addrBuffer, sizeof(addrBuffer), '_');
2145 // Not enough room to encode
2146 addrBuffer[sizeof(addrBuffer) - sizeof(validIPv6Address) - 1] = '\0';
2147 strcat(addrBuffer, validIPv6Address);
2149 OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), addrBuffer);
2151 // Encoding should have failed due to output size limitations
2152 EXPECT_STREQ(bytes, "");
2153 EXPECT_EQ(OC_STACK_ERROR, result);
2156 TEST(StackHeaderOption, setHeaderOption)
2158 uint8_t optionValue1[MAX_HEADER_OPTION_DATA_LENGTH] =
2160 OCHeaderOption options[MAX_HEADER_OPTIONS] =
2162 { OC_COAP_ID, 6, 8, optionValue1 }, };
2163 uint8_t optionData = 255;
2164 size_t optionDataSize = sizeof(optionData);
2165 size_t numOptions = 1;
2166 uint16_t optionID = 2048;
2167 EXPECT_EQ(OC_STACK_OK, OCSetHeaderOption(options,
2172 EXPECT_EQ(options[1].optionID, optionID);
2173 EXPECT_EQ(options[1].optionData[0], 255);
2176 TEST(StackHeaderOption, getHeaderOption)
2178 uint8_t optionValue1[MAX_HEADER_OPTION_DATA_LENGTH] =
2180 uint8_t optionValue2[MAX_HEADER_OPTION_DATA_LENGTH] =
2182 OCHeaderOption options[MAX_HEADER_OPTIONS] =
2184 { OC_COAP_ID, 6, 8, optionValue1 },
2185 { OC_COAP_ID, 2048, 16, optionValue2 }, };
2186 uint8_t optionData[MAX_HEADER_OPTION_DATA_LENGTH];
2187 size_t optionDataSize = sizeof(optionData);
2188 size_t numOptions = 2;
2189 uint16_t optionID = 6;
2190 uint16_t actualDataSize = 0;
2191 EXPECT_EQ(OC_STACK_OK, OCGetHeaderOption(options,
2197 EXPECT_EQ(optionData[0], 1);
2198 EXPECT_EQ(actualDataSize, 8);
2201 static OCStackApplicationResult DiscoverBaslineResource(void *ctx, OCDoHandle handle,
2202 OCClientResponse *response)
2206 EXPECT_EQ(OC_STACK_OK, response->result);
2207 EXPECT_TRUE(NULL != response->payload);
2208 if (NULL != response->payload)
2210 EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2212 OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload;
2213 EXPECT_TRUE(NULL != payload->sid);
2216 EXPECT_STREQ("StackTest", payload->name);
2218 EXPECT_STREQ(OC_RSRVD_RESOURCE_TYPE_RES, payload->type->value);
2219 EXPECT_STREQ(OC_RSRVD_INTERFACE_LL, payload->iface->value);
2220 EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, payload->iface->next->value);
2222 for (OCResourcePayload *resource = payload->resources; resource; resource = resource->next)
2224 if (0 == strcmp("/a/light", resource->uri))
2226 EXPECT_STREQ("/a/light", resource->uri);
2227 EXPECT_STREQ("core.light", resource->types->value);
2228 EXPECT_EQ(NULL, resource->types->next);
2229 EXPECT_STREQ("oic.if.baseline", resource->interfaces->value);
2230 EXPECT_EQ(NULL, resource->interfaces->next);
2231 EXPECT_TRUE(resource->bitmap & OC_DISCOVERABLE);
2232 EXPECT_TRUE(resource->bitmap & OC_OBSERVABLE);
2233 EXPECT_FALSE(resource->secure);
2234 EXPECT_EQ(0, resource->port);
2235 EXPECT_EQ(NULL, resource->next);
2240 return OC_STACK_DELETE_TRANSACTION;
2243 static OCStackApplicationResult DiscoverLinkedListResource(void *ctx, OCDoHandle handle,
2244 OCClientResponse *response)
2248 EXPECT_EQ(OC_STACK_OK, response->result);
2249 EXPECT_TRUE(NULL != response->payload);
2250 if (NULL != response->payload)
2252 EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2254 OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload;
2255 EXPECT_NE((char *)NULL, payload->sid);
2256 EXPECT_EQ(NULL, payload->name);
2257 EXPECT_EQ(NULL, payload->type);
2258 EXPECT_EQ(NULL, payload->iface);
2260 for (OCResourcePayload *resource = payload->resources; resource; resource = resource->next)
2262 if (0 == strcmp("/a/light", resource->uri))
2264 EXPECT_STREQ("/a/light", resource->uri);
2265 EXPECT_STREQ("core.light", resource->types->value);
2266 EXPECT_EQ(NULL, resource->types->next);
2267 EXPECT_STREQ("oic.if.baseline", resource->interfaces->value);
2268 EXPECT_EQ(NULL, resource->interfaces->next);
2269 EXPECT_TRUE(resource->bitmap & OC_DISCOVERABLE);
2270 EXPECT_TRUE(resource->bitmap & OC_OBSERVABLE);
2271 EXPECT_FALSE(resource->secure);
2272 EXPECT_EQ(0, resource->port);
2273 EXPECT_EQ(NULL, resource->next);
2277 return OC_STACK_DELETE_TRANSACTION;
2281 static OCStackApplicationResult DiscoverResourceTypeResponse(void *ctx, OCDoHandle handle,
2282 OCClientResponse *response)
2286 EXPECT_EQ(OC_STACK_OK, response->result);
2287 EXPECT_TRUE(NULL != response->payload);
2288 if (NULL != response->payload)
2290 EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2292 OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload;
2293 EXPECT_NE((char *)NULL, payload->sid);
2294 EXPECT_EQ(NULL, payload->name);
2295 EXPECT_EQ(NULL, payload->type);
2296 EXPECT_EQ(NULL, payload->iface);
2297 EXPECT_TRUE(NULL != payload->resources);
2299 OCResourcePayload *resource = payload->resources;
2301 if (0 == strcmp("/a/light", resource->uri))
2303 EXPECT_STREQ("/a/light", resource->uri);
2304 EXPECT_STREQ("core.light", resource->types->value);
2305 EXPECT_EQ(NULL, resource->types->next);
2306 EXPECT_STREQ("oic.if.baseline", resource->interfaces->value);
2307 EXPECT_EQ(NULL, resource->interfaces->next);
2308 EXPECT_TRUE(resource->bitmap & OC_DISCOVERABLE);
2309 EXPECT_TRUE(resource->bitmap & OC_OBSERVABLE);
2310 EXPECT_FALSE(resource->secure);
2311 EXPECT_EQ(0, resource->port);
2312 EXPECT_EQ(NULL, resource->next);
2316 return OC_STACK_DELETE_TRANSACTION;
2319 static OCStackApplicationResult DiscoverNoResource(void *ctx, OCDoHandle handle,
2320 OCClientResponse *response)
2324 EXPECT_EQ(OC_STACK_OK, response->result);
2325 EXPECT_TRUE(NULL != response->payload);
2326 if (NULL != response->payload)
2328 EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2330 OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload;
2331 EXPECT_EQ(NULL, payload->sid);
2332 EXPECT_EQ(NULL, payload->name);
2333 EXPECT_EQ(NULL, payload->type);
2334 EXPECT_EQ(NULL, payload->iface);
2336 bool resourceFound = false;
2337 for (OCResourcePayload *resource = payload->resources; resource; resource = resource->next)
2339 if (0 == strcmp("/a/light", resource->uri))
2341 resourceFound = true;
2345 EXPECT_FALSE(resourceFound);
2347 return OC_STACK_DELETE_TRANSACTION;
2350 static OCStackApplicationResult DiscoverUnicastErrorResponse(void *ctx, OCDoHandle handle,
2351 OCClientResponse *response)
2355 EXPECT_NE(OC_STACK_OK, response->result);
2356 EXPECT_TRUE(NULL == response->payload);
2358 return OC_STACK_DELETE_TRANSACTION;
2361 TEST_F(OCDiscoverTests, DiscoverResourceWithInterfaceBaselineQuery)
2363 itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2365 OCResourceHandle handles;
2366 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2367 entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
2368 OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, "StackTest");
2369 Callback discoverCB(&DiscoverBaslineResource);
2370 EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=oic.if.baseline", NULL,
2371 0, CT_DEFAULT, OC_HIGH_QOS, discoverCB, NULL, 0));
2372 discoverCB.Wait(100);
2375 TEST_F(OCDiscoverTests, DiscoverResourceWithoutAnyQuery)
2377 itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2379 OCResourceHandle handles;
2380 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2381 entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
2382 OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest");
2383 Callback discoverCB(&DiscoverLinkedListResource);
2384 EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res", NULL, 0, CT_DEFAULT,
2385 OC_HIGH_QOS, discoverCB, NULL, 0));
2386 discoverCB.Wait(100);
2389 TEST_F(OCDiscoverTests, DiscoverResourceWithInterfaceLinkedListQuery)
2391 itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2393 OCResourceHandle handles;
2394 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2395 entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
2396 OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest");
2397 Callback discoverCB(&DiscoverLinkedListResource);
2398 EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=oic.if.ll", NULL, 0,
2399 CT_DEFAULT, OC_HIGH_QOS, discoverCB, NULL, 0));
2400 discoverCB.Wait(100);
2403 TEST_F(OCDiscoverTests, DiscoverResourceWithResourceTypeQuery)
2405 itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2407 OCResourceHandle handles;
2408 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2409 entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
2410 OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest");
2411 Callback discoverCB(&DiscoverResourceTypeResponse);
2412 EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?rt=core.light", NULL, 0,
2413 CT_DEFAULT, OC_HIGH_QOS, discoverCB, NULL, 0));
2414 discoverCB.Wait(100);
2417 TEST_F(OCDiscoverTests, DiscoverResourceWithInvalidInterfaceQuery_Unicast)
2419 itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2421 OCResourceHandle handles;
2422 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2423 entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
2424 OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest");
2425 Callback discoverCB(&DiscoverUnicastErrorResponse);
2426 char targetUri[MAX_URI_LENGTH * 2] ={ 0, };
2427 snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?if=invalid");
2428 EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0,
2429 CT_DEFAULT, OC_HIGH_QOS, discoverCB, NULL, 0));
2430 discoverCB.Wait(100);
2433 TEST_F(OCDiscoverTests, DiscoverResourceWithoutInterfaceQuery_Unicast)
2435 itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2437 OCResourceHandle handles;
2438 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2439 entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
2440 OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest");
2441 Callback discoverCB(&DiscoverUnicastErrorResponse);
2442 char targetUri[MAX_URI_LENGTH * 2] ={ 0, };
2443 snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?if=");
2444 EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0, CT_DEFAULT,
2445 OC_HIGH_QOS, discoverCB, NULL, 0));
2446 discoverCB.Wait(10);
2449 TEST_F(OCDiscoverTests, DiscoverResourceWithInvalidResourceTypeQuery_Unicast)
2451 itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2453 OCResourceHandle handles;
2454 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2455 entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
2456 OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest");
2457 Callback discoverCB(&DiscoverUnicastErrorResponse);
2458 char targetUri[MAX_URI_LENGTH * 2] ={ 0, };
2459 snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?rt=invalid");
2460 EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0,
2461 CT_DEFAULT, OC_HIGH_QOS, discoverCB, NULL, 0));
2462 discoverCB.Wait(10);
2465 TEST_F(OCDiscoverTests, DiscoverResourceWithoutResourceTypeQuery_Unicast)
2467 itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2469 OCResourceHandle handles;
2470 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2471 entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
2472 OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest");
2473 Callback discoverCB(&DiscoverUnicastErrorResponse);
2474 char targetUri[MAX_URI_LENGTH * 2] ={ 0, };
2475 snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?rt=");
2476 EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0, CT_DEFAULT,
2477 OC_HIGH_QOS, discoverCB, NULL, 0));
2478 discoverCB.Wait(10);
2481 TEST_F(OCDiscoverTests, DiscoverResourceWithInvalidResourceTypeQuery)
2483 itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2485 OCResourceHandle handles;
2486 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2487 entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
2488 OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest");
2489 Callback discoverCB(&DiscoverUnicastErrorResponse);
2490 EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?rt=invalid", NULL, 0,
2491 CT_DEFAULT, OC_HIGH_QOS, discoverCB, NULL, 0));
2495 TEST_F(OCDiscoverTests, DiscoverResourceWithoutResourceTypeQuery)
2497 itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2499 OCResourceHandle handles;
2500 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2501 entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
2502 OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest");
2503 Callback discoverCB(&DiscoverUnicastErrorResponse);
2504 EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?rt=", NULL, 0, CT_DEFAULT,
2505 OC_HIGH_QOS, discoverCB, NULL, 0));
2509 TEST_F(OCDiscoverTests, DiscoverResourceWithInvalidInterfaceQuery)
2511 itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2513 OCResourceHandle handles;
2514 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2515 entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
2516 OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest");
2517 Callback discoverCB(&DiscoverNoResource);
2518 EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=invalid", NULL, 0,
2519 CT_DEFAULT, OC_HIGH_QOS, discoverCB, NULL, 0));
2523 TEST_F(OCDiscoverTests, DiscoverResourceWithoutInterfaceQuery)
2525 itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2527 OCResourceHandle handles;
2528 EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2529 entityHandler, NULL, (OC_DISCOVERABLE | OC_OBSERVABLE)));
2530 OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest");
2531 Callback discoverCB(&DiscoverNoResource);
2532 EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=", NULL, 0, CT_DEFAULT,
2533 OC_HIGH_QOS, discoverCB, NULL, 0));