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                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 379
 380     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 381                                             "core.led",
 382                                             "core.rw",
 383                                             "", //"/a/led",
 384                                             0,
 385                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 386
 387     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 388                                             "core.led",
 389                                             "core.rw",
 390                                             uri65, //"/a/led",
 391                                             0,
 392                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 393
 394     EXPECT_EQ(OC_STACK_OK, OCStop());
 395 }
 396
 397 TEST(StackResource, CreateResourceSuccess)
 398 {
 399     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 400     OC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
 401     InitStack(OC_SERVER);
 402
 403     OCResourceHandle handle;
 404     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 405                                             "core.led",
 406                                             "core.rw",
 407                                             "/a/led",
 408                                             0,
 409                                             NULL,
 410                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 411     const char *url = OCGetResourceUri(handle);
 412     EXPECT_STREQ("/a/led", url);
 413
 414     EXPECT_EQ(OC_STACK_OK, OCStop());
 415 }
 416
 417 TEST(StackResource, CreateResourceFailDuplicateUri)
 418 {
 419     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 420     OC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
 421     InitStack(OC_SERVER);
 422
 423     OCResourceHandle handle;
 424     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 425                                             "core.led",
 426                                             "core.rw",
 427                                             "/a/led",
 428                                             0,
 429                                             NULL,
 430                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 431     const char *url = OCGetResourceUri(handle);
 432     EXPECT_STREQ("/a/led", url);
 433
 434     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 435                                             "core.led",
 436                                             "core.rw",
 437                                             "/a/led",
 438                                             0,
 439                                             NULL,
 440                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 441
 442     EXPECT_EQ(OC_STACK_OK, OCStop());
 443 }
 444
 445 TEST(StackResource, CreateResourceMultipleResources)
 446 {
 447     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 448     OC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
 449     InitStack(OC_SERVER);
 450
 451     OCResourceHandle handle1;
 452     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 453                                             "core.led",
 454                                             "core.rw",
 455                                             "/a/led1",
 456                                             0,
 457                                             NULL,
 458                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 459
 460     OCResourceHandle handle2;
 461     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 462                                             "core.led",
 463                                             "core.rw",
 464                                             "/a/led2",
 465                                             0,
 466                                             NULL,
 467                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 468     OCResourceHandle handle3;
 469     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 470                                             "core.led",
 471                                             "core.rw",
 472                                             "/a/led3",
 473                                             0,
 474                                             NULL,
 475                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 476
 477     const char *url = OCGetResourceUri(handle1);
 478     EXPECT_STREQ("/a/led1", url);
 479
 480     url = OCGetResourceUri(handle2);
 481     EXPECT_STREQ("/a/led2", url);
 482
 483     url = OCGetResourceUri(handle3);
 484     EXPECT_STREQ("/a/led3", url);
 485
 486     EXPECT_EQ(OC_STACK_OK, OCStop());
 487 }
 488
 489 TEST(StackResource, CreateResourceBadResoureType)
 490 {
 491     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 492     OC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
 493     InitStack(OC_SERVER);
 494
 495     OCResourceHandle handle;
 496     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 497                                             NULL, //"core.led",
 498                                             "core.rw",
 499                                             "/a/led",
 500                                             0,
 501                                             NULL,
 502                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 503
 504     EXPECT_EQ(OC_STACK_OK, OCStop());
 505 }
 506
 507 TEST(StackResource, CreateResourceGoodResourceType)
 508 {
 509     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 510     OC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
 511     InitStack(OC_SERVER);
 512
 513     OCResourceHandle handle;
 514     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 515                                             "core.led",
 516                                             "core.rw",
 517                                             "/a/led",
 518                                             0,
 519                                             NULL,
 520                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 521
 522     EXPECT_EQ(OC_STACK_OK, OCStop());
 523 }
 524
 525 TEST(StackResource, ResourceTypeName)
 526 {
 527     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 528     OC_LOG(INFO, TAG, "Starting ResourceTypeName test");
 529     InitStack(OC_SERVER);
 530
 531     OCResourceHandle handle;
 532     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 533                                             "core.led",
 534                                             "core.rw",
 535                                             "/a/led",
 536                                             0,
 537                                             NULL,
 538                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 539
 540     uint8_t numResourceTypes;
 541     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 542     EXPECT_EQ(1, numResourceTypes);
 543     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 544     EXPECT_STREQ("core.led", resourceTypeName);
 545
 546     // try getting resource type names with an invalid index
 547     resourceTypeName = OCGetResourceTypeName(handle, 1);
 548     EXPECT_STREQ(NULL, resourceTypeName);
 549     // try getting resource type names with an invalid index
 550     resourceTypeName = OCGetResourceTypeName(handle, 10);
 551     EXPECT_STREQ(NULL, resourceTypeName);
 552
 553     EXPECT_EQ(OC_STACK_OK, OCStop());
 554 }
 555
 556 TEST(StackResource, ResourceTypeAttrRepresentation)
 557 {
 558     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 559     OC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
 560     InitStack(OC_SERVER);
 561
 562     OCResourceHandle handle;
 563     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 564                                             "core.led",
 565                                             "core.rw",
 566                                             "/a/led",
 567                                             0,
 568                                             NULL,
 569                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 570
 571     uint8_t numResourceTypes;
 572     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 573     EXPECT_EQ(1, numResourceTypes);
 574
 575     EXPECT_EQ(OC_STACK_OK, OCStop());
 576 }
 577
 578 TEST(StackResource, ResourceTypeInterface)
 579 {
 580     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 581     OC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
 582     InitStack(OC_SERVER);
 583
 584     OCResourceHandle handle;
 585     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 586                                             "core.led",
 587                                             "core.rw",
 588                                             "/a/led",
 589                                             0,
 590                                             NULL,
 591                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 592
 593     uint8_t numResourceInterfaces;
 594     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 595     EXPECT_EQ(1, numResourceInterfaces);
 596     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 597     EXPECT_STREQ("core.rw", resourceInterfaceName);
 598
 599     // try getting resource interface names with an invalid index
 600     resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
 601     EXPECT_STREQ(NULL, resourceInterfaceName);
 602     // try getting resource interface names with an invalid index
 603     resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
 604     EXPECT_STREQ(NULL, resourceInterfaceName);
 605
 606     EXPECT_EQ(OC_STACK_OK, OCStop());
 607 }
 608
 609 TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
 610 {
 611     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 612
 613     OC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
 614
 615     InitStack(OC_SERVER);
 616
 617     OCResourceHandle handle;
 618     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 619                                             "core.led",
 620                                             "core.rw",
 621                                             "/a/led",
 622                                             0,
 623                                             NULL,
 624                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 625     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 626                                         OC_RSRVD_INTERFACE_DEFAULT));
 627     uint8_t numResourceInterfaces;
 628     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 629     EXPECT_EQ(2, numResourceInterfaces);
 630
 631     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
 632     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
 633
 634     const char*interfaceName_2 = OCGetResourceInterfaceName(handle, 1);
 635     EXPECT_STREQ("core.rw", interfaceName_2);
 636
 637     EXPECT_EQ(OC_STACK_OK, OCStop());
 638 }
 639
 640 TEST(StackResource, ResourceDuplicateDefaultInterfaces)
 641 {
 642     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 643
 644     OC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
 645
 646     InitStack(OC_SERVER);
 647
 648     OCResourceHandle handle;
 649     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 650                                             "core.led",
 651                                             "core.rw",
 652                                             "/a/led",
 653                                             0,
 654                                             NULL,
 655                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 656
 657     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 658                                         OC_RSRVD_INTERFACE_DEFAULT));
 659     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 660                                         OC_RSRVD_INTERFACE_DEFAULT));
 661
 662     uint8_t numResourceInterfaces;
 663     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 664     EXPECT_EQ(2, numResourceInterfaces);
 665
 666     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
 667     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
 668
 669     EXPECT_EQ(OC_STACK_OK, OCStop());
 670 }
 671
 672 TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
 673 {
 674     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 675
 676     OC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
 677
 678     InitStack(OC_SERVER);
 679
 680     OCResourceHandle handle;
 681     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 682                                             "core.led",
 683                                             "core.rw",
 684                                             "/a/led",
 685                                             0,
 686                                             NULL,
 687                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 688
 689     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 690                                         "core.rw"));
 691     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 692                                         "core.rw"));
 693
 694     uint8_t numResourceInterfaces;
 695     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 696     EXPECT_EQ(1, numResourceInterfaces);
 697
 698     EXPECT_EQ(OC_STACK_OK, OCStop());
 699 }
 700
 701 TEST(StackResource, ResourceTypeInterfaceMethods)
 702 {
 703     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 704     OC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
 705     InitStack(OC_SERVER);
 706
 707     OCResourceHandle handle;
 708     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 709                                             "core.led",
 710                                             "core.rw",
 711                                             "/a/led",
 712                                             0,
 713                                             NULL,
 714                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 715
 716     uint8_t numResourceInterfaces;
 717     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 718     EXPECT_EQ(1, numResourceInterfaces);
 719
 720     EXPECT_EQ(OC_STACK_OK, OCStop());
 721 }
 722
 723 TEST(StackResource, GetResourceProperties)
 724 {
 725     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 726     OC_LOG(INFO, TAG, "Starting GetResourceProperties test");
 727     InitStack(OC_SERVER);
 728
 729     OCResourceHandle handle;
 730     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 731                                             "core.led",
 732                                             "core.rw",
 733                                             "/a/led",
 734                                             0,
 735                                             NULL,
 736                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 737
 738     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
 739     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 740
 741     EXPECT_EQ(OC_STACK_OK, OCStop());
 742 }
 743
 744 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
 745 {
 746     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 747     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
 748     InitStack(OC_SERVER);
 749     uint8_t numResources = 0;
 750     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 751
 752     OCResourceHandle handle;
 753     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 754                                             "core.led",
 755                                             "core.rw",
 756                                             "/a1/led",
 757                                             0,
 758                                             NULL,
 759                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 760     const char *url = OCGetResourceUri(handle);
 761     EXPECT_STREQ("/a1/led", url);
 762
 763     //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
 764     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 765     uint8_t numExpectedResources = 0;
 766
 767     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
 768     EXPECT_EQ(numExpectedResources, numResources);
 769
 770     EXPECT_EQ(OC_STACK_OK, OCStop());
 771 }
 772
 773 TEST(StackResource, StackTestResourceDiscoverOneResource)
 774 {
 775     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 776     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
 777     InitStack(OC_SERVER);
 778
 779     OCResourceHandle handle;
 780     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 781                                             "core.led",
 782                                             "core.rw",
 783                                             "/a/led",
 784                                             0,
 785                                             NULL,
 786                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 787     const char *url = OCGetResourceUri(handle);
 788     EXPECT_STREQ("/a/led", url);
 789
 790     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 791     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 792
 793     EXPECT_EQ(OC_STACK_OK, OCStop());
 794 }
 795
 796 TEST(StackResource, StackTestResourceDiscoverManyResources)
 797 {
 798     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 799     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
 800     InitStack(OC_SERVER);
 801
 802     OCResourceHandle handle1;
 803     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 804                                             "core.led",
 805                                             "core.rw",
 806                                             "/a/led1",
 807                                             0,
 808                                             NULL,
 809                                             OC_DISCOVERABLE));
 810     const char *url = OCGetResourceUri(handle1);
 811     EXPECT_STREQ("/a/led1", url);
 812
 813     OCResourceHandle handle2;
 814     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 815                                             "core.led",
 816                                             "core.rw",
 817                                             "/a/led2",
 818                                             0,
 819                                             NULL,
 820                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 821     url = OCGetResourceUri(handle2);
 822     EXPECT_STREQ("/a/led2", url);
 823
 824     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
 825     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
 826
 827     OCResourceHandle handle3;
 828     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 829                                             "core.led",
 830                                             "core.rw",
 831                                             "/a/led3",
 832                                             0,
 833                                             NULL,
 834                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 835     url = OCGetResourceUri(handle3);
 836     EXPECT_STREQ("/a/led3", url);
 837
 838     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
 839     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
 840
 841     OCResourceHandle handle4;
 842     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
 843                                             "core.led",
 844                                             "core.rw",
 845                                             "/a/led4",
 846                                             0,
 847                                             NULL,
 848                                             OC_DISCOVERABLE));
 849     url = OCGetResourceUri(handle4);
 850     EXPECT_STREQ("/a/led4", url);
 851
 852     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
 853     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
 854     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
 855
 856     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 857
 858     EXPECT_EQ(OC_STACK_OK, OCStop());
 859 }
 860
 861 TEST(StackBind, BindResourceTypeNameBad)
 862 {
 863     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 864     OC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
 865     InitStack(OC_SERVER);
 866
 867     OCResourceHandle handle;
 868     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 869                                             "core.led",
 870                                             "core.rw",
 871                                             "/a/led",
 872                                             0,
 873                                             NULL,
 874                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 875
 876     uint8_t numResourceTypes;
 877     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 878     EXPECT_EQ(1, numResourceTypes);
 879     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 880     EXPECT_STREQ("core.led", resourceTypeName);
 881
 882     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
 883
 884     EXPECT_EQ(OC_STACK_OK, OCStop());
 885 }
 886
 887 TEST(StackBind, BindResourceTypeNameGood)
 888 {
 889     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 890     OC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
 891     InitStack(OC_SERVER);
 892
 893     OCResourceHandle handle;
 894     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 895                                             "core.led",
 896                                             "core.rw",
 897                                             "/a/led",
 898                                             0,
 899                                             NULL,
 900                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 901
 902     uint8_t numResourceTypes;
 903     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 904     EXPECT_EQ(1, numResourceTypes);
 905     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 906     EXPECT_STREQ("core.led", resourceTypeName);
 907
 908     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
 909     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 910     EXPECT_EQ(2, numResourceTypes);
 911     resourceTypeName = OCGetResourceTypeName(handle, 1);
 912     EXPECT_STREQ("core.brightled", resourceTypeName);
 913
 914     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
 915     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 916     EXPECT_EQ(3, numResourceTypes);
 917     resourceTypeName = OCGetResourceTypeName(handle, 2);
 918     EXPECT_STREQ("core.reallybrightled", resourceTypeName);
 919
 920     EXPECT_EQ(OC_STACK_OK, OCStop());
 921 }
 922
 923 TEST(StackBind, BindResourceTypeAttribRepGood)
 924 {
 925     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 926     OC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
 927     InitStack(OC_SERVER);
 928
 929     OCResourceHandle handle;
 930     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 931                                             "core.led",
 932                                             "core.rw",
 933                                             "/a/led",
 934                                             0,
 935                                             NULL,
 936                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 937
 938     uint8_t numResourceTypes;
 939     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 940     EXPECT_EQ(1, numResourceTypes);
 941
 942     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
 943     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 944     EXPECT_EQ(2, numResourceTypes);
 945
 946     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
 947     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 948     EXPECT_EQ(3, numResourceTypes);
 949
 950     EXPECT_EQ(OC_STACK_OK, OCStop());
 951 }
 952
 953
 954 TEST(StackBind, BindResourceInterfaceNameBad)
 955 {
 956     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 957     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
 958     InitStack(OC_SERVER);
 959
 960     OCResourceHandle handle;
 961     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 962                                             "core.led",
 963                                             "core.rw",
 964                                             "/a/led",
 965                                             0,
 966                                             NULL,
 967                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 968
 969     uint8_t numResourceInterfaces;
 970     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 971     EXPECT_EQ(1, numResourceInterfaces);
 972     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 973     EXPECT_STREQ("core.rw", resourceInterfaceName);
 974
 975     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
 976
 977     EXPECT_EQ(OC_STACK_OK, OCStop());
 978 }
 979
 980 TEST(StackBind, BindResourceInterfaceNameGood)
 981 {
 982     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 983     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
 984     InitStack(OC_SERVER);
 985
 986     OCResourceHandle handle;
 987     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 988                                             "core.led",
 989                                             "core.rw",
 990                                             "/a/led",
 991                                             0,
 992                                             NULL,
 993                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 994
 995     uint8_t numResourceInterfaces;
 996     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 997     EXPECT_EQ(1, numResourceInterfaces);
 998     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 999     EXPECT_STREQ("core.rw", resourceInterfaceName);
1000
1001     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1002
1003     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1004     EXPECT_EQ(2, numResourceInterfaces);
1005     resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1006     EXPECT_STREQ("core.r", resourceInterfaceName);
1007
1008     EXPECT_EQ(OC_STACK_OK, OCStop());
1009 }
1010
1011 TEST(StackBind, BindResourceInterfaceMethodsBad)
1012 {
1013     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1014     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
1015     InitStack(OC_SERVER);
1016
1017     OCResourceHandle handle;
1018     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1019                                             "core.led",
1020                                             "core.rw",
1021                                             "/a/led",
1022                                             0,
1023                                             NULL,
1024                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1025
1026     uint8_t numResourceInterfaces;
1027     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1028     EXPECT_EQ(1, numResourceInterfaces);
1029
1030     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
1031
1032     EXPECT_EQ(OC_STACK_OK, OCStop());
1033 }
1034
1035 TEST(StackBind, BindResourceInterfaceMethodsGood)
1036 {
1037     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1038     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
1039     InitStack(OC_SERVER);
1040
1041     OCResourceHandle handle;
1042     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1043                                             "core.led",
1044                                             "core.rw",
1045                                             "/a/led",
1046                                             0,
1047                                             NULL,
1048                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1049
1050     uint8_t numResourceInterfaces;
1051     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1052     EXPECT_EQ(1, numResourceInterfaces);
1053
1054     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1055
1056     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1057     EXPECT_EQ(2, numResourceInterfaces);
1058
1059     EXPECT_EQ(OC_STACK_OK, OCStop());
1060 }
1061
1062 TEST(StackBind, BindContainedResourceBad)
1063 {
1064     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1065     OC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
1066     InitStack(OC_SERVER);
1067
1068     OCResourceHandle containerHandle;
1069     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1070                                             "core.led",
1071                                             "core.rw",
1072                                             "/a/kitchen",
1073                                             0,
1074                                             NULL,
1075                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1076
1077     OCResourceHandle handle0;
1078     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1079                                             "core.led",
1080                                             "core.rw",
1081                                             "/a/led",
1082                                             0,
1083                                             NULL,
1084                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1085
1086     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1087
1088     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1089
1090     EXPECT_EQ(OC_STACK_OK, OCStop());
1091 }
1092
1093 TEST(StackBind, BindContainedResourceGood)
1094 {
1095     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1096     OC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1097     InitStack(OC_SERVER);
1098
1099     uint8_t numResources = 0;
1100     uint8_t numExpectedResources = 0;
1101
1102     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1103
1104     OCResourceHandle containerHandle;
1105     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1106                                             "core.led",
1107                                             "core.rw",
1108                                             "/a/kitchen",
1109                                             0,
1110                                             NULL,
1111                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1112     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1113     EXPECT_EQ(++numExpectedResources, numResources);
1114
1115     OCResourceHandle handle0;
1116     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1117                                             "core.led",
1118                                             "core.rw",
1119                                             "/a/led0",
1120                                             0,
1121                                             NULL,
1122                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1123     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1124     EXPECT_EQ(++numExpectedResources, numResources);
1125
1126     OCResourceHandle handle1;
1127     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1128                                             "core.led",
1129                                             "core.rw",
1130                                             "/a/led1",
1131                                             0,
1132                                             NULL,
1133                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1134     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1135     EXPECT_EQ(++numExpectedResources, numResources);
1136
1137     OCResourceHandle handle2;
1138     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1139                                             "core.led",
1140                                             "core.rw",
1141                                             "/a/led2",
1142                                             0,
1143                                             NULL,
1144                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1145     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1146     EXPECT_EQ(++numExpectedResources, numResources);
1147
1148     OCResourceHandle handle3;
1149     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1150                                             "core.led",
1151                                             "core.rw",
1152                                             "/a/led3",
1153                                             0,
1154                                             NULL,
1155                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1156     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1157     EXPECT_EQ(++numExpectedResources, numResources);
1158
1159     OCResourceHandle handle4;
1160     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1161                                             "core.led",
1162                                             "core.rw",
1163                                             "/a/led4",
1164                                             0,
1165                                             NULL,
1166                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1167     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1168     EXPECT_EQ(++numExpectedResources, numResources);
1169
1170     OCResourceHandle handle5;
1171     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1172                                             "core.led",
1173                                             "core.rw",
1174                                             "/a/led5",
1175                                             0,
1176                                             NULL,
1177                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1178     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1179     EXPECT_EQ(++numExpectedResources, numResources);
1180
1181
1182     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1183     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1184     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1185     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1186     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1187     EXPECT_EQ(OC_STACK_ERROR, OCBindResource(containerHandle, handle5));
1188
1189     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1190     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1191     EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1192     EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1193     EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1194
1195     EXPECT_EQ(NULL, OCGetResourceHandleFromCollection(containerHandle, 5));
1196
1197     EXPECT_EQ(OC_STACK_OK, OCStop());
1198 }
1199
1200
1201 TEST(StackBind, BindEntityHandlerBad)
1202 {
1203     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1204     OC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1205     InitStack(OC_SERVER);
1206
1207     OCResourceHandle handle;
1208     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1209                                             "core.led",
1210                                             "core.rw",
1211                                             "/a/led",
1212                                             0,
1213                                             NULL,
1214                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1215
1216     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
1217
1218     EXPECT_EQ(OC_STACK_OK, OCStop());
1219 }
1220
1221 TEST(StackBind, BindEntityHandlerGood)
1222 {
1223     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1224     OC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1225     InitStack(OC_SERVER);
1226
1227     OCResourceHandle handle;
1228     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1229                                             "core.led",
1230                                             "core.rw",
1231                                             "/a/led",
1232                                             0,
1233                                             NULL,
1234                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1235
1236     OCEntityHandler myHandler = entityHandler;
1237
1238     EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
1239
1240     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1241
1242     EXPECT_EQ(OC_STACK_OK, OCStop());
1243 }
1244
1245 TEST(StackResourceAccess, GetResourceByIndex)
1246 {
1247     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1248     OC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1249     InitStack(OC_SERVER);
1250
1251     uint8_t numResources = 0;
1252     uint8_t numExpectedResources = 0;
1253     uint8_t resourceIndex = 0;
1254     uint8_t prevResources = 0;
1255     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1256     prevResources = numExpectedResources;
1257     OCResourceHandle containerHandle;
1258     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1259                                             "core.led",
1260                                             "core.rw",
1261                                             "/a/kitchen",
1262                                             0,
1263                                             NULL,
1264                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1265     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1266     EXPECT_EQ(++numExpectedResources, numResources);
1267
1268     OCResourceHandle handle0;
1269     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1270                                             "core.led",
1271                                             "core.rw",
1272                                             "/a/led0",
1273                                             0,
1274                                             NULL,
1275                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1276     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1277     EXPECT_EQ(++numExpectedResources, numResources);
1278
1279     OCResourceHandle handle1;
1280     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1281                                             "core.led",
1282                                             "core.rw",
1283                                             "/a/led1",
1284                                             0,
1285                                             NULL,
1286                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1287     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1288     EXPECT_EQ(++numExpectedResources, numResources);
1289
1290     OCResourceHandle handle2;
1291     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1292                                             "core.led",
1293                                             "core.rw",
1294                                             "/a/led2",
1295                                             0,
1296                                             NULL,
1297                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1298     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1299     EXPECT_EQ(++numExpectedResources, numResources);
1300
1301     OCResourceHandle handle3;
1302     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1303                                             "core.led",
1304                                             "core.rw",
1305                                             "/a/led3",
1306                                             0,
1307                                             NULL,
1308                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1309     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1310     EXPECT_EQ(++numExpectedResources, numResources);
1311
1312     OCResourceHandle handle4;
1313     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1314                                             "core.led",
1315                                             "core.rw",
1316                                             "/a/led4",
1317                                             0,
1318                                             NULL,
1319                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1320     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1321     EXPECT_EQ(++numExpectedResources, numResources);
1322
1323     OCResourceHandle handle5;
1324     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1325                                             "core.led",
1326                                             "core.rw",
1327                                             "/a/led5",
1328                                             0,
1329                                             NULL,
1330                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1331     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1332     EXPECT_EQ(++numExpectedResources, numResources);
1333     resourceIndex += prevResources;
1334     EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1335     EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1336     EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1337     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1338     EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1339     EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1340     EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1341
1342     EXPECT_EQ(OC_STACK_OK, OCStop());
1343 }
1344
1345 TEST(StackResourceAccess, DeleteHeadResource)
1346 {
1347     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1348     OC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1349     InitStack(OC_SERVER);
1350
1351     uint8_t numResources = 0;
1352     uint8_t numExpectedResources = 0;
1353
1354     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1355
1356     OCResourceHandle handle0;
1357     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1358                                             "core.led",
1359                                             "core.rw",
1360                                             "/a/led0",
1361                                             0,
1362                                             NULL,
1363                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1364     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1365     EXPECT_EQ(++numExpectedResources, numResources);
1366
1367     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1368     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1369     EXPECT_EQ(--numExpectedResources, numResources);
1370
1371     EXPECT_EQ(OC_STACK_OK, OCStop());
1372 }
1373
1374 TEST(StackResourceAccess, DeleteHeadResource2)
1375 {
1376     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1377     OC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1378     InitStack(OC_SERVER);
1379
1380     uint8_t numResources = 0;
1381     uint8_t numExpectedResources = 0;
1382
1383     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1384     OCResourceHandle handle0;
1385     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1386                                             "core.led",
1387                                             "core.rw",
1388                                             "/a/led0",
1389                                             0,
1390                                             NULL,
1391                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1392     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1393     EXPECT_EQ(++numExpectedResources, numResources);
1394
1395     OCResourceHandle handle1;
1396     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1397                                             "core.led",
1398                                             "core.rw",
1399                                             "/a/led1",
1400                                             0,
1401                                             NULL,
1402                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1403     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1404     EXPECT_EQ(++numExpectedResources, numResources);
1405
1406     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1407     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1408     EXPECT_EQ(--numExpectedResources, numResources);
1409
1410     EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
1411
1412     EXPECT_EQ(OC_STACK_OK, OCStop());
1413 }
1414
1415
1416 TEST(StackResourceAccess, DeleteLastResource)
1417 {
1418     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1419     OC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1420     InitStack(OC_SERVER);
1421
1422     uint8_t numResources = 0;
1423     uint8_t numExpectedResources = 0;
1424
1425     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1426
1427     OCResourceHandle handle0;
1428     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1429                                             "core.led",
1430                                             "core.rw",
1431                                             "/a/led0",
1432                                             0,
1433                                             NULL,
1434                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1435     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1436     EXPECT_EQ(++numExpectedResources, numResources);
1437
1438     OCResourceHandle handle1;
1439     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1440                                             "core.led",
1441                                             "core.rw",
1442                                             "/a/led1",
1443                                             0,
1444                                             NULL,
1445                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1446     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1447     EXPECT_EQ(++numExpectedResources, numResources);
1448
1449     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1450     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1451     EXPECT_EQ(--numExpectedResources, numResources);
1452
1453     EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
1454
1455     OCResourceHandle handle2;
1456     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1457                                             "core.led",
1458                                             "core.rw",
1459                                             "/a/led2",
1460                                             0,
1461                                             NULL,
1462                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1463     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1464     EXPECT_EQ(++numExpectedResources, numResources);
1465
1466     EXPECT_EQ(OC_STACK_OK, OCStop());
1467 }
1468
1469 TEST(StackResourceAccess, DeleteMiddleResource)
1470 {
1471     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1472     OC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1473     InitStack(OC_SERVER);
1474
1475     uint8_t numResources = 0;
1476     uint8_t numExpectedResources = 0;
1477     uint8_t resourceIndex = InitResourceIndex();
1478
1479     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1480     resourceIndex = numExpectedResources;
1481     OCResourceHandle handle0;
1482     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1483                                             "core.led",
1484                                             "core.rw",
1485                                             "/a/led0",
1486                                             0,
1487                                             NULL,
1488                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1489     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1490     EXPECT_EQ(++numExpectedResources, numResources);
1491
1492     OCResourceHandle handle1;
1493     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1494                                             "core.led",
1495                                             "core.rw",
1496                                             "/a/led1",
1497                                             0,
1498                                             NULL,
1499                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1500     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1501     EXPECT_EQ(++numExpectedResources, numResources);
1502
1503     OCResourceHandle handle2;
1504     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1505                                             "core.led",
1506                                             "core.rw",
1507                                             "/a/led2",
1508                                             0,
1509                                             NULL,
1510                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1511     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1512     EXPECT_EQ(++numExpectedResources, numResources);
1513
1514     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1515     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1516     EXPECT_EQ(--numExpectedResources, numResources);
1517
1518     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1519     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1520
1521     // Make sure the resource elements are still correct
1522     uint8_t numResourceInterfaces;
1523     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1524     EXPECT_EQ(1, numResourceInterfaces);
1525     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0);
1526     EXPECT_STREQ("core.rw", resourceInterfaceName);
1527
1528     EXPECT_EQ(OC_STACK_OK, OCStop());
1529 }
1530
1531
1532 #ifdef __cplusplus
1533 extern "C" {
1534 #endif // __cplusplus
1535     void parsePresencePayload(char* payload, uint32_t* seqNum,
1536             uint32_t* maxAge, OCPresenceTrigger* presenceTrigger, char** resType);
1537 #ifdef __cplusplus
1538 }
1539 #endif // __cplusplus
1540
1541 TEST(StackPresence, ParsePresencePayload)
1542 {
1543     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1544     OC_LOG(INFO, TAG, "Starting ParsePresencePayload test");
1545
1546     char payload[100];
1547     uint32_t seqNum = 0, maxAge = 0;
1548     OCPresenceTrigger presenceTrigger = OC_PRESENCE_TRIGGER_CHANGE;
1549     char * resType = NULL;
1550
1551     //Good Scenario
1552     strncpy(payload, "{\"oic\":[{\"ttl\":99,\"non\":100,\"trg\":"
1553             "\"delete\",\"rt\":\"presence\"}]}", sizeof(payload));
1554     parsePresencePayload(payload, &seqNum, &maxAge,
1555             &presenceTrigger, &resType);
1556     EXPECT_TRUE(100 == seqNum);
1557     EXPECT_TRUE(99 == maxAge);
1558     EXPECT_TRUE(OC_PRESENCE_TRIGGER_DELETE == presenceTrigger);
1559     EXPECT_TRUE(NULL != resType);
1560     EXPECT_STREQ("presence", resType);
1561     OICFree(resType);
1562
1563     presenceTrigger = OC_PRESENCE_TRIGGER_CHANGE;
1564
1565     //Bad Scenario -- should not result in Seg Fault
1566     parsePresencePayload(payload, NULL, &maxAge, &presenceTrigger, &resType);
1567
1568     //Bad Scenario
1569     seqNum = 0; maxAge = 0; resType = NULL;
1570     strncpy(payload, "{abracadabra}", sizeof(payload));
1571     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1572     EXPECT_TRUE(0 == seqNum);
1573     EXPECT_TRUE(0 == maxAge);
1574     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1575     EXPECT_TRUE(NULL == resType);
1576     EXPECT_EQ(NULL, resType);
1577     OICFree(resType);
1578
1579     //Bad Scenario
1580     seqNum = 0; maxAge = 0; resType = NULL;
1581     strncpy(payload, "{\"oic\":[100]}", sizeof(payload));
1582     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1583     EXPECT_TRUE(0 == seqNum);
1584     EXPECT_TRUE(0 == maxAge);
1585     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1586     EXPECT_TRUE(NULL == resType);
1587     EXPECT_EQ(NULL, resType);
1588     OICFree(resType);
1589
1590     //Bad Scenario
1591     seqNum = 0; maxAge = 0; resType = NULL;
1592     strncpy(payload, "{\"oic\":[]}", sizeof(payload));
1593     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1594     EXPECT_TRUE(0 == seqNum);
1595     EXPECT_TRUE(0 == maxAge);
1596     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1597     EXPECT_TRUE(NULL == resType);
1598     EXPECT_EQ(NULL, resType);
1599     OICFree(resType);
1600
1601     //Bad Scenario
1602     strncpy(payload, "{:]}", sizeof(payload));
1603     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1604     EXPECT_TRUE(0 == seqNum);
1605     EXPECT_TRUE(0 == maxAge);
1606     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1607     EXPECT_TRUE(NULL == resType);
1608     EXPECT_EQ(NULL, resType);
1609     OICFree(resType);
1610
1611     //Bad Scenario
1612     strncpy(payload, "{:[presence}", sizeof(payload));
1613     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1614     EXPECT_TRUE(0 == seqNum);
1615     EXPECT_TRUE(0 == maxAge);
1616     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1617     EXPECT_TRUE(NULL == resType);
1618     EXPECT_EQ(NULL, resType);
1619     OICFree(resType);
1620 }
1621
1622 TEST(PODTests, OCHeaderOption)
1623 {
1624     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1625 }
1626
1627 TEST(PODTests, OCCallbackData)
1628 {
1629     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1630 }