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