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