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 "ocstack.h"
  25     #include "ocstackinternal.h"
  26     #include "logger.h"
  27     #include "oic_malloc.h"
  28 }
  29
  30 #include "gtest/gtest.h"
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <errno.h>
  34 #include <fcntl.h>
  35 #include <unistd.h>
  36 #include <stdlib.h>
  37
  38 //-----------------------------------------------------------------------------
  39 // Includes
  40 //-----------------------------------------------------------------------------
  41 #include <stdio.h>
  42 #include <string.h>
  43
  44 #include <iostream>
  45 #include <stdint.h>
  46
  47 #include "gtest_helper.h"
  48
  49 using namespace std;
  50
  51 namespace itst = iotivity::test;
  52
  53 #define DEFAULT_CONTEXT_VALUE 0x99
  54
  55 //-----------------------------------------------------------------------------
  56 // Private variables
  57 //-----------------------------------------------------------------------------
  58 static const char TAG[] = "TestHarness";
  59
  60 std::chrono::seconds const SHORT_TEST_TIMEOUT = std::chrono::seconds(5);
  61
  62 //-----------------------------------------------------------------------------
  63 // Callback functions
  64 //-----------------------------------------------------------------------------
  65 extern "C"  OCStackApplicationResult asyncDoResourcesCallback(void* ctx, OCDoHandle handle, OCClientResponse * clientResponse)
  66 {
  67     OC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
  68
  69     EXPECT_EQ(OC_STACK_OK, clientResponse->result);
  70
  71     if(ctx == (void*)DEFAULT_CONTEXT_VALUE) {
  72         OC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
  73     }
  74     OC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
  75
  76     return OC_STACK_KEEP_TRANSACTION;
  77 }
  78
  79 //-----------------------------------------------------------------------------
  80 // Entity handler
  81 //-----------------------------------------------------------------------------
  82 OCEntityHandlerResult entityHandler(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest,
  83                                     void* callbackParam)
  84 {
  85     OC_LOG(INFO, TAG, "Entering entityHandler");
  86
  87     return OC_EH_OK;
  88 }
  89
  90 //-----------------------------------------------------------------------------
  91 //  Local functions
  92 //-----------------------------------------------------------------------------
  93 void InitStack(OCMode mode)
  94 {
  95     OC_LOG(INFO, TAG, "Entering InitStack");
  96
  97     EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, mode));
  98     OC_LOG(INFO, TAG, "Leaving InitStack");
  99 }
 100
 101 uint8_t InitNumExpectedResources()
 102 {
 103 #ifdef WITH_PRESENCE
 104     // When presence is enabled, it is a resource and so is (currently) included
 105     // in the returned resource count returned by the OCGetNumberOfResources API.
 106     return 1;
 107 #else
 108     return 0;
 109 #endif
 110 }
 111
 112 uint8_t InitResourceIndex()
 113 {
 114 #ifdef WITH_PRESENCE
 115     // When presence is enabled, it is a resource and so is (currently) included
 116     // in the returned resource count returned by the OCGetNumberOfResources API.
 117     // The index of the presence resource is 0, so the first user app resource index
 118     // is 1.
 119     return 1;
 120 #else
 121     return 0;
 122 #endif
 123 }
 124 //-----------------------------------------------------------------------------
 125 //  Tests
 126 //-----------------------------------------------------------------------------
 127
 128 TEST(StackInit, StackInitNullAddr)
 129 {
 130     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 131     EXPECT_EQ(OC_STACK_OK, OCInit(0, 5683, OC_SERVER));
 132     EXPECT_EQ(OC_STACK_OK, OCStop());
 133 }
 134
 135 TEST(StackInit, StackInitNullPort)
 136 {
 137     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 138     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 0, OC_SERVER));
 139     EXPECT_EQ(OC_STACK_OK, OCStop());
 140 }
 141
 142 TEST(StackInit, StackInitNullAddrAndPort)
 143 {
 144     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 145     EXPECT_EQ(OC_STACK_OK, OCInit(0, 0, OC_SERVER));
 146     EXPECT_EQ(OC_STACK_OK, OCStop());
 147 }
 148
 149 TEST(StackInit, StackInitInvalidMode)
 150 {
 151     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 152     EXPECT_EQ(OC_STACK_ERROR, OCInit(0, 0, (OCMode)10));
 153     EXPECT_EQ(OC_STACK_ERROR, OCStop());
 154 }
 155
 156 TEST(StackStart, StackStartSuccessClient)
 157 {
 158     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 159     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 160     EXPECT_EQ(OC_STACK_OK, OCStop());
 161 }
 162
 163 TEST(StackStart, StackStartSuccessServer)
 164 {
 165     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 166     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 167     EXPECT_EQ(OC_STACK_OK, OCStop());
 168 }
 169
 170 TEST(StackStart, StackStartSuccessClientServer)
 171 {
 172     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 173     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
 174     EXPECT_EQ(OC_STACK_OK, OCStop());
 175 }
 176
 177 TEST(StackStart, StackStartSuccessiveInits)
 178 {
 179     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 180     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 181     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.2", 5683, OC_SERVER));
 182     EXPECT_EQ(OC_STACK_OK, OCStop());
 183 }
 184
 185 TEST(StackStart, SetPlatformInfoValid)
 186 {
 187     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 188     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 189
 190     OCPlatformInfo info = {};
 191     info.platformID = (char *) "platform_id";
 192     info.manufacturerName = (char *) "manufac_name";
 193
 194     EXPECT_EQ(OC_STACK_OK, OCSetPlatformInfo(info));
 195     EXPECT_EQ(OC_STACK_OK, OCStop());
 196 }
 197
 198 TEST(StackStart, SetPlatformInfoWithNoPlatformID)
 199 {
 200     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 201     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 202
 203     OCPlatformInfo info = {};
 204     info.manufacturerName = (char *) "manufac_name";
 205
 206     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 207     EXPECT_EQ(OC_STACK_OK, OCStop());
 208 }
 209
 210 TEST(StackStart, SetPlatformInfoWithNoManufacturerName)
 211 {
 212     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 213     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 214
 215     OCPlatformInfo info = {};
 216     info.platformID = (char *) "platform_id";
 217
 218     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 219     EXPECT_EQ(OC_STACK_OK, OCStop());
 220 }
 221
 222 TEST(StackStart, SetPlatformInfoWithZeroLengthManufacturerName)
 223 {
 224     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 225     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 226
 227     OCPlatformInfo info = {};
 228     info.platformID = (char *) "platform_id";
 229     info.manufacturerName = (char *) "";
 230
 231     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 232     EXPECT_EQ(OC_STACK_OK, OCStop());
 233 }
 234
 235 TEST(StackStart, SetPlatformInfoWithTooLongManufacName)
 236 {
 237     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 238     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 239
 240     OCPlatformInfo info = {};
 241     info.platformID = (char *) "platform_id";
 242     info.manufacturerName = (char *) "extremelylongmanufacturername";
 243
 244     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 245     EXPECT_EQ(OC_STACK_OK, OCStop());
 246 }
 247
 248 TEST(StackStart, SetPlatformInfoWithTooLongManufacURL)
 249 {
 250     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 251     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 252
 253     OCPlatformInfo info = {};
 254     info.platformID = (char *) "platform_id";
 255     info.manufacturerName = (char *) "extremelylongmanufacturername";
 256     info.manufacturerUrl = (char *)"www.foooooooooooooooo.baaaaaaaaaaaaar";
 257
 258     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 259     EXPECT_EQ(OC_STACK_OK, OCStop());
 260 }
 261
 262
 263 TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery)
 264 {
 265     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 266     OCCallbackData cbData;
 267     OCDoHandle handle;
 268
 269     OC_LOG(INFO, TAG, "Starting DoResourceDeviceDiscovery test ");
 270     InitStack(OC_CLIENT);
 271
 272     /* Start a discovery query*/
 273     char szQueryUri[64] = { 0 };
 274     strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
 275     cbData.cb = asyncDoResourcesCallback;
 276     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 277     cbData.cd = NULL;
 278     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
 279                                         OC_REST_GET,
 280                                         szQueryUri,
 281                                         0,
 282                                         0,
 283                                         OC_IPV4,
 284                                         OC_LOW_QOS,
 285                                         &cbData,
 286                                         NULL,
 287                                         0));
 288     EXPECT_EQ(OC_STACK_OK, OCStop());
 289 }
 290
 291 TEST(StackStop, StackStopWithoutInit)
 292 {
 293     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 294     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 295     EXPECT_EQ(OC_STACK_OK, OCStop());
 296     EXPECT_EQ(OC_STACK_ERROR, OCStop());
 297 }
 298
 299 TEST(StackResource, DISABLED_UpdateResourceNullURI)
 300 {
 301     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 302     OCCallbackData cbData;
 303     OCDoHandle handle;
 304
 305     OC_LOG(INFO, TAG, "Starting UpdateResourceNullURI test");
 306     InitStack(OC_CLIENT);
 307
 308     /* Start a discovery query*/
 309     char szQueryUri[64] = { 0 };
 310     strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
 311     cbData.cb = asyncDoResourcesCallback;
 312     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 313     cbData.cd = NULL;
 314     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
 315                                         OC_REST_GET,
 316                                         szQueryUri,
 317                                         0,
 318                                         0,
 319                                         OC_IPV4,
 320                                         OC_LOW_QOS,
 321                                         &cbData,
 322                                         NULL,
 323                                         0));
 324     EXPECT_EQ(OC_STACK_OK, OCStop());
 325 }
 326
 327 TEST(StackResource, CreateResourceBadParams)
 328 {
 329     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 330     OC_LOG(INFO, TAG, "Starting CreateResourceBadParams test");
 331     InitStack(OC_SERVER);
 332
 333     OCResourceHandle handle;
 334
 335     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(NULL, //&handle,
 336                                             "core.led",
 337                                             "core.rw",
 338                                             "/a/led",
 339                                             0,
 340                                             NULL,
 341                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 342
 343     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 344                                             NULL, //"core.led",
 345                                             "core.rw",
 346                                             "/a/led",
 347                                             0,
 348                                             NULL,
 349                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 350
 351     // Property bitmask out of range
 352     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 353                                             "core.led",
 354                                             "core.rw",
 355                                             "/a/led",
 356                                             0,
 357                                             NULL,
 358                                             128));// invalid bitmask for OCResourceProperty
 359
 360     EXPECT_EQ(OC_STACK_OK, OCStop());
 361 }
 362
 363 TEST(StackResource, CreateResourceBadUri)
 364 {
 365     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 366     OC_LOG(INFO, TAG, "Starting CreateResourceBadUri test");
 367     InitStack(OC_SERVER);
 368
 369     const char *uri65 = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKL";
 370
 371     OCResourceHandle handle;
 372
 373     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 374                                             "core.led",
 375                                             "core.rw",
 376                                             NULL, //"/a/led",
 377                                             0,
 378                                             0,
 379                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 380
 381     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 382                                             "core.led",
 383                                             "core.rw",
 384                                             "", //"/a/led",
 385                                             0,
 386                                             0,
 387                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 388
 389     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 390                                             "core.led",
 391                                             "core.rw",
 392                                             uri65, //"/a/led",
 393                                             0,
 394                                             0,
 395                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 396
 397     EXPECT_EQ(OC_STACK_OK, OCStop());
 398 }
 399
 400 TEST(StackResource, CreateResourceSuccess)
 401 {
 402     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 403     OC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
 404     InitStack(OC_SERVER);
 405
 406     OCResourceHandle handle;
 407     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 408                                             "core.led",
 409                                             "core.rw",
 410                                             "/a/led",
 411                                             0,
 412                                             NULL,
 413                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 414     const char *url = OCGetResourceUri(handle);
 415     EXPECT_STREQ("/a/led", url);
 416
 417     EXPECT_EQ(OC_STACK_OK, OCStop());
 418 }
 419
 420 TEST(StackResource, CreateResourceFailDuplicateUri)
 421 {
 422     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 423     OC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
 424     InitStack(OC_SERVER);
 425
 426     OCResourceHandle handle;
 427     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 428                                             "core.led",
 429                                             "core.rw",
 430                                             "/a/led",
 431                                             0,
 432                                             NULL,
 433                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 434     const char *url = OCGetResourceUri(handle);
 435     EXPECT_STREQ("/a/led", url);
 436
 437     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 438                                             "core.led",
 439                                             "core.rw",
 440                                             "/a/led",
 441                                             0,
 442                                             NULL,
 443                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 444
 445     EXPECT_EQ(OC_STACK_OK, OCStop());
 446 }
 447
 448 TEST(StackResource, CreateResourceMultipleResources)
 449 {
 450     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 451     OC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
 452     InitStack(OC_SERVER);
 453
 454     OCResourceHandle handle1;
 455     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 456                                             "core.led",
 457                                             "core.rw",
 458                                             "/a/led1",
 459                                             0,
 460                                             NULL,
 461                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 462
 463     OCResourceHandle handle2;
 464     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 465                                             "core.led",
 466                                             "core.rw",
 467                                             "/a/led2",
 468                                             0,
 469                                             NULL,
 470                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 471     OCResourceHandle handle3;
 472     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 473                                             "core.led",
 474                                             "core.rw",
 475                                             "/a/led3",
 476                                             0,
 477                                             NULL,
 478                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 479
 480     const char *url = OCGetResourceUri(handle1);
 481     EXPECT_STREQ("/a/led1", url);
 482
 483     url = OCGetResourceUri(handle2);
 484     EXPECT_STREQ("/a/led2", url);
 485
 486     url = OCGetResourceUri(handle3);
 487     EXPECT_STREQ("/a/led3", url);
 488
 489     EXPECT_EQ(OC_STACK_OK, OCStop());
 490 }
 491
 492 TEST(StackResource, CreateResourceBadResoureType)
 493 {
 494     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 495     OC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
 496     InitStack(OC_SERVER);
 497
 498     OCResourceHandle handle;
 499     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 500                                             NULL, //"core.led",
 501                                             "core.rw",
 502                                             "/a/led",
 503                                             0,
 504                                             NULL,
 505                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 506
 507     EXPECT_EQ(OC_STACK_OK, OCStop());
 508 }
 509
 510 TEST(StackResource, CreateResourceGoodResourceType)
 511 {
 512     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 513     OC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
 514     InitStack(OC_SERVER);
 515
 516     OCResourceHandle handle;
 517     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 518                                             "core.led",
 519                                             "core.rw",
 520                                             "/a/led",
 521                                             0,
 522                                             NULL,
 523                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 524
 525     EXPECT_EQ(OC_STACK_OK, OCStop());
 526 }
 527
 528 TEST(StackResource, ResourceTypeName)
 529 {
 530     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 531     OC_LOG(INFO, TAG, "Starting ResourceTypeName test");
 532     InitStack(OC_SERVER);
 533
 534     OCResourceHandle handle;
 535     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 536                                             "core.led",
 537                                             "core.rw",
 538                                             "/a/led",
 539                                             0,
 540                                             NULL,
 541                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 542
 543     uint8_t numResourceTypes;
 544     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 545     EXPECT_EQ(1, numResourceTypes);
 546     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 547     EXPECT_STREQ("core.led", resourceTypeName);
 548
 549     // try getting resource type names with an invalid index
 550     resourceTypeName = OCGetResourceTypeName(handle, 1);
 551     EXPECT_STREQ(NULL, resourceTypeName);
 552     // try getting resource type names with an invalid index
 553     resourceTypeName = OCGetResourceTypeName(handle, 10);
 554     EXPECT_STREQ(NULL, resourceTypeName);
 555
 556     EXPECT_EQ(OC_STACK_OK, OCStop());
 557 }
 558
 559 TEST(StackResource, ResourceTypeAttrRepresentation)
 560 {
 561     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 562     OC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
 563     InitStack(OC_SERVER);
 564
 565     OCResourceHandle handle;
 566     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 567                                             "core.led",
 568                                             "core.rw",
 569                                             "/a/led",
 570                                             0,
 571                                             NULL,
 572                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 573
 574     uint8_t numResourceTypes;
 575     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 576     EXPECT_EQ(1, numResourceTypes);
 577
 578     EXPECT_EQ(OC_STACK_OK, OCStop());
 579 }
 580
 581 TEST(StackResource, ResourceTypeInterface)
 582 {
 583     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 584     OC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
 585     InitStack(OC_SERVER);
 586
 587     OCResourceHandle handle;
 588     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 589                                             "core.led",
 590                                             "core.rw",
 591                                             "/a/led",
 592                                             0,
 593                                             NULL,
 594                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 595
 596     uint8_t numResourceInterfaces;
 597     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 598     EXPECT_EQ(1, numResourceInterfaces);
 599     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 600     EXPECT_STREQ("core.rw", resourceInterfaceName);
 601
 602     // try getting resource interface names with an invalid index
 603     resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
 604     EXPECT_STREQ(NULL, resourceInterfaceName);
 605     // try getting resource interface names with an invalid index
 606     resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
 607     EXPECT_STREQ(NULL, resourceInterfaceName);
 608
 609     EXPECT_EQ(OC_STACK_OK, OCStop());
 610 }
 611
 612 TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
 613 {
 614     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 615
 616     OC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
 617
 618     InitStack(OC_SERVER);
 619
 620     OCResourceHandle handle;
 621     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 622                                             "core.led",
 623                                             "core.rw",
 624                                             "/a/led",
 625                                             0,
 626                                             NULL,
 627                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 628     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 629                                         OC_RSRVD_INTERFACE_DEFAULT));
 630     uint8_t numResourceInterfaces;
 631     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 632     EXPECT_EQ(2, numResourceInterfaces);
 633
 634     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
 635     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
 636
 637     const char*interfaceName_2 = OCGetResourceInterfaceName(handle, 1);
 638     EXPECT_STREQ("core.rw", interfaceName_2);
 639
 640     EXPECT_EQ(OC_STACK_OK, OCStop());
 641 }
 642
 643 TEST(StackResource, ResourceDuplicateDefaultInterfaces)
 644 {
 645     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 646
 647     OC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
 648
 649     InitStack(OC_SERVER);
 650
 651     OCResourceHandle handle;
 652     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 653                                             "core.led",
 654                                             "core.rw",
 655                                             "/a/led",
 656                                             0,
 657                                             NULL,
 658                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 659
 660     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 661                                         OC_RSRVD_INTERFACE_DEFAULT));
 662     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 663                                         OC_RSRVD_INTERFACE_DEFAULT));
 664
 665     uint8_t numResourceInterfaces;
 666     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 667     EXPECT_EQ(2, numResourceInterfaces);
 668
 669     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
 670     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
 671
 672     EXPECT_EQ(OC_STACK_OK, OCStop());
 673 }
 674
 675 TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
 676 {
 677     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 678
 679     OC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
 680
 681     InitStack(OC_SERVER);
 682
 683     OCResourceHandle handle;
 684     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 685                                             "core.led",
 686                                             "core.rw",
 687                                             "/a/led",
 688                                             0,
 689                                             NULL,
 690                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 691
 692     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 693                                         "core.rw"));
 694     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 695                                         "core.rw"));
 696
 697     uint8_t numResourceInterfaces;
 698     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 699     EXPECT_EQ(1, numResourceInterfaces);
 700
 701     EXPECT_EQ(OC_STACK_OK, OCStop());
 702 }
 703
 704 TEST(StackResource, ResourceTypeInterfaceMethods)
 705 {
 706     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 707     OC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
 708     InitStack(OC_SERVER);
 709
 710     OCResourceHandle handle;
 711     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 712                                             "core.led",
 713                                             "core.rw",
 714                                             "/a/led",
 715                                             0,
 716                                             NULL,
 717                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 718
 719     uint8_t numResourceInterfaces;
 720     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 721     EXPECT_EQ(1, numResourceInterfaces);
 722
 723     EXPECT_EQ(OC_STACK_OK, OCStop());
 724 }
 725
 726 TEST(StackResource, GetResourceProperties)
 727 {
 728     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 729     OC_LOG(INFO, TAG, "Starting GetResourceProperties test");
 730     InitStack(OC_SERVER);
 731
 732     OCResourceHandle handle;
 733     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 734                                             "core.led",
 735                                             "core.rw",
 736                                             "/a/led",
 737                                             0,
 738                                             NULL,
 739                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 740
 741     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
 742     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 743
 744     EXPECT_EQ(OC_STACK_OK, OCStop());
 745 }
 746
 747 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
 748 {
 749     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 750     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
 751     InitStack(OC_SERVER);
 752     uint8_t numResources = 0;
 753     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 754
 755     OCResourceHandle handle;
 756     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 757                                             "core.led",
 758                                             "core.rw",
 759                                             "/a1/led",
 760                                             0,
 761                                             NULL,
 762                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 763     const char *url = OCGetResourceUri(handle);
 764     EXPECT_STREQ("/a1/led", url);
 765
 766     //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
 767     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 768     uint8_t numExpectedResources = 0;
 769
 770     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
 771     EXPECT_EQ(numExpectedResources, numResources);
 772
 773     EXPECT_EQ(OC_STACK_OK, OCStop());
 774 }
 775
 776 TEST(StackResource, StackTestResourceDiscoverOneResource)
 777 {
 778     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 779     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
 780     InitStack(OC_SERVER);
 781
 782     OCResourceHandle handle;
 783     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 784                                             "core.led",
 785                                             "core.rw",
 786                                             "/a/led",
 787                                             0,
 788                                             NULL,
 789                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 790     const char *url = OCGetResourceUri(handle);
 791     EXPECT_STREQ("/a/led", url);
 792
 793     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 794     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 795
 796     EXPECT_EQ(OC_STACK_OK, OCStop());
 797 }
 798
 799 TEST(StackResource, StackTestResourceDiscoverManyResources)
 800 {
 801     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 802     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
 803     InitStack(OC_SERVER);
 804
 805     OCResourceHandle handle1;
 806     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 807                                             "core.led",
 808                                             "core.rw",
 809                                             "/a/led1",
 810                                             0,
 811                                             NULL,
 812                                             OC_DISCOVERABLE));
 813     const char *url = OCGetResourceUri(handle1);
 814     EXPECT_STREQ("/a/led1", url);
 815
 816     OCResourceHandle handle2;
 817     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 818                                             "core.led",
 819                                             "core.rw",
 820                                             "/a/led2",
 821                                             0,
 822                                             NULL,
 823                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 824     url = OCGetResourceUri(handle2);
 825     EXPECT_STREQ("/a/led2", url);
 826
 827     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
 828     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
 829
 830     OCResourceHandle handle3;
 831     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 832                                             "core.led",
 833                                             "core.rw",
 834                                             "/a/led3",
 835                                             0,
 836                                             NULL,
 837                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 838     url = OCGetResourceUri(handle3);
 839     EXPECT_STREQ("/a/led3", url);
 840
 841     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
 842     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
 843
 844     OCResourceHandle handle4;
 845     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
 846                                             "core.led",
 847                                             "core.rw",
 848                                             "/a/led4",
 849                                             0,
 850                                             NULL,
 851                                             OC_DISCOVERABLE));
 852     url = OCGetResourceUri(handle4);
 853     EXPECT_STREQ("/a/led4", url);
 854
 855     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
 856     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
 857     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
 858
 859     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 860
 861     EXPECT_EQ(OC_STACK_OK, OCStop());
 862 }
 863
 864 TEST(StackBind, BindResourceTypeNameBad)
 865 {
 866     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 867     OC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
 868     InitStack(OC_SERVER);
 869
 870     OCResourceHandle handle;
 871     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 872                                             "core.led",
 873                                             "core.rw",
 874                                             "/a/led",
 875                                             0,
 876                                             NULL,
 877                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 878
 879     uint8_t numResourceTypes;
 880     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 881     EXPECT_EQ(1, numResourceTypes);
 882     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 883     EXPECT_STREQ("core.led", resourceTypeName);
 884
 885     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
 886
 887     EXPECT_EQ(OC_STACK_OK, OCStop());
 888 }
 889
 890 TEST(StackBind, BindResourceTypeNameGood)
 891 {
 892     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 893     OC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
 894     InitStack(OC_SERVER);
 895
 896     OCResourceHandle handle;
 897     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 898                                             "core.led",
 899                                             "core.rw",
 900                                             "/a/led",
 901                                             0,
 902                                             NULL,
 903                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 904
 905     uint8_t numResourceTypes;
 906     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 907     EXPECT_EQ(1, numResourceTypes);
 908     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 909     EXPECT_STREQ("core.led", resourceTypeName);
 910
 911     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
 912     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 913     EXPECT_EQ(2, numResourceTypes);
 914     resourceTypeName = OCGetResourceTypeName(handle, 1);
 915     EXPECT_STREQ("core.brightled", resourceTypeName);
 916
 917     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
 918     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 919     EXPECT_EQ(3, numResourceTypes);
 920     resourceTypeName = OCGetResourceTypeName(handle, 2);
 921     EXPECT_STREQ("core.reallybrightled", resourceTypeName);
 922
 923     EXPECT_EQ(OC_STACK_OK, OCStop());
 924 }
 925
 926 TEST(StackBind, BindResourceTypeAttribRepGood)
 927 {
 928     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 929     OC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
 930     InitStack(OC_SERVER);
 931
 932     OCResourceHandle handle;
 933     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 934                                             "core.led",
 935                                             "core.rw",
 936                                             "/a/led",
 937                                             0,
 938                                             NULL,
 939                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 940
 941     uint8_t numResourceTypes;
 942     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 943     EXPECT_EQ(1, numResourceTypes);
 944
 945     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
 946     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 947     EXPECT_EQ(2, numResourceTypes);
 948
 949     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
 950     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 951     EXPECT_EQ(3, numResourceTypes);
 952
 953     EXPECT_EQ(OC_STACK_OK, OCStop());
 954 }
 955
 956
 957 TEST(StackBind, BindResourceInterfaceNameBad)
 958 {
 959     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 960     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
 961     InitStack(OC_SERVER);
 962
 963     OCResourceHandle handle;
 964     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 965                                             "core.led",
 966                                             "core.rw",
 967                                             "/a/led",
 968                                             0,
 969                                             NULL,
 970                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 971
 972     uint8_t numResourceInterfaces;
 973     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 974     EXPECT_EQ(1, numResourceInterfaces);
 975     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 976     EXPECT_STREQ("core.rw", resourceInterfaceName);
 977
 978     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
 979
 980     EXPECT_EQ(OC_STACK_OK, OCStop());
 981 }
 982
 983 TEST(StackBind, BindResourceInterfaceNameGood)
 984 {
 985     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 986     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
 987     InitStack(OC_SERVER);
 988
 989     OCResourceHandle handle;
 990     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 991                                             "core.led",
 992                                             "core.rw",
 993                                             "/a/led",
 994                                             0,
 995                                             NULL,
 996                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 997
 998     uint8_t numResourceInterfaces;
 999     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1000     EXPECT_EQ(1, numResourceInterfaces);
1001     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
1002     EXPECT_STREQ("core.rw", resourceInterfaceName);
1003
1004     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1005
1006     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1007     EXPECT_EQ(2, numResourceInterfaces);
1008     resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1009     EXPECT_STREQ("core.r", resourceInterfaceName);
1010
1011     EXPECT_EQ(OC_STACK_OK, OCStop());
1012 }
1013
1014 TEST(StackBind, BindResourceInterfaceMethodsBad)
1015 {
1016     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1017     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
1018     InitStack(OC_SERVER);
1019
1020     OCResourceHandle handle;
1021     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1022                                             "core.led",
1023                                             "core.rw",
1024                                             "/a/led",
1025                                             0,
1026                                             NULL,
1027                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1028
1029     uint8_t numResourceInterfaces;
1030     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1031     EXPECT_EQ(1, numResourceInterfaces);
1032
1033     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
1034
1035     EXPECT_EQ(OC_STACK_OK, OCStop());
1036 }
1037
1038 TEST(StackBind, BindResourceInterfaceMethodsGood)
1039 {
1040     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1041     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
1042     InitStack(OC_SERVER);
1043
1044     OCResourceHandle handle;
1045     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1046                                             "core.led",
1047                                             "core.rw",
1048                                             "/a/led",
1049                                             0,
1050                                             NULL,
1051                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1052
1053     uint8_t numResourceInterfaces;
1054     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1055     EXPECT_EQ(1, numResourceInterfaces);
1056
1057     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1058
1059     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1060     EXPECT_EQ(2, numResourceInterfaces);
1061
1062     EXPECT_EQ(OC_STACK_OK, OCStop());
1063 }
1064
1065 TEST(StackBind, BindContainedResourceBad)
1066 {
1067     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1068     OC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
1069     InitStack(OC_SERVER);
1070
1071     OCResourceHandle containerHandle;
1072     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1073                                             "core.led",
1074                                             "core.rw",
1075                                             "/a/kitchen",
1076                                             0,
1077                                             NULL,
1078                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1079
1080     OCResourceHandle handle0;
1081     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1082                                             "core.led",
1083                                             "core.rw",
1084                                             "/a/led",
1085                                             0,
1086                                             NULL,
1087                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1088
1089     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1090
1091     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1092
1093     EXPECT_EQ(OC_STACK_OK, OCStop());
1094 }
1095
1096 TEST(StackBind, BindContainedResourceGood)
1097 {
1098     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1099     OC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1100     InitStack(OC_SERVER);
1101
1102     uint8_t numResources = 0;
1103     uint8_t numExpectedResources = 0;
1104
1105     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1106
1107     OCResourceHandle containerHandle;
1108     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1109                                             "core.led",
1110                                             "core.rw",
1111                                             "/a/kitchen",
1112                                             0,
1113                                             NULL,
1114                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1115     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1116     EXPECT_EQ(++numExpectedResources, numResources);
1117
1118     OCResourceHandle handle0;
1119     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1120                                             "core.led",
1121                                             "core.rw",
1122                                             "/a/led0",
1123                                             0,
1124                                             NULL,
1125                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1126     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1127     EXPECT_EQ(++numExpectedResources, numResources);
1128
1129     OCResourceHandle handle1;
1130     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1131                                             "core.led",
1132                                             "core.rw",
1133                                             "/a/led1",
1134                                             0,
1135                                             NULL,
1136                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1137     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1138     EXPECT_EQ(++numExpectedResources, numResources);
1139
1140     OCResourceHandle handle2;
1141     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1142                                             "core.led",
1143                                             "core.rw",
1144                                             "/a/led2",
1145                                             0,
1146                                             NULL,
1147                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1148     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1149     EXPECT_EQ(++numExpectedResources, numResources);
1150
1151     OCResourceHandle handle3;
1152     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1153                                             "core.led",
1154                                             "core.rw",
1155                                             "/a/led3",
1156                                             0,
1157                                             NULL,
1158                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1159     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1160     EXPECT_EQ(++numExpectedResources, numResources);
1161
1162     OCResourceHandle handle4;
1163     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1164                                             "core.led",
1165                                             "core.rw",
1166                                             "/a/led4",
1167                                             0,
1168                                             NULL,
1169                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1170     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1171     EXPECT_EQ(++numExpectedResources, numResources);
1172
1173     OCResourceHandle handle5;
1174     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1175                                             "core.led",
1176                                             "core.rw",
1177                                             "/a/led5",
1178                                             0,
1179                                             NULL,
1180                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1181     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1182     EXPECT_EQ(++numExpectedResources, numResources);
1183
1184
1185     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1186     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1187     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1188     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1189     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1190     EXPECT_EQ(OC_STACK_ERROR, OCBindResource(containerHandle, handle5));
1191
1192     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1193     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1194     EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1195     EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1196     EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1197
1198     EXPECT_EQ(NULL, OCGetResourceHandleFromCollection(containerHandle, 5));
1199
1200     EXPECT_EQ(OC_STACK_OK, OCStop());
1201 }
1202
1203
1204 TEST(StackBind, BindEntityHandlerBad)
1205 {
1206     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1207     OC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1208     InitStack(OC_SERVER);
1209
1210     OCResourceHandle handle;
1211     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1212                                             "core.led",
1213                                             "core.rw",
1214                                             "/a/led",
1215                                             0,
1216                                             NULL,
1217                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1218
1219     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
1220
1221     EXPECT_EQ(OC_STACK_OK, OCStop());
1222 }
1223
1224 TEST(StackBind, BindEntityHandlerGood)
1225 {
1226     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1227     OC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1228     InitStack(OC_SERVER);
1229
1230     OCResourceHandle handle;
1231     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1232                                             "core.led",
1233                                             "core.rw",
1234                                             "/a/led",
1235                                             0,
1236                                             NULL,
1237                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1238
1239     OCEntityHandler myHandler = entityHandler;
1240
1241     EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
1242
1243     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1244
1245     EXPECT_EQ(OC_STACK_OK, OCStop());
1246 }
1247
1248 TEST(StackResourceAccess, GetResourceByIndex)
1249 {
1250     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1251     OC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1252     InitStack(OC_SERVER);
1253
1254     uint8_t numResources = 0;
1255     uint8_t numExpectedResources = 0;
1256     uint8_t resourceIndex = 0;
1257     uint8_t prevResources = 0;
1258     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1259     prevResources = numExpectedResources;
1260     OCResourceHandle containerHandle;
1261     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1262                                             "core.led",
1263                                             "core.rw",
1264                                             "/a/kitchen",
1265                                             0,
1266                                             NULL,
1267                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1268     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1269     EXPECT_EQ(++numExpectedResources, numResources);
1270
1271     OCResourceHandle handle0;
1272     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1273                                             "core.led",
1274                                             "core.rw",
1275                                             "/a/led0",
1276                                             0,
1277                                             NULL,
1278                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1279     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1280     EXPECT_EQ(++numExpectedResources, numResources);
1281
1282     OCResourceHandle handle1;
1283     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1284                                             "core.led",
1285                                             "core.rw",
1286                                             "/a/led1",
1287                                             0,
1288                                             NULL,
1289                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1290     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1291     EXPECT_EQ(++numExpectedResources, numResources);
1292
1293     OCResourceHandle handle2;
1294     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1295                                             "core.led",
1296                                             "core.rw",
1297                                             "/a/led2",
1298                                             0,
1299                                             NULL,
1300                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1301     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1302     EXPECT_EQ(++numExpectedResources, numResources);
1303
1304     OCResourceHandle handle3;
1305     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1306                                             "core.led",
1307                                             "core.rw",
1308                                             "/a/led3",
1309                                             0,
1310                                             NULL,
1311                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1312     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1313     EXPECT_EQ(++numExpectedResources, numResources);
1314
1315     OCResourceHandle handle4;
1316     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1317                                             "core.led",
1318                                             "core.rw",
1319                                             "/a/led4",
1320                                             0,
1321                                             NULL,
1322                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1323     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1324     EXPECT_EQ(++numExpectedResources, numResources);
1325
1326     OCResourceHandle handle5;
1327     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1328                                             "core.led",
1329                                             "core.rw",
1330                                             "/a/led5",
1331                                             0,
1332                                             NULL,
1333                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1334     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1335     EXPECT_EQ(++numExpectedResources, numResources);
1336     resourceIndex += prevResources;
1337     EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1338     EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1339     EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1340     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1341     EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1342     EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1343     EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1344
1345     EXPECT_EQ(OC_STACK_OK, OCStop());
1346 }
1347
1348 TEST(StackResourceAccess, DeleteHeadResource)
1349 {
1350     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1351     OC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1352     InitStack(OC_SERVER);
1353
1354     uint8_t numResources = 0;
1355     uint8_t numExpectedResources = 0;
1356
1357     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1358
1359     OCResourceHandle handle0;
1360     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1361                                             "core.led",
1362                                             "core.rw",
1363                                             "/a/led0",
1364                                             0,
1365                                             NULL,
1366                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1367     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1368     EXPECT_EQ(++numExpectedResources, numResources);
1369
1370     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1371     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1372     EXPECT_EQ(--numExpectedResources, numResources);
1373
1374     EXPECT_EQ(OC_STACK_OK, OCStop());
1375 }
1376
1377 TEST(StackResourceAccess, DeleteHeadResource2)
1378 {
1379     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1380     OC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1381     InitStack(OC_SERVER);
1382
1383     uint8_t numResources = 0;
1384     uint8_t numExpectedResources = 0;
1385
1386     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1387     OCResourceHandle handle0;
1388     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1389                                             "core.led",
1390                                             "core.rw",
1391                                             "/a/led0",
1392                                             0,
1393                                             NULL,
1394                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1395     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1396     EXPECT_EQ(++numExpectedResources, numResources);
1397
1398     OCResourceHandle handle1;
1399     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1400                                             "core.led",
1401                                             "core.rw",
1402                                             "/a/led1",
1403                                             0,
1404                                             NULL,
1405                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1406     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1407     EXPECT_EQ(++numExpectedResources, numResources);
1408
1409     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1410     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1411     EXPECT_EQ(--numExpectedResources, numResources);
1412
1413     EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
1414
1415     EXPECT_EQ(OC_STACK_OK, OCStop());
1416 }
1417
1418
1419 TEST(StackResourceAccess, DeleteLastResource)
1420 {
1421     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1422     OC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1423     InitStack(OC_SERVER);
1424
1425     uint8_t numResources = 0;
1426     uint8_t numExpectedResources = 0;
1427
1428     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1429
1430     OCResourceHandle handle0;
1431     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1432                                             "core.led",
1433                                             "core.rw",
1434                                             "/a/led0",
1435                                             0,
1436                                             NULL,
1437                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1438     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1439     EXPECT_EQ(++numExpectedResources, numResources);
1440
1441     OCResourceHandle handle1;
1442     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1443                                             "core.led",
1444                                             "core.rw",
1445                                             "/a/led1",
1446                                             0,
1447                                             NULL,
1448                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1449     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1450     EXPECT_EQ(++numExpectedResources, numResources);
1451
1452     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1453     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1454     EXPECT_EQ(--numExpectedResources, numResources);
1455
1456     EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
1457
1458     OCResourceHandle handle2;
1459     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1460                                             "core.led",
1461                                             "core.rw",
1462                                             "/a/led2",
1463                                             0,
1464                                             NULL,
1465                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1466     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1467     EXPECT_EQ(++numExpectedResources, numResources);
1468
1469     EXPECT_EQ(OC_STACK_OK, OCStop());
1470 }
1471
1472 TEST(StackResourceAccess, DeleteMiddleResource)
1473 {
1474     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1475     OC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1476     InitStack(OC_SERVER);
1477
1478     uint8_t numResources = 0;
1479     uint8_t numExpectedResources = 0;
1480     uint8_t resourceIndex = InitResourceIndex();
1481
1482     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1483     resourceIndex = numExpectedResources;
1484     OCResourceHandle handle0;
1485     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1486                                             "core.led",
1487                                             "core.rw",
1488                                             "/a/led0",
1489                                             0,
1490                                             NULL,
1491                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1492     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1493     EXPECT_EQ(++numExpectedResources, numResources);
1494
1495     OCResourceHandle handle1;
1496     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1497                                             "core.led",
1498                                             "core.rw",
1499                                             "/a/led1",
1500                                             0,
1501                                             NULL,
1502                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1503     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1504     EXPECT_EQ(++numExpectedResources, numResources);
1505
1506     OCResourceHandle handle2;
1507     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1508                                             "core.led",
1509                                             "core.rw",
1510                                             "/a/led2",
1511                                             0,
1512                                             NULL,
1513                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1514     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1515     EXPECT_EQ(++numExpectedResources, numResources);
1516
1517     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1518     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1519     EXPECT_EQ(--numExpectedResources, numResources);
1520
1521     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1522     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1523
1524     // Make sure the resource elements are still correct
1525     uint8_t numResourceInterfaces;
1526     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1527     EXPECT_EQ(1, numResourceInterfaces);
1528     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0);
1529     EXPECT_STREQ("core.rw", resourceInterfaceName);
1530
1531     EXPECT_EQ(OC_STACK_OK, OCStop());
1532 }
1533
1534
1535 #ifdef __cplusplus
1536 extern "C" {
1537 #endif // __cplusplus
1538     void parsePresencePayload(char* payload, uint32_t* seqNum,
1539             uint32_t* maxAge, OCPresenceTrigger* presenceTrigger, char** resType);
1540 #ifdef __cplusplus
1541 }
1542 #endif // __cplusplus
1543
1544 TEST(StackPresence, ParsePresencePayload)
1545 {
1546     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1547     OC_LOG(INFO, TAG, "Starting ParsePresencePayload test");
1548
1549     char payload[100];
1550     uint32_t seqNum = 0, maxAge = 0;
1551     OCPresenceTrigger presenceTrigger = OC_PRESENCE_TRIGGER_CHANGE;
1552     char * resType = NULL;
1553
1554     //Good Scenario
1555     strncpy(payload, "{\"oic\":[{\"ttl\":99,\"non\":100,\"trg\":"
1556             "\"delete\",\"rt\":\"presence\"}]}", sizeof(payload));
1557     parsePresencePayload(payload, &seqNum, &maxAge,
1558             &presenceTrigger, &resType);
1559     EXPECT_TRUE(100 == seqNum);
1560     EXPECT_TRUE(99 == maxAge);
1561     EXPECT_TRUE(OC_PRESENCE_TRIGGER_DELETE == presenceTrigger);
1562     EXPECT_TRUE(NULL != resType);
1563     EXPECT_STREQ("presence", resType);
1564     OICFree(resType);
1565
1566     presenceTrigger = OC_PRESENCE_TRIGGER_CHANGE;
1567
1568     //Bad Scenario -- should not result in Seg Fault
1569     parsePresencePayload(payload, NULL, &maxAge, &presenceTrigger, &resType);
1570
1571     //Bad Scenario
1572     seqNum = 0; maxAge = 0; resType = NULL;
1573     strncpy(payload, "{abracadabra}", sizeof(payload));
1574     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1575     EXPECT_TRUE(0 == seqNum);
1576     EXPECT_TRUE(0 == maxAge);
1577     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1578     EXPECT_TRUE(NULL == resType);
1579     EXPECT_EQ(NULL, resType);
1580     OICFree(resType);
1581
1582     //Bad Scenario
1583     seqNum = 0; maxAge = 0; resType = NULL;
1584     strncpy(payload, "{\"oic\":[100]}", sizeof(payload));
1585     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1586     EXPECT_TRUE(0 == seqNum);
1587     EXPECT_TRUE(0 == maxAge);
1588     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1589     EXPECT_TRUE(NULL == resType);
1590     EXPECT_EQ(NULL, resType);
1591     OICFree(resType);
1592
1593     //Bad Scenario
1594     seqNum = 0; maxAge = 0; resType = NULL;
1595     strncpy(payload, "{\"oic\":[]}", sizeof(payload));
1596     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1597     EXPECT_TRUE(0 == seqNum);
1598     EXPECT_TRUE(0 == maxAge);
1599     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1600     EXPECT_TRUE(NULL == resType);
1601     EXPECT_EQ(NULL, resType);
1602     OICFree(resType);
1603
1604     //Bad Scenario
1605     strncpy(payload, "{:]}", sizeof(payload));
1606     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1607     EXPECT_TRUE(0 == seqNum);
1608     EXPECT_TRUE(0 == maxAge);
1609     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1610     EXPECT_TRUE(NULL == resType);
1611     EXPECT_EQ(NULL, resType);
1612     OICFree(resType);
1613
1614     //Bad Scenario
1615     strncpy(payload, "{:[presence}", sizeof(payload));
1616     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1617     EXPECT_TRUE(0 == seqNum);
1618     EXPECT_TRUE(0 == maxAge);
1619     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1620     EXPECT_TRUE(NULL == resType);
1621     EXPECT_EQ(NULL, resType);
1622     OICFree(resType);
1623 }
1624
1625 TEST(PODTests, OCHeaderOption)
1626 {
1627     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1628 }
1629
1630 TEST(PODTests, OCCallbackData)
1631 {
1632     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1633 }