resource/csdk/stack/test/stacktests.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   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
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  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.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21
  22 extern "C"
  23 {
  24     #include "ocpayload.h"
  25     #include "ocstack.h"
  26     #include "ocstackinternal.h"
  27     #include "logger.h"
  28     #include "oic_malloc.h"
  29     #include "oic_string.h"
  30     #include "oic_time.h"
  31 }
  32
  33 #include "gtest/gtest.h"
  34 #include <sys/types.h>
  35 #include <sys/stat.h>
  36 #include <errno.h>
  37 #include <fcntl.h>
  38 #ifdef HAVE_UNISTD_H
  39 #include <unistd.h>
  40 #endif
  41 #include <stdlib.h>
  42
  43 //-----------------------------------------------------------------------------
  44 // Includes
  45 //-----------------------------------------------------------------------------
  46 #include <stdio.h>
  47 #include <string.h>
  48
  49 #include <iostream>
  50 #include <stdint.h>
  51
  52 #include "gtest_helper.h"
  53
  54 using namespace std;
  55
  56 namespace itst = iotivity::test;
  57
  58 #define DEFAULT_CONTEXT_VALUE 0x99
  59
  60 //-----------------------------------------------------------------------------
  61 // Private variables
  62 //-----------------------------------------------------------------------------
  63 static const char TAG[] = "TestHarness";
  64
  65 char gDeviceUUID[] = "myDeviceUUID";
  66 char gManufacturerName[] = "myName";
  67 static OCPrm_t pmSel;
  68 static char pinNumber;
  69 static OCDPDev_t peer;
  70
  71 std::chrono::seconds const SHORT_TEST_TIMEOUT = std::chrono::seconds(5);
  72 std::chrono::seconds const LONG_TEST_TIMEOUT = std::chrono::seconds(300);
  73
  74 //-----------------------------------------------------------------------------
  75 // Callback functions
  76 //-----------------------------------------------------------------------------
  77 extern "C"  OCStackApplicationResult asyncDoResourcesCallback(void* ctx,
  78         OCDoHandle /*handle*/, OCClientResponse * clientResponse)
  79 {
  80     OIC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
  81
  82     EXPECT_EQ(OC_STACK_OK, clientResponse->result);
  83
  84     if(ctx == (void*)DEFAULT_CONTEXT_VALUE) {
  85         OIC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
  86     }
  87     OIC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
  88
  89     return OC_STACK_KEEP_TRANSACTION;
  90 }
  91
  92 static void resultCallback(void *UNUSED1, OCDPDev_t *UNUSED2, OCStackResult UNUSED3)
  93 {
  94     (void) (UNUSED1);
  95     (void) (UNUSED2);
  96     (void) (UNUSED3);
  97 }
  98
  99 extern "C" OCStackApplicationResult discoveryCallback(void* ctx,
 100         OCDoHandle /*handle*/, OCClientResponse * clientResponse)
 101 {
 102     OIC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
 103
 104     EXPECT_EQ(OC_STACK_OK, clientResponse->result);
 105
 106     if(ctx == (void*)DEFAULT_CONTEXT_VALUE)
 107     {
 108         OIC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
 109     }
 110
 111     OIC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
 112
 113     OCDiscoveryPayload *discoveryPayload = ((OCDiscoveryPayload *) clientResponse->payload);
 114     EXPECT_TRUE(discoveryPayload != NULL);
 115     OCResourcePayload *res = discoveryPayload->resources;
 116     int count = 0;
 117     for (OCResourcePayload *res1 = discoveryPayload->resources; res1; res1 = res1->next)
 118     {
 119         count++;
 120     }
 121     EXPECT_EQ(3, count);
 122     EXPECT_EQ("/a/led1", res->uri);
 123     res = res->next;
 124     EXPECT_EQ("/a/led2", res->uri);
 125     res = res->next;
 126     EXPECT_EQ("/a/led3", res->uri);
 127     res = res->next;
 128     EXPECT_TRUE(res == NULL);
 129
 130     return OC_STACK_KEEP_TRANSACTION;
 131 }
 132
 133 //-----------------------------------------------------------------------------
 134 // Entity handler
 135 //-----------------------------------------------------------------------------
 136 OCEntityHandlerResult entityHandler(OCEntityHandlerFlag /*flag*/,
 137         OCEntityHandlerRequest * /*entityHandlerRequest*/,
 138         void* /*callbackParam*/)
 139 {
 140     OIC_LOG(INFO, TAG, "Entering entityHandler");
 141
 142     return OC_EH_OK;
 143 }
 144
 145 //-----------------------------------------------------------------------------
 146 //  Local functions
 147 //-----------------------------------------------------------------------------
 148 void InitStack(OCMode mode)
 149 {
 150     OIC_LOG(INFO, TAG, "Entering InitStack");
 151
 152     EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, mode));
 153     OIC_LOG(INFO, TAG, "Leaving InitStack");
 154 }
 155
 156 uint8_t InitNumExpectedResources()
 157 {
 158 #ifdef WITH_PRESENCE
 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.
 161     return 1;
 162 #else
 163     return 0;
 164 #endif
 165 }
 166
 167 uint8_t InitResourceIndex()
 168 {
 169 #ifdef WITH_PRESENCE
 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
 173     // is 1.
 174     return 1;
 175 #else
 176     return 0;
 177 #endif
 178 }
 179
 180 class Callback
 181 {
 182     public:
 183         Callback(OCClientResponseHandler cb) : m_cb(cb), m_called(false)
 184         {
 185             m_cbData.cb = &Callback::handler;
 186             m_cbData.cd = NULL;
 187             m_cbData.context = this;
 188         }
 189         void Wait(long waitTime)
 190         {
 191             uint64_t startTime = OICGetCurrentTime(TIME_IN_MS);
 192             while (!m_called)
 193             {
 194                 uint64_t currTime = OICGetCurrentTime(TIME_IN_MS);
 195                 long elapsed = (long)((currTime - startTime) / MS_PER_SEC);
 196                 if (elapsed > waitTime)
 197                 {
 198                     m_called = true;
 199                 }
 200                 OCProcess();
 201             }
 202         }
 203         operator OCCallbackData *()
 204         {
 205             return &m_cbData;
 206         }
 207     private:
 208         OCCallbackData m_cbData;
 209         OCClientResponseHandler m_cb;
 210         bool m_called;
 211         static OCStackApplicationResult handler(void *ctx, OCDoHandle handle, OCClientResponse *clientResponse)
 212         {
 213             Callback *callback = (Callback *) ctx;
 214             OCStackApplicationResult result = callback->m_cb(NULL, handle, clientResponse);
 215             callback->m_called = true;
 216             return result;
 217         }
 218 };
 219
 220 class OCDiscoverTests : public testing::Test
 221 {
 222     protected:
 223         virtual void SetUp()
 224         {
 225             EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
 226         }
 227
 228         virtual void TearDown()
 229         {
 230             OCStop();
 231         }
 232 };
 233 //-----------------------------------------------------------------------------
 234 //  Tests
 235 //-----------------------------------------------------------------------------
 236
 237 TEST(StackInit, StackInitNullAddr)
 238 {
 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());
 242 }
 243
 244 TEST(StackInit, StackInitNullPort)
 245 {
 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());
 249 }
 250
 251 TEST(StackInit, StackInitNullAddrAndPort)
 252 {
 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());
 256 }
 257
 258 TEST(StackInit, StackInitInvalidMode)
 259 {
 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());
 263 }
 264
 265 TEST(StackStart, StackStartSuccessClient)
 266 {
 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());
 270 }
 271
 272 TEST(StackStart, StackStartSuccessServer)
 273 {
 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());
 277 }
 278
 279 TEST(StackStart, StackStartSuccessClientServer)
 280 {
 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());
 284 }
 285
 286 TEST(StackStart, StackStartSuccessServerThenClient)
 287 {
 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());
 293 }
 294
 295 TEST(StackStart, StackStartSuccessClientThenServer)
 296 {
 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());
 302 }
 303
 304 TEST(StackStart, StackStartSuccessiveInits)
 305 {
 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());
 310 }
 311
 312 TEST(StackStart, SetPlatformInfoValid)
 313 {
 314     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 315     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 316
 317     OCPlatformInfo info =
 318     {
 319         gDeviceUUID,
 320         gManufacturerName,
 321         0, 0, 0, 0, 0, 0, 0, 0, 0
 322     };
 323     EXPECT_EQ(OC_STACK_OK, OCSetPlatformInfo(info));
 324     EXPECT_EQ(OC_STACK_OK, OCStop());
 325 }
 326
 327 TEST(StackStart, SetPlatformInfoWithClientMode)
 328 {
 329     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 330     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 331
 332     OCPlatformInfo info =
 333     {
 334         gDeviceUUID,
 335         gManufacturerName,
 336         0, 0, 0, 0, 0, 0, 0, 0, 0
 337     };
 338     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 339     EXPECT_EQ(OC_STACK_OK, OCStop());
 340 }
 341
 342 TEST(StackStart, SetPlatformInfoWithNoPlatformID)
 343 {
 344     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 345     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 346
 347     OCPlatformInfo info =
 348      {
 349          0,
 350          gDeviceUUID,
 351          0, 0, 0, 0, 0, 0, 0, 0, 0
 352      };
 353
 354     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 355     EXPECT_EQ(OC_STACK_OK, OCStop());
 356 }
 357
 358 TEST(StackStart, SetPlatformInfoWithNoManufacturerName)
 359 {
 360     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 361     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 362
 363     OCPlatformInfo info =
 364     {
 365         gDeviceUUID,
 366         0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 367     };
 368
 369     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 370     EXPECT_EQ(OC_STACK_OK, OCStop());
 371 }
 372
 373 TEST(StackStart, SetPlatformInfoWithZeroLengthManufacturerName)
 374 {
 375     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 376     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 377
 378     OCPlatformInfo info =
 379     {
 380         gDeviceUUID,
 381         0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 382     };
 383     info.manufacturerName = (char *) "";
 384
 385     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 386     EXPECT_EQ(OC_STACK_OK, OCStop());
 387 }
 388
 389 TEST(StackStart, SetPlatformInfoWithTooLongManufacName)
 390 {
 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++ )
 395     {
 396         gTooLongManufacturerName[i] = 'a';
 397     }
 398     gTooLongManufacturerName[MAX_PLATFORM_NAME_LENGTH+1] = '\0';
 399     OCPlatformInfo info =
 400     {
 401         gDeviceUUID,
 402         gTooLongManufacturerName,
 403         0, 0, 0, 0, 0, 0, 0, 0, 0
 404     };
 405
 406     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 407     EXPECT_EQ(OC_STACK_OK, OCStop());
 408 }
 409
 410 TEST(StackStart, SetPlatformInfoWithTooLongManufacURL)
 411 {
 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++ )
 416     {
 417         gManufacturerUrl[i] = 'a';
 418     }
 419     gManufacturerUrl[MAX_PLATFORM_URL_LENGTH+1] = '\0';
 420     OCPlatformInfo info =
 421     {
 422         gDeviceUUID,
 423         gManufacturerName,
 424         gManufacturerUrl,
 425         0, 0, 0, 0, 0, 0, 0, 0
 426     };
 427
 428     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 429     EXPECT_EQ(OC_STACK_OK, OCStop());
 430 }
 431
 432 TEST(StackStart, SetPlatformInfoWithOCSetPropertyValueAPI)
 433 {
 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());
 452 }
 453
 454 TEST(StackStart, GetPlatformInfoWithOCGetPropertyValueAPI)
 455 {
 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"));
 470
 471     void *value = NULL;
 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);
 475     OICFree(value);
 476     value = NULL;
 477
 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);
 481     OICFree(value);
 482     value = NULL;
 483
 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);
 487     OICFree(value);
 488     value = NULL;
 489
 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);
 493     OICFree(value);
 494     value = NULL;
 495
 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);
 499     OICFree(value);
 500     value = NULL;
 501
 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);
 505     OICFree(value);
 506     value = NULL;
 507
 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);
 511     OICFree(value);
 512     value = NULL;
 513
 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);
 517     OICFree(value);
 518     value = NULL;
 519
 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);
 523     OICFree(value);
 524     value = NULL;
 525
 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);
 529     OICFree(value);
 530     value = NULL;
 531
 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);
 535     OICFree(value);
 536     value = NULL;
 537
 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);
 541     OICFree(value);
 542
 543     EXPECT_EQ(OC_STACK_OK, OCStop());
 544 }
 545
 546 TEST(StackStart, SetDeviceInfoAPI)
 547 {
 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());
 563 }
 564
 565 TEST(StackStart, GetDeviceInfoAPI)
 566 {
 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"));
 579
 580     void *value = NULL;
 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);
 584     OICFree(value);
 585     value = NULL;
 586
 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);
 590     OICFree(value);
 591     value = NULL;
 592
 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);
 596     OICFree(value);
 597     value = NULL;
 598
 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);
 604     value = NULL;
 605
 606     EXPECT_STREQ("oic.wk.d", OCGetResourceTypeName(handle, 0));
 607     EXPECT_STREQ("oic.wk.tv", OCGetResourceTypeName(handle, 1));
 608
 609     EXPECT_EQ(OC_STACK_OK, OCStop());
 610 }
 611
 612 TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery)
 613 {
 614     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 615     OCCallbackData cbData;
 616     OCDoHandle handle;
 617
 618     OIC_LOG(INFO, TAG, "Starting DoResourceDeviceDiscovery test ");
 619     InitStack(OC_CLIENT);
 620
 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;
 626     cbData.cd = NULL;
 627     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
 628                                         OC_REST_GET,
 629                                         szQueryUri,
 630                                         0,
 631                                         0,
 632                                         CT_ADAPTER_IP,
 633                                         OC_LOW_QOS,
 634                                         &cbData,
 635                                         NULL,
 636                                         0));
 637     EXPECT_EQ(OC_STACK_OK, OCStop());
 638 }
 639
 640 TEST(StackStop, StackStopWithoutInit)
 641 {
 642     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 643     EXPECT_EQ(OC_STACK_ERROR, OCStop());
 644 }
 645
 646 TEST(StackStop, StackStopRepeated)
 647 {
 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());
 652 }
 653
 654 TEST(StackResource, DISABLED_UpdateResourceNullURI)
 655 {
 656     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 657     OCCallbackData cbData;
 658     OCDoHandle handle;
 659
 660     OIC_LOG(INFO, TAG, "Starting UpdateResourceNullURI test");
 661     InitStack(OC_CLIENT);
 662
 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;
 668     cbData.cd = NULL;
 669     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
 670                                         OC_REST_GET,
 671                                         szQueryUri,
 672                                         0,
 673                                         0,
 674                                         CT_ADAPTER_IP,
 675                                         OC_LOW_QOS,
 676                                         &cbData,
 677                                         NULL,
 678                                         0));
 679     EXPECT_EQ(OC_STACK_OK, OCStop());
 680 }
 681
 682 TEST(StackResource, CreateResourceBadParams)
 683 {
 684     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 685     OIC_LOG(INFO, TAG, "Starting CreateResourceBadParams test");
 686     InitStack(OC_SERVER);
 687
 688     OCResourceHandle handle;
 689
 690     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(NULL, //&handle,
 691                                             "core.led",
 692                                             "core.rw",
 693                                             "/a/led",
 694                                             0,
 695                                             NULL,
 696                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 697
 698     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 699                                             NULL, //"core.led",
 700                                             "core.rw",
 701                                             "/a/led",
 702                                             0,
 703                                             NULL,
 704                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 705
 706     // Property bitmask out of range
 707     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 708                                             "core.led",
 709                                             "core.rw",
 710                                             "/a/led",
 711                                             0,
 712                                             NULL,
 713                                             255));// invalid bitmask for OCResourceProperty
 714
 715     EXPECT_EQ(OC_STACK_OK, OCStop());
 716 }
 717
 718 TEST(StackResource, CreateResourceBadUri)
 719 {
 720     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 721     OIC_LOG(INFO, TAG, "Starting CreateResourceBadUri test");
 722     InitStack(OC_SERVER);
 723
 724     const char *uri257 = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVW";
 725
 726     OCResourceHandle handle;
 727
 728     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 729                                             "core.led",
 730                                             "core.rw",
 731                                             NULL, //"/a/led",
 732                                             0,
 733                                             0,
 734                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 735
 736     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 737                                             "core.led",
 738                                             "core.rw",
 739                                             "", //"/a/led",
 740                                             0,
 741                                             0,
 742                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 743
 744     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 745                                             "core.led",
 746                                             "core.rw",
 747                                             uri257, //"/a/led",
 748                                             0,
 749                                             0,
 750                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 751
 752     EXPECT_EQ(OC_STACK_OK, OCStop());
 753 }
 754
 755 TEST(StackResource, CreateResourceSuccess)
 756 {
 757     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 758     OIC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
 759     InitStack(OC_SERVER);
 760
 761     OCResourceHandle handle;
 762     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 763                                             "core.led",
 764                                             "core.rw",
 765                                             "/a/led",
 766                                             0,
 767                                             NULL,
 768                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 769     const char *url = OCGetResourceUri(handle);
 770     EXPECT_STREQ("/a/led", url);
 771
 772     EXPECT_EQ(OC_STACK_OK, OCStop());
 773 }
 774
 775 TEST(StackResource, CreateResourceSuccessWithResourcePolicyPropNone)
 776 {
 777     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 778     OIC_LOG(INFO, TAG, "Starting CreateResourceSuccessWithResourcePolicyPropNone test");
 779     InitStack(OC_SERVER);
 780
 781     OCResourceHandle handle;
 782     // the resource is non-discoverable & non-observable by the client.
 783     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 784                                             "core.led",
 785                                             "core.rw",
 786                                             "/a/led",
 787                                             0,
 788                                             NULL,
 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);
 793
 794     EXPECT_EQ(OC_STACK_OK, OCStop());
 795 }
 796
 797 TEST(StackResource, CreateResourceWithClientStackMode)
 798 {
 799     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 800     OIC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
 801     InitStack(OC_CLIENT);
 802
 803     OCResourceHandle handle;
 804     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 805                                             "core.led",
 806                                             "core.rw",
 807                                             "/a/led",
 808                                             0,
 809                                             NULL,
 810                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 811
 812     EXPECT_EQ(OC_STACK_OK, OCStop());
 813 }
 814
 815 TEST(StackResource, CreateResourceFailDuplicateUri)
 816 {
 817     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 818     OIC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
 819     InitStack(OC_SERVER);
 820
 821     OCResourceHandle handle;
 822     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 823                                             "core.led",
 824                                             "core.rw",
 825                                             "/a/led",
 826                                             0,
 827                                             NULL,
 828                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 829     const char *url = OCGetResourceUri(handle);
 830     EXPECT_STREQ("/a/led", url);
 831
 832     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 833                                             "core.led",
 834                                             "core.rw",
 835                                             "/a/led",
 836                                             0,
 837                                             NULL,
 838                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 839
 840     EXPECT_EQ(OC_STACK_OK, OCStop());
 841 }
 842
 843 TEST(StackResource, CreateResourceMultipleResources)
 844 {
 845     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 846     OIC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
 847     InitStack(OC_SERVER);
 848
 849     OCResourceHandle handle1;
 850     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 851                                             "core.led",
 852                                             "core.rw",
 853                                             "/a/led1",
 854                                             0,
 855                                             NULL,
 856                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 857
 858     OCResourceHandle handle2;
 859     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 860                                             "core.led",
 861                                             "core.rw",
 862                                             "/a/led2",
 863                                             0,
 864                                             NULL,
 865                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 866     OCResourceHandle handle3;
 867     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 868                                             "core.led",
 869                                             "core.rw",
 870                                             "/a/led3",
 871                                             0,
 872                                             NULL,
 873                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 874
 875     const char *url = OCGetResourceUri(handle1);
 876     EXPECT_STREQ("/a/led1", url);
 877
 878     url = OCGetResourceUri(handle2);
 879     EXPECT_STREQ("/a/led2", url);
 880
 881     url = OCGetResourceUri(handle3);
 882     EXPECT_STREQ("/a/led3", url);
 883
 884     EXPECT_EQ(OC_STACK_OK, OCStop());
 885 }
 886
 887 TEST(StackResource, CreateResourceBadResoureType)
 888 {
 889     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 890     OIC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
 891     InitStack(OC_SERVER);
 892
 893     OCResourceHandle handle;
 894     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 895                                             NULL, //"core.led",
 896                                             "core.rw",
 897                                             "/a/led",
 898                                             0,
 899                                             NULL,
 900                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 901
 902     OCResourceHandle handle2;
 903     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle2,
 904                                             "",
 905                                             "core.rw",
 906                                             "/a/led",
 907                                             0,
 908                                             NULL,
 909                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 910
 911     EXPECT_EQ(OC_STACK_OK, OCStop());
 912 }
 913
 914 TEST(StackResource, CreateResourceGoodResourceType)
 915 {
 916     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 917     OIC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
 918     InitStack(OC_SERVER);
 919
 920     OCResourceHandle handle;
 921     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 922                                             "core.led",
 923                                             "core.rw",
 924                                             "/a/led",
 925                                             0,
 926                                             NULL,
 927                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 928
 929     EXPECT_EQ(OC_STACK_OK, OCStop());
 930 }
 931
 932 TEST(StackResource, ResourceTypeName)
 933 {
 934     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 935     OIC_LOG(INFO, TAG, "Starting ResourceTypeName test");
 936     InitStack(OC_SERVER);
 937
 938     OCResourceHandle handle;
 939     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 940                                             "core.led",
 941                                             "core.rw",
 942                                             "/a/led",
 943                                             0,
 944                                             NULL,
 945                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 946
 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);
 952
 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);
 959
 960     EXPECT_EQ(OC_STACK_OK, OCStop());
 961 }
 962
 963 TEST(StackResource, ResourceTypeAttrRepresentation)
 964 {
 965     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 966     OIC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
 967     InitStack(OC_SERVER);
 968
 969     OCResourceHandle handle;
 970     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 971                                             "core.led",
 972                                             "core.rw",
 973                                             "/a/led",
 974                                             0,
 975                                             NULL,
 976                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 977
 978     uint8_t numResourceTypes;
 979     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 980     EXPECT_EQ(1, numResourceTypes);
 981
 982     EXPECT_EQ(OC_STACK_OK, OCStop());
 983 }
 984
 985 TEST(StackResource, ResourceTypeInterface)
 986 {
 987     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 988     OIC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
 989     InitStack(OC_SERVER);
 990
 991     OCResourceHandle handle;
 992     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 993                                             "core.led",
 994                                             "core.rw",
 995                                             "/a/led",
 996                                             0,
 997                                             NULL,
 998                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 999
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);
1007
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);
1014
1015     EXPECT_EQ(OC_STACK_OK, OCStop());
1016 }
1017
1018 TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
1019 {
1020     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1021
1022     OIC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
1023
1024     InitStack(OC_SERVER);
1025
1026     OCResourceHandle handle;
1027     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1028                                             "core.led",
1029                                             "core.rw",
1030                                             "/a/led",
1031                                             0,
1032                                             NULL,
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);
1039
1040     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
1041     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
1042
1043     const char*interfaceName_2 = OCGetResourceInterfaceName(handle, 1);
1044     EXPECT_STREQ("core.rw", interfaceName_2);
1045
1046     EXPECT_EQ(OC_STACK_OK, OCStop());
1047 }
1048
1049 TEST(StackResource, ResourceDuplicateDefaultInterfaces)
1050 {
1051     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1052
1053     OIC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
1054
1055     InitStack(OC_SERVER);
1056
1057     OCResourceHandle handle;
1058     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1059                                             "core.led",
1060                                             "core.rw",
1061                                             "/a/led",
1062                                             0,
1063                                             NULL,
1064                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1065
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));
1070
1071     uint8_t numResourceInterfaces;
1072     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1073     EXPECT_EQ(2, numResourceInterfaces);
1074
1075     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
1076     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
1077
1078     EXPECT_EQ(OC_STACK_OK, OCStop());
1079 }
1080
1081 TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
1082 {
1083     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1084
1085     OIC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
1086
1087     InitStack(OC_SERVER);
1088
1089     OCResourceHandle handle;
1090     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1091                                             "core.led",
1092                                             "core.rw",
1093                                             "/a/led",
1094                                             0,
1095                                             NULL,
1096                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1097
1098     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1099                                         "core.rw"));
1100     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1101                                         "core.rw"));
1102
1103     uint8_t numResourceInterfaces;
1104     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1105     EXPECT_EQ(2, numResourceInterfaces);
1106
1107     EXPECT_EQ(OC_STACK_OK, OCStop());
1108 }
1109
1110 TEST(StackResource, ResourceTypeInterfaceMethods)
1111 {
1112     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1113     OIC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
1114     InitStack(OC_SERVER);
1115
1116     OCResourceHandle handle;
1117     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1118                                             "core.led",
1119                                             "core.rw",
1120                                             "/a/led",
1121                                             0,
1122                                             NULL,
1123                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1124
1125     uint8_t numResourceInterfaces;
1126     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1127     EXPECT_EQ(2, numResourceInterfaces);
1128
1129     EXPECT_EQ(OC_STACK_OK, OCStop());
1130 }
1131
1132 TEST(StackResource, GetResourceProperties)
1133 {
1134     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1135     OIC_LOG(INFO, TAG, "Starting GetResourceProperties test");
1136     InitStack(OC_SERVER);
1137
1138     OCResourceHandle handle;
1139     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1140                                             "core.led",
1141                                             "core.rw",
1142                                             "/a/led",
1143                                             0,
1144                                             NULL,
1145                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1146
1147 #ifdef MQ_PUBLISHER
1148     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE|OC_MQ_PUBLISHER, OCGetResourceProperties(handle));
1149 #else
1150     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
1151 #endif
1152     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1153
1154     EXPECT_EQ(OC_STACK_OK, OCStop());
1155 }
1156
1157 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
1158 {
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));
1164
1165     OCResourceHandle handle;
1166     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1167                                             "core.led",
1168                                             "core.rw",
1169                                             "/a1/led",
1170                                             0,
1171                                             NULL,
1172                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1173     const char *url = OCGetResourceUri(handle);
1174     EXPECT_STREQ("/a1/led", url);
1175
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;
1179
1180     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1181     EXPECT_EQ(numExpectedResources, numResources);
1182
1183     EXPECT_EQ(OC_STACK_OK, OCStop());
1184 }
1185
1186 TEST(StackResource, StackTestResourceDiscoverOneResource)
1187 {
1188     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1189     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
1190     InitStack(OC_SERVER);
1191
1192     OCResourceHandle handle;
1193     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1194                                             "core.led",
1195                                             "core.rw",
1196                                             "/a/led",
1197                                             0,
1198                                             NULL,
1199                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1200     const char *url = OCGetResourceUri(handle);
1201     EXPECT_STREQ("/a/led", url);
1202
1203     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1204     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1205
1206     EXPECT_EQ(OC_STACK_OK, OCStop());
1207 }
1208
1209 TEST(StackResource, StackTestResourceDiscoverManyResources)
1210 {
1211     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1212     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
1213     InitStack(OC_SERVER);
1214
1215     OCResourceHandle handle1;
1216     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1217                                             "core.led",
1218                                             "core.rw",
1219                                             "/a/led1",
1220                                             0,
1221                                             NULL,
1222                                             OC_DISCOVERABLE));
1223     const char *url = OCGetResourceUri(handle1);
1224     EXPECT_STREQ("/a/led1", url);
1225
1226     OCResourceHandle handle2;
1227     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1228                                             "core.led",
1229                                             "core.rw",
1230                                             "/a/led2",
1231                                             0,
1232                                             NULL,
1233                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1234     url = OCGetResourceUri(handle2);
1235     EXPECT_STREQ("/a/led2", url);
1236
1237     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
1238     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
1239
1240     OCResourceHandle handle3;
1241     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1242                                             "core.led",
1243                                             "core.rw",
1244                                             "/a/led3",
1245                                             0,
1246                                             NULL,
1247                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1248     url = OCGetResourceUri(handle3);
1249     EXPECT_STREQ("/a/led3", url);
1250
1251     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
1252     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
1253
1254     OCResourceHandle handle4;
1255     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1256                                             "core.led",
1257                                             "core.rw",
1258                                             "/a/led4",
1259                                             0,
1260                                             NULL,
1261                                             OC_DISCOVERABLE));
1262     url = OCGetResourceUri(handle4);
1263     EXPECT_STREQ("/a/led4", url);
1264
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));
1268
1269     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1270
1271     EXPECT_EQ(OC_STACK_OK, OCStop());
1272 }
1273
1274 TEST(StackBind, BindResourceTypeNameBad)
1275 {
1276     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1277     OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
1278     InitStack(OC_SERVER);
1279
1280     OCResourceHandle handle;
1281     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1282                                             "core.led",
1283                                             "core.rw",
1284                                             "/a/led",
1285                                             0,
1286                                             NULL,
1287                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1288
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);
1294
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"));
1298
1299     EXPECT_EQ(OC_STACK_OK, OCStop());
1300 }
1301
1302 TEST(StackBind, BindResourceTypeNameGood)
1303 {
1304     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1305     OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
1306     InitStack(OC_SERVER);
1307
1308     OCResourceHandle handle;
1309     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1310                                             "core.led",
1311                                             "core.rw",
1312                                             "/a/led",
1313                                             0,
1314                                             NULL,
1315                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1316
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);
1322
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);
1328
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);
1334
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);
1340
1341     EXPECT_EQ(OC_STACK_OK, OCStop());
1342 }
1343
1344 TEST(StackBind, BindResourceTypeAttribRepGood)
1345 {
1346     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1347     OIC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
1348     InitStack(OC_SERVER);
1349
1350     OCResourceHandle handle;
1351     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1352                                             "core.led",
1353                                             "core.rw",
1354                                             "/a/led",
1355                                             0,
1356                                             NULL,
1357                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1358
1359     uint8_t numResourceTypes;
1360     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1361     EXPECT_EQ(1, numResourceTypes);
1362
1363     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1364     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1365     EXPECT_EQ(2, numResourceTypes);
1366
1367     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1368     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1369     EXPECT_EQ(3, numResourceTypes);
1370
1371     EXPECT_EQ(OC_STACK_OK, OCStop());
1372 }
1373
1374
1375 TEST(StackBind, BindResourceInterfaceNameBad)
1376 {
1377     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1378     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
1379     InitStack(OC_SERVER);
1380
1381     OCResourceHandle handle;
1382     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1383                                             "core.led",
1384                                             "core.rw",
1385                                             "/a/led",
1386                                             0,
1387                                             NULL,
1388                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1389
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);
1395
1396     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
1397
1398     EXPECT_EQ(OC_STACK_OK, OCStop());
1399 }
1400
1401 TEST(StackBind, BindResourceInterfaceNameGood)
1402 {
1403     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1404     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
1405     InitStack(OC_SERVER);
1406
1407     OCResourceHandle handle;
1408     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1409                                             "core.led",
1410                                             "core.rw",
1411                                             "/a/led",
1412                                             0,
1413                                             NULL,
1414                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1415
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);
1421
1422     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1423
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);
1428
1429     EXPECT_EQ(OC_STACK_OK, OCStop());
1430 }
1431
1432 TEST(StackBind, BindResourceInterfaceMethodsBad)
1433 {
1434     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1435     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
1436     InitStack(OC_SERVER);
1437
1438     OCResourceHandle handle;
1439     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1440                                             "core.led",
1441                                             "core.rw",
1442                                             "/a/led",
1443                                             0,
1444                                             NULL,
1445                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1446
1447     uint8_t numResourceInterfaces;
1448     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1449     EXPECT_EQ(2, numResourceInterfaces);
1450
1451     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
1452
1453     EXPECT_EQ(OC_STACK_OK, OCStop());
1454 }
1455
1456 TEST(StackBind, BindResourceInterfaceMethodsGood)
1457 {
1458     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1459     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
1460     InitStack(OC_SERVER);
1461
1462     OCResourceHandle handle;
1463     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1464                                             "core.led",
1465                                             "core.rw",
1466                                             "/a/led",
1467                                             0,
1468                                             NULL,
1469                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1470
1471     uint8_t numResourceInterfaces;
1472     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1473     EXPECT_EQ(2, numResourceInterfaces);
1474
1475     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1476
1477     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1478     EXPECT_EQ(3, numResourceInterfaces);
1479
1480     EXPECT_EQ(OC_STACK_OK, OCStop());
1481 }
1482
1483 TEST(StackBind, BindContainedResourceBad)
1484 {
1485     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1486     OIC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
1487     InitStack(OC_SERVER);
1488
1489     OCResourceHandle containerHandle;
1490     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1491                                             "core.led",
1492                                             "core.rw",
1493                                             "/a/kitchen",
1494                                             0,
1495                                             NULL,
1496                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1497
1498     OCResourceHandle handle0;
1499     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1500                                             "core.led",
1501                                             "core.rw",
1502                                             "/a/led",
1503                                             0,
1504                                             NULL,
1505                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1506
1507     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1508
1509     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1510
1511     EXPECT_EQ(OC_STACK_OK, OCStop());
1512 }
1513
1514 TEST(StackBind, BindContainedResourceGood)
1515 {
1516     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1517     OIC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1518     InitStack(OC_SERVER);
1519
1520     uint8_t numResources = 0;
1521     uint8_t numExpectedResources = 0;
1522
1523     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1524
1525     OCResourceHandle containerHandle;
1526     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1527                                             "core.led",
1528                                             "core.rw",
1529                                             "/a/kitchen",
1530                                             0,
1531                                             NULL,
1532                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1533     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1534     EXPECT_EQ(++numExpectedResources, numResources);
1535
1536     OCResourceHandle handle0;
1537     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1538                                             "core.led",
1539                                             "core.rw",
1540                                             "/a/led0",
1541                                             0,
1542                                             NULL,
1543                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1544     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1545     EXPECT_EQ(++numExpectedResources, numResources);
1546
1547     OCResourceHandle handle1;
1548     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1549                                             "core.led",
1550                                             "core.rw",
1551                                             "/a/led1",
1552                                             0,
1553                                             NULL,
1554                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1555     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1556     EXPECT_EQ(++numExpectedResources, numResources);
1557
1558     OCResourceHandle handle2;
1559     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1560                                             "core.led",
1561                                             "core.rw",
1562                                             "/a/led2",
1563                                             0,
1564                                             NULL,
1565                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1566     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1567     EXPECT_EQ(++numExpectedResources, numResources);
1568
1569     OCResourceHandle handle3;
1570     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1571                                             "core.led",
1572                                             "core.rw",
1573                                             "/a/led3",
1574                                             0,
1575                                             NULL,
1576                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1577     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1578     EXPECT_EQ(++numExpectedResources, numResources);
1579
1580     OCResourceHandle handle4;
1581     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1582                                             "core.led",
1583                                             "core.rw",
1584                                             "/a/led4",
1585                                             0,
1586                                             NULL,
1587                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1588     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1589     EXPECT_EQ(++numExpectedResources, numResources);
1590
1591     OCResourceHandle handle5;
1592     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1593                                             "core.led",
1594                                             "core.rw",
1595                                             "/a/led5",
1596                                             0,
1597                                             NULL,
1598                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1599     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1600     EXPECT_EQ(++numExpectedResources, numResources);
1601
1602
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));
1609
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));
1616
1617     EXPECT_EQ(OC_STACK_OK, OCStop());
1618 }
1619
1620
1621 TEST(StackBind, BindEntityHandlerBad)
1622 {
1623     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1624     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1625     InitStack(OC_SERVER);
1626
1627     OCResourceHandle handle;
1628     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1629                                             "core.led",
1630                                             "core.rw",
1631                                             "/a/led",
1632                                             0,
1633                                             NULL,
1634                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1635
1636     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
1637
1638     EXPECT_EQ(OC_STACK_OK, OCStop());
1639 }
1640
1641 TEST(StackBind, BindEntityHandlerGood)
1642 {
1643     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1644     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1645     InitStack(OC_SERVER);
1646
1647     OCResourceHandle handle;
1648     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1649                                             "core.led",
1650                                             "core.rw",
1651                                             "/a/led",
1652                                             0,
1653                                             NULL,
1654                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1655
1656     OCEntityHandler myHandler = entityHandler;
1657
1658     EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
1659
1660     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1661
1662     EXPECT_EQ(OC_STACK_OK, OCStop());
1663 }
1664
1665 TEST(StackResourceAccess, GetResourceByIndex)
1666 {
1667     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1668     OIC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1669     InitStack(OC_SERVER);
1670
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,
1679                                             "core.led",
1680                                             "core.rw",
1681                                             "/a/kitchen",
1682                                             0,
1683                                             NULL,
1684                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1685     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1686     EXPECT_EQ(++numExpectedResources, numResources);
1687
1688     OCResourceHandle handle0;
1689     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1690                                             "core.led",
1691                                             "core.rw",
1692                                             "/a/led0",
1693                                             0,
1694                                             NULL,
1695                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1696     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1697     EXPECT_EQ(++numExpectedResources, numResources);
1698
1699     OCResourceHandle handle1;
1700     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1701                                             "core.led",
1702                                             "core.rw",
1703                                             "/a/led1",
1704                                             0,
1705                                             NULL,
1706                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1707     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1708     EXPECT_EQ(++numExpectedResources, numResources);
1709
1710     OCResourceHandle handle2;
1711     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1712                                             "core.led",
1713                                             "core.rw",
1714                                             "/a/led2",
1715                                             0,
1716                                             NULL,
1717                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1718     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1719     EXPECT_EQ(++numExpectedResources, numResources);
1720
1721     OCResourceHandle handle3;
1722     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1723                                             "core.led",
1724                                             "core.rw",
1725                                             "/a/led3",
1726                                             0,
1727                                             NULL,
1728                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1729     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1730     EXPECT_EQ(++numExpectedResources, numResources);
1731
1732     OCResourceHandle handle4;
1733     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1734                                             "core.led",
1735                                             "core.rw",
1736                                             "/a/led4",
1737                                             0,
1738                                             NULL,
1739                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1740     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1741     EXPECT_EQ(++numExpectedResources, numResources);
1742
1743     OCResourceHandle handle5;
1744     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1745                                             "core.led",
1746                                             "core.rw",
1747                                             "/a/led5",
1748                                             0,
1749                                             NULL,
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));
1761
1762     EXPECT_EQ(OC_STACK_OK, OCStop());
1763 }
1764
1765 TEST(StackResourceAccess, DeleteHeadResource)
1766 {
1767     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1768     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1769     InitStack(OC_SERVER);
1770
1771     uint8_t numResources = 0;
1772     uint8_t numExpectedResources = 0;
1773
1774     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1775
1776     OCResourceHandle handle0;
1777     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1778                                             "core.led",
1779                                             "core.rw",
1780                                             "/a/led0",
1781                                             0,
1782                                             NULL,
1783                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1784     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1785     EXPECT_EQ(++numExpectedResources, numResources);
1786
1787     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1788     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1789     EXPECT_EQ(--numExpectedResources, numResources);
1790
1791     EXPECT_EQ(OC_STACK_OK, OCStop());
1792 }
1793
1794 TEST(StackResourceAccess, DeleteHeadResource2)
1795 {
1796     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1797     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1798     InitStack(OC_SERVER);
1799
1800     uint8_t numResources = 0;
1801     uint8_t numExpectedResources = 0;
1802
1803     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1804     OCResourceHandle handle0;
1805     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1806                                             "core.led",
1807                                             "core.rw",
1808                                             "/a/led0",
1809                                             0,
1810                                             NULL,
1811                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1812     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1813     EXPECT_EQ(++numExpectedResources, numResources);
1814
1815     OCResourceHandle handle1;
1816     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1817                                             "core.led",
1818                                             "core.rw",
1819                                             "/a/led1",
1820                                             0,
1821                                             NULL,
1822                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1823     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1824     EXPECT_EQ(++numExpectedResources, numResources);
1825
1826     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1827     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1828     EXPECT_EQ(--numExpectedResources, numResources);
1829
1830     EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
1831
1832     EXPECT_EQ(OC_STACK_OK, OCStop());
1833 }
1834
1835
1836 TEST(StackResourceAccess, DeleteLastResource)
1837 {
1838     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1839     OIC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1840     InitStack(OC_SERVER);
1841
1842     uint8_t numResources = 0;
1843     uint8_t numExpectedResources = 0;
1844
1845     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1846
1847     OCResourceHandle handle0;
1848     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1849                                             "core.led",
1850                                             "core.rw",
1851                                             "/a/led0",
1852                                             0,
1853                                             NULL,
1854                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1855     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1856     EXPECT_EQ(++numExpectedResources, numResources);
1857
1858     OCResourceHandle handle1;
1859     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1860                                             "core.led",
1861                                             "core.rw",
1862                                             "/a/led1",
1863                                             0,
1864                                             NULL,
1865                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1866     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1867     EXPECT_EQ(++numExpectedResources, numResources);
1868
1869     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1870     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1871     EXPECT_EQ(--numExpectedResources, numResources);
1872
1873     EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
1874
1875     OCResourceHandle handle2;
1876     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1877                                             "core.led",
1878                                             "core.rw",
1879                                             "/a/led2",
1880                                             0,
1881                                             NULL,
1882                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1883     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1884     EXPECT_EQ(++numExpectedResources, numResources);
1885
1886     EXPECT_EQ(OC_STACK_OK, OCStop());
1887 }
1888
1889 TEST(StackResourceAccess, DeleteMiddleResource)
1890 {
1891     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1892     OIC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1893     InitStack(OC_SERVER);
1894
1895     uint8_t numResources = 0;
1896     uint8_t numExpectedResources = 0;
1897     uint8_t resourceIndex = InitResourceIndex();
1898
1899     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1900     resourceIndex = numExpectedResources;
1901     OCResourceHandle handle0;
1902     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1903                                             "core.led",
1904                                             "core.rw",
1905                                             "/a/led0",
1906                                             0,
1907                                             NULL,
1908                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1909     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1910     EXPECT_EQ(++numExpectedResources, numResources);
1911
1912     OCResourceHandle handle1;
1913     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1914                                             "core.led",
1915                                             "core.rw",
1916                                             "/a/led1",
1917                                             0,
1918                                             NULL,
1919                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1920     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1921     EXPECT_EQ(++numExpectedResources, numResources);
1922
1923     OCResourceHandle handle2;
1924     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1925                                             "core.led",
1926                                             "core.rw",
1927                                             "/a/led2",
1928                                             0,
1929                                             NULL,
1930                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1931     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1932     EXPECT_EQ(++numExpectedResources, numResources);
1933
1934     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1935     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1936     EXPECT_EQ(--numExpectedResources, numResources);
1937
1938     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1939     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1940
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);
1947
1948     EXPECT_EQ(OC_STACK_OK, OCStop());
1949 }
1950
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)
1954 {
1955     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1956 }
1957
1958 TEST(PODTests, OCCallbackData)
1959 {
1960     EXPECT_TRUE(std::is_pod<OCCallbackData>::value);
1961 }
1962 #endif
1963
1964 TEST(OCDoDirectPairingTests, Nullpeer)
1965 {
1966     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, NULL, pmSel, &pinNumber, &resultCallback));
1967 }
1968
1969 TEST(OCDoDirectPairingTests, NullCallback)
1970 {
1971     EXPECT_EQ(OC_STACK_INVALID_CALLBACK,OCDoDirectPairing(NULL, &peer, pmSel, &pinNumber, NULL));
1972 }
1973
1974 TEST(OCDoDirectPairingTests, NullpinNumber)
1975 {
1976     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, &peer, pmSel, NULL, &resultCallback));
1977 }
1978
1979 TEST(StackResource, MultipleResourcesDiscovery)
1980 {
1981     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1982     OIC_LOG(INFO, TAG, "Starting MultipleResourcesDiscovery test");
1983     InitStack(OC_SERVER);
1984
1985     OCResourceHandle handle1;
1986     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1987                                             "core.led",
1988                                             "core.rw",
1989                                             "/a/led1",
1990                                             0,
1991                                             NULL,
1992                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1993
1994     OCResourceHandle handle2;
1995     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1996                                             "core.led",
1997                                             "core.rw",
1998                                             "/a/led2",
1999                                             0,
2000                                             NULL,
2001                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2002     OCResourceHandle handle3;
2003     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
2004                                             "core.led",
2005                                             "core.rw",
2006                                             "/a/led3",
2007                                             0,
2008                                             NULL,
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;
2015     cbData.cd = NULL;
2016
2017     OCDoHandle handle;
2018     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
2019                                         OC_REST_DISCOVER,
2020                                         szQueryUri,
2021                                         0,
2022                                         0,
2023                                         CT_ADAPTER_IP,
2024                                         OC_LOW_QOS,
2025                                         &cbData,
2026                                         NULL,
2027                                         0));
2028
2029     EXPECT_EQ(OC_STACK_OK, OCStop());
2030 }
2031
2032 TEST(StackPayload, CloneByteString)
2033 {
2034     uint8_t bytes[] = { 0, 1, 2, 3 };
2035     OCByteString byteString;
2036     byteString.bytes = bytes;
2037     byteString.len = sizeof(bytes);
2038
2039     OCRepPayload *original = OCRepPayloadCreate();
2040     ASSERT_TRUE(original != NULL);
2041     EXPECT_TRUE(OCRepPayloadSetPropByteString(original, "name", byteString));
2042
2043     OCRepPayload *clone = OCRepPayloadClone(original);
2044     ASSERT_TRUE(clone != NULL);
2045
2046     OCRepPayloadDestroy(original);
2047
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);
2054
2055     OCRepPayloadDestroy(clone);
2056 }
2057
2058 TEST(StackUri, Rfc6874_Noop_1)
2059 {
2060     char validIPv6Address[] = "FF01:0:0:0:0:0:0:FB";
2061     char bytes[100] = {0};
2062     strncpy(bytes, validIPv6Address, sizeof(bytes));
2063
2064     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2065
2066     // No % sign, should do nothing
2067     EXPECT_STREQ(bytes, validIPv6Address);
2068     EXPECT_EQ(OC_STACK_OK, result);
2069 }
2070
2071 TEST(StackUri, Rfc6874_Noop_2)
2072 {
2073     char validIPv6Address[] = "3812:a61::4:1";
2074     char bytes[100] = {0};
2075
2076     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2077
2078     // No % sign, should do nothing
2079     EXPECT_STREQ(bytes, validIPv6Address);
2080     EXPECT_EQ(OC_STACK_OK, result);
2081 }
2082
2083 TEST(StackUri, Rfc6874_WithEncoding)
2084 {
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));
2089
2090     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2091
2092     // Encoding should have occured
2093     EXPECT_STREQ(bytes, validIPv6AddressEncoded);
2094     EXPECT_EQ(OC_STACK_OK, result);
2095 }
2096
2097 TEST(StackUri, Rfc6874_WithEncoding_ExtraPercent)
2098 {
2099     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%%wlan0";
2100     char bytes[100] = {0};
2101
2102     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2103
2104     // Encoding should have failed due to extra '%' character
2105     EXPECT_STREQ(bytes, "");
2106     EXPECT_EQ(OC_STACK_ERROR, result);
2107 }
2108
2109 TEST(StackUri, Rfc6874_AlreadyEncoded)
2110 {
2111     char validIPv6AddressEncoded[] = "fe80::dafe:e3ff:fe00:ebfa%25wlan0";
2112     char bytes[100] = {0};
2113
2114     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6AddressEncoded);
2115
2116     // Encoding should have failed due to extra '%' character
2117     EXPECT_STREQ(bytes, "");
2118     EXPECT_EQ(OC_STACK_ERROR, result);
2119 }
2120
2121 TEST(StackUri, Rfc6874_NoOverflow)
2122 {
2123     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0";
2124     char addrBuffer[100];
2125     char bytes[100] = {0};
2126     memset(addrBuffer, sizeof(addrBuffer), '_');
2127
2128     // Just enough room to encode
2129     addrBuffer[sizeof(addrBuffer) - sizeof(validIPv6Address) - 3] = '\0';
2130     strcat(addrBuffer, validIPv6Address);
2131
2132     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), addrBuffer);
2133
2134     // Encoding should have succeeded
2135     EXPECT_EQ(OC_STACK_OK, result);
2136 }
2137
2138 TEST(StackUri, Rfc6874_NoOverflow_2)
2139 {
2140     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0";
2141     char addrBuffer[100];
2142     char bytes[100] = {0};
2143     memset(addrBuffer, sizeof(addrBuffer), '_');
2144
2145     // Not enough room to encode
2146     addrBuffer[sizeof(addrBuffer) - sizeof(validIPv6Address) - 1] = '\0';
2147     strcat(addrBuffer, validIPv6Address);
2148
2149     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), addrBuffer);
2150
2151     // Encoding should have failed due to output size limitations
2152     EXPECT_STREQ(bytes, "");
2153     EXPECT_EQ(OC_STACK_ERROR, result);
2154 }
2155
2156 TEST(StackHeaderOption, setHeaderOption)
2157 {
2158     uint8_t optionValue1[MAX_HEADER_OPTION_DATA_LENGTH] =
2159     { 1 };
2160     OCHeaderOption options[MAX_HEADER_OPTIONS] =
2161     {
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,
2168                                              &numOptions,
2169                                              optionID,
2170                                              &optionData,
2171                                              optionDataSize));
2172     EXPECT_EQ(options[1].optionID, optionID);
2173     EXPECT_EQ(options[1].optionData[0], 255);
2174 }
2175
2176 TEST(StackHeaderOption, getHeaderOption)
2177 {
2178     uint8_t optionValue1[MAX_HEADER_OPTION_DATA_LENGTH] =
2179     { 1 };
2180     uint8_t optionValue2[MAX_HEADER_OPTION_DATA_LENGTH] =
2181     { 255 };
2182     OCHeaderOption options[MAX_HEADER_OPTIONS] =
2183     {
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,
2192                                              numOptions,
2193                                              optionID,
2194                                              optionData,
2195                                              optionDataSize,
2196                                              &actualDataSize));
2197     EXPECT_EQ(optionData[0], 1);
2198     EXPECT_EQ(actualDataSize, 8);
2199 }
2200
2201 static OCStackApplicationResult DiscoverBaslineResource(void *ctx, OCDoHandle handle,
2202     OCClientResponse *response)
2203 {
2204     OC_UNUSED(ctx);
2205     OC_UNUSED(handle);
2206     EXPECT_EQ(OC_STACK_OK, response->result);
2207     EXPECT_TRUE(NULL != response->payload);
2208     if (NULL != response->payload)
2209     {
2210         EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2211
2212         OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload;
2213         EXPECT_TRUE(NULL != payload->sid);
2214         if (payload->name)
2215         {
2216             EXPECT_STREQ("StackTest", payload->name);
2217         }
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);
2221
2222         for (OCResourcePayload *resource = payload->resources; resource; resource = resource->next)
2223         {
2224             if (0 == strcmp("/a/light", resource->uri))
2225             {
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);
2236             }
2237         }
2238     }
2239
2240     return OC_STACK_DELETE_TRANSACTION;
2241 }
2242
2243 static OCStackApplicationResult DiscoverLinkedListResource(void *ctx, OCDoHandle handle,
2244     OCClientResponse *response)
2245 {
2246     OC_UNUSED(ctx);
2247     OC_UNUSED(handle);
2248     EXPECT_EQ(OC_STACK_OK, response->result);
2249     EXPECT_TRUE(NULL != response->payload);
2250     if (NULL != response->payload)
2251     {
2252         EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2253
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);
2259
2260         for (OCResourcePayload *resource = payload->resources; resource; resource = resource->next)
2261         {
2262             if (0 == strcmp("/a/light", resource->uri))
2263             {
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);
2274             }
2275         }
2276     }
2277     return OC_STACK_DELETE_TRANSACTION;
2278 }
2279
2280
2281 static OCStackApplicationResult DiscoverResourceTypeResponse(void *ctx, OCDoHandle handle,
2282     OCClientResponse *response)
2283 {
2284     OC_UNUSED(ctx);
2285     OC_UNUSED(handle);
2286     EXPECT_EQ(OC_STACK_OK, response->result);
2287     EXPECT_TRUE(NULL != response->payload);
2288     if (NULL != response->payload)
2289     {
2290         EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2291
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);
2298
2299         OCResourcePayload *resource = payload->resources;
2300
2301         if (0 == strcmp("/a/light", resource->uri))
2302         {
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);
2313         }
2314     }
2315
2316     return OC_STACK_DELETE_TRANSACTION;
2317 }
2318
2319 static OCStackApplicationResult DiscoverNoResource(void *ctx, OCDoHandle handle,
2320     OCClientResponse *response)
2321 {
2322     OC_UNUSED(ctx);
2323     OC_UNUSED(handle);
2324     EXPECT_EQ(OC_STACK_OK, response->result);
2325     EXPECT_TRUE(NULL != response->payload);
2326     if (NULL != response->payload)
2327     {
2328         EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2329
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);
2335
2336         bool resourceFound = false;
2337         for (OCResourcePayload *resource = payload->resources; resource; resource = resource->next)
2338         {
2339             if (0 == strcmp("/a/light", resource->uri))
2340             {
2341                 resourceFound = true;
2342             }
2343         }
2344
2345         EXPECT_FALSE(resourceFound);
2346     }
2347     return OC_STACK_DELETE_TRANSACTION;
2348 }
2349
2350 static OCStackApplicationResult DiscoverUnicastErrorResponse(void *ctx, OCDoHandle handle,
2351     OCClientResponse *response)
2352 {
2353     OC_UNUSED(ctx);
2354     OC_UNUSED(handle);
2355     EXPECT_NE(OC_STACK_OK, response->result);
2356     EXPECT_TRUE(NULL == response->payload);
2357
2358     return OC_STACK_DELETE_TRANSACTION;
2359 }
2360
2361 TEST_F(OCDiscoverTests, DiscoverResourceWithInterfaceBaselineQuery)
2362 {
2363    itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2364
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);
2373 }
2374
2375 TEST_F(OCDiscoverTests, DiscoverResourceWithoutAnyQuery)
2376 {
2377    itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2378
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);
2387 }
2388
2389 TEST_F(OCDiscoverTests, DiscoverResourceWithInterfaceLinkedListQuery)
2390 {
2391     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2392
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);
2401 }
2402
2403 TEST_F(OCDiscoverTests, DiscoverResourceWithResourceTypeQuery)
2404 {
2405     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2406
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);
2415 }
2416
2417 TEST_F(OCDiscoverTests, DiscoverResourceWithInvalidInterfaceQuery_Unicast)
2418 {
2419     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2420
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);
2431 }
2432
2433 TEST_F(OCDiscoverTests, DiscoverResourceWithoutInterfaceQuery_Unicast)
2434 {
2435     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2436
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);
2447 }
2448
2449 TEST_F(OCDiscoverTests, DiscoverResourceWithInvalidResourceTypeQuery_Unicast)
2450 {
2451     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2452
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);
2463 }
2464
2465 TEST_F(OCDiscoverTests, DiscoverResourceWithoutResourceTypeQuery_Unicast)
2466 {
2467     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2468
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);
2479 }
2480
2481 TEST_F(OCDiscoverTests, DiscoverResourceWithInvalidResourceTypeQuery)
2482 {
2483     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2484
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));
2492     discoverCB.Wait(5);
2493 }
2494
2495 TEST_F(OCDiscoverTests, DiscoverResourceWithoutResourceTypeQuery)
2496 {
2497     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2498
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));
2506     discoverCB.Wait(5);
2507 }
2508
2509 TEST_F(OCDiscoverTests, DiscoverResourceWithInvalidInterfaceQuery)
2510 {
2511     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2512
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));
2520     discoverCB.Wait(5);
2521 }
2522
2523 TEST_F(OCDiscoverTests, DiscoverResourceWithoutInterfaceQuery)
2524 {
2525     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2526
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));
2534     discoverCB.Wait(5);
2535 }