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     uint8_t numResources = 0;
 717     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 718
 719     OCResourceHandle handle;
 720     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 721                                             "core.led",
 722                                             "core.rw",
 723                                             "/a1/led",
 724                                             0,
 725                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 726     const char *url = OCGetResourceUri(handle);
 727     EXPECT_STREQ("/a1/led", url);
 728
 729     //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
 730     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 731     uint8_t numExpectedResources = 0;
 732
 733     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
 734     EXPECT_EQ(numExpectedResources, numResources);
 735
 736     EXPECT_EQ(OC_STACK_OK, OCStop());
 737 }
 738
 739 TEST(StackResource, StackTestResourceDiscoverOneResource)
 740 {
 741     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 742     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
 743     InitStack(OC_SERVER);
 744
 745     OCResourceHandle handle;
 746     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 747                                             "core.led",
 748                                             "core.rw",
 749                                             "/a/led",
 750                                             0,
 751                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 752     const char *url = OCGetResourceUri(handle);
 753     EXPECT_STREQ("/a/led", url);
 754
 755     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 756     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 757
 758     EXPECT_EQ(OC_STACK_OK, OCStop());
 759 }
 760
 761 TEST(StackResource, StackTestResourceDiscoverManyResources)
 762 {
 763     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 764     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
 765     InitStack(OC_SERVER);
 766
 767     OCResourceHandle handle1;
 768     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 769                                             "core.led",
 770                                             "core.rw",
 771                                             "/a/led1",
 772                                             0,
 773                                             OC_DISCOVERABLE));
 774     const char *url = OCGetResourceUri(handle1);
 775     EXPECT_STREQ("/a/led1", url);
 776
 777     OCResourceHandle handle2;
 778     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 779                                             "core.led",
 780                                             "core.rw",
 781                                             "/a/led2",
 782                                             0,
 783                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 784     url = OCGetResourceUri(handle2);
 785     EXPECT_STREQ("/a/led2", url);
 786
 787     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
 788     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
 789
 790     OCResourceHandle handle3;
 791     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 792                                             "core.led",
 793                                             "core.rw",
 794                                             "/a/led3",
 795                                             0,
 796                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 797     url = OCGetResourceUri(handle3);
 798     EXPECT_STREQ("/a/led3", url);
 799
 800     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
 801     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
 802
 803     OCResourceHandle handle4;
 804     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
 805                                             "core.led",
 806                                             "core.rw",
 807                                             "/a/led4",
 808                                             0,
 809                                             OC_DISCOVERABLE));
 810     url = OCGetResourceUri(handle4);
 811     EXPECT_STREQ("/a/led4", url);
 812
 813     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
 814     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
 815     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
 816
 817     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 818
 819     EXPECT_EQ(OC_STACK_OK, OCStop());
 820 }
 821
 822 TEST(StackBind, BindResourceTypeNameBad)
 823 {
 824     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 825     OC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
 826     InitStack(OC_SERVER);
 827
 828     OCResourceHandle handle;
 829     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 830                                             "core.led",
 831                                             "core.rw",
 832                                             "/a/led",
 833                                             0,
 834                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 835
 836     uint8_t numResourceTypes;
 837     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 838     EXPECT_EQ(1, numResourceTypes);
 839     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 840     EXPECT_STREQ("core.led", resourceTypeName);
 841
 842     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
 843
 844     EXPECT_EQ(OC_STACK_OK, OCStop());
 845 }
 846
 847 TEST(StackBind, BindResourceTypeNameGood)
 848 {
 849     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 850     OC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
 851     InitStack(OC_SERVER);
 852
 853     OCResourceHandle handle;
 854     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 855                                             "core.led",
 856                                             "core.rw",
 857                                             "/a/led",
 858                                             0,
 859                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 860
 861     uint8_t numResourceTypes;
 862     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 863     EXPECT_EQ(1, numResourceTypes);
 864     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 865     EXPECT_STREQ("core.led", resourceTypeName);
 866
 867     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
 868     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 869     EXPECT_EQ(2, numResourceTypes);
 870     resourceTypeName = OCGetResourceTypeName(handle, 1);
 871     EXPECT_STREQ("core.brightled", resourceTypeName);
 872
 873     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
 874     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 875     EXPECT_EQ(3, numResourceTypes);
 876     resourceTypeName = OCGetResourceTypeName(handle, 2);
 877     EXPECT_STREQ("core.reallybrightled", resourceTypeName);
 878
 879     EXPECT_EQ(OC_STACK_OK, OCStop());
 880 }
 881
 882 TEST(StackBind, BindResourceTypeAttribRepGood)
 883 {
 884     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 885     OC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
 886     InitStack(OC_SERVER);
 887
 888     OCResourceHandle handle;
 889     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 890                                             "core.led",
 891                                             "core.rw",
 892                                             "/a/led",
 893                                             0,
 894                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 895
 896     uint8_t numResourceTypes;
 897     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 898     EXPECT_EQ(1, numResourceTypes);
 899
 900     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
 901     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 902     EXPECT_EQ(2, numResourceTypes);
 903
 904     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
 905     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 906     EXPECT_EQ(3, numResourceTypes);
 907
 908     EXPECT_EQ(OC_STACK_OK, OCStop());
 909 }
 910
 911
 912 TEST(StackBind, BindResourceInterfaceNameBad)
 913 {
 914     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 915     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
 916     InitStack(OC_SERVER);
 917
 918     OCResourceHandle handle;
 919     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 920                                             "core.led",
 921                                             "core.rw",
 922                                             "/a/led",
 923                                             0,
 924                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 925
 926     uint8_t numResourceInterfaces;
 927     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 928     EXPECT_EQ(1, numResourceInterfaces);
 929     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 930     EXPECT_STREQ("core.rw", resourceInterfaceName);
 931
 932     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
 933
 934     EXPECT_EQ(OC_STACK_OK, OCStop());
 935 }
 936
 937 TEST(StackBind, BindResourceInterfaceNameGood)
 938 {
 939     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 940     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
 941     InitStack(OC_SERVER);
 942
 943     OCResourceHandle handle;
 944     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 945                                             "core.led",
 946                                             "core.rw",
 947                                             "/a/led",
 948                                             0,
 949                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 950
 951     uint8_t numResourceInterfaces;
 952     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 953     EXPECT_EQ(1, numResourceInterfaces);
 954     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 955     EXPECT_STREQ("core.rw", resourceInterfaceName);
 956
 957     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
 958
 959     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 960     EXPECT_EQ(2, numResourceInterfaces);
 961     resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
 962     EXPECT_STREQ("core.r", resourceInterfaceName);
 963
 964     EXPECT_EQ(OC_STACK_OK, OCStop());
 965 }
 966
 967 TEST(StackBind, BindResourceInterfaceMethodsBad)
 968 {
 969     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 970     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
 971     InitStack(OC_SERVER);
 972
 973     OCResourceHandle handle;
 974     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 975                                             "core.led",
 976                                             "core.rw",
 977                                             "/a/led",
 978                                             0,
 979                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 980
 981     uint8_t numResourceInterfaces;
 982     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 983     EXPECT_EQ(1, numResourceInterfaces);
 984
 985     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
 986
 987     EXPECT_EQ(OC_STACK_OK, OCStop());
 988 }
 989
 990 TEST(StackBind, BindResourceInterfaceMethodsGood)
 991 {
 992     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 993     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
 994     InitStack(OC_SERVER);
 995
 996     OCResourceHandle handle;
 997     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 998                                             "core.led",
 999                                             "core.rw",
1000                                             "/a/led",
1001                                             0,
1002                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1003
1004     uint8_t numResourceInterfaces;
1005     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1006     EXPECT_EQ(1, numResourceInterfaces);
1007
1008     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1009
1010     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1011     EXPECT_EQ(2, numResourceInterfaces);
1012
1013     EXPECT_EQ(OC_STACK_OK, OCStop());
1014 }
1015
1016 TEST(StackBind, BindContainedResourceBad)
1017 {
1018     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1019     OC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
1020     InitStack(OC_SERVER);
1021
1022     OCResourceHandle containerHandle;
1023     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1024                                             "core.led",
1025                                             "core.rw",
1026                                             "/a/kitchen",
1027                                             0,
1028                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1029
1030     OCResourceHandle handle0;
1031     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1032                                             "core.led",
1033                                             "core.rw",
1034                                             "/a/led",
1035                                             0,
1036                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1037
1038     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1039
1040     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1041
1042     EXPECT_EQ(OC_STACK_OK, OCStop());
1043 }
1044
1045 TEST(StackBind, BindContainedResourceGood)
1046 {
1047     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1048     OC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1049     InitStack(OC_SERVER);
1050
1051     uint8_t numResources = 0;
1052     uint8_t numExpectedResources = 0;
1053
1054     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
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 = 0;
1196     uint8_t resourceIndex = 0;
1197     uint8_t prevResources = 0;
1198     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1199     prevResources = numExpectedResources;
1200     OCResourceHandle containerHandle;
1201     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1202                                             "core.led",
1203                                             "core.rw",
1204                                             "/a/kitchen",
1205                                             0,
1206                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1207     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1208     EXPECT_EQ(++numExpectedResources, numResources);
1209
1210     OCResourceHandle handle0;
1211     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1212                                             "core.led",
1213                                             "core.rw",
1214                                             "/a/led0",
1215                                             0,
1216                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1217     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1218     EXPECT_EQ(++numExpectedResources, numResources);
1219
1220     OCResourceHandle handle1;
1221     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1222                                             "core.led",
1223                                             "core.rw",
1224                                             "/a/led1",
1225                                             0,
1226                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1227     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1228     EXPECT_EQ(++numExpectedResources, numResources);
1229
1230     OCResourceHandle handle2;
1231     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1232                                             "core.led",
1233                                             "core.rw",
1234                                             "/a/led2",
1235                                             0,
1236                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1237     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1238     EXPECT_EQ(++numExpectedResources, numResources);
1239
1240     OCResourceHandle handle3;
1241     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1242                                             "core.led",
1243                                             "core.rw",
1244                                             "/a/led3",
1245                                             0,
1246                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1247     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1248     EXPECT_EQ(++numExpectedResources, numResources);
1249
1250     OCResourceHandle handle4;
1251     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1252                                             "core.led",
1253                                             "core.rw",
1254                                             "/a/led4",
1255                                             0,
1256                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1257     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1258     EXPECT_EQ(++numExpectedResources, numResources);
1259
1260     OCResourceHandle handle5;
1261     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1262                                             "core.led",
1263                                             "core.rw",
1264                                             "/a/led5",
1265                                             0,
1266                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1267     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1268     EXPECT_EQ(++numExpectedResources, numResources);
1269     resourceIndex += prevResources;
1270     EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1271     EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1272     EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1273     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1274     EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1275     EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1276     EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1277
1278     EXPECT_EQ(OC_STACK_OK, OCStop());
1279 }
1280
1281 TEST(StackResourceAccess, DeleteHeadResource)
1282 {
1283     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1284     OC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1285     InitStack(OC_SERVER);
1286
1287     uint8_t numResources = 0;
1288     uint8_t numExpectedResources = 0;
1289
1290     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1291
1292     OCResourceHandle handle0;
1293     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1294                                             "core.led",
1295                                             "core.rw",
1296                                             "/a/led0",
1297                                             0,
1298                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1299     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1300     EXPECT_EQ(++numExpectedResources, numResources);
1301
1302     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1303     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1304     EXPECT_EQ(--numExpectedResources, numResources);
1305
1306     EXPECT_EQ(OC_STACK_OK, OCStop());
1307 }
1308
1309 TEST(StackResourceAccess, DeleteHeadResource2)
1310 {
1311     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1312     OC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1313     InitStack(OC_SERVER);
1314
1315     uint8_t numResources = 0;
1316     uint8_t numExpectedResources = 0;
1317
1318     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1319     OCResourceHandle handle0;
1320     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1321                                             "core.led",
1322                                             "core.rw",
1323                                             "/a/led0",
1324                                             0,
1325                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1326     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1327     EXPECT_EQ(++numExpectedResources, numResources);
1328
1329     OCResourceHandle handle1;
1330     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1331                                             "core.led",
1332                                             "core.rw",
1333                                             "/a/led1",
1334                                             0,
1335                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1336     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1337     EXPECT_EQ(++numExpectedResources, numResources);
1338
1339     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1340     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1341     EXPECT_EQ(--numExpectedResources, numResources);
1342
1343     EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
1344
1345     EXPECT_EQ(OC_STACK_OK, OCStop());
1346 }
1347
1348
1349 TEST(StackResourceAccess, DeleteLastResource)
1350 {
1351     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1352     OC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1353     InitStack(OC_SERVER);
1354
1355     uint8_t numResources = 0;
1356     uint8_t numExpectedResources = 0;
1357
1358     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1359
1360     OCResourceHandle handle0;
1361     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1362                                             "core.led",
1363                                             "core.rw",
1364                                             "/a/led0",
1365                                             0,
1366                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1367     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1368     EXPECT_EQ(++numExpectedResources, numResources);
1369
1370     OCResourceHandle handle1;
1371     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1372                                             "core.led",
1373                                             "core.rw",
1374                                             "/a/led1",
1375                                             0,
1376                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1377     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1378     EXPECT_EQ(++numExpectedResources, numResources);
1379
1380     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1381     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1382     EXPECT_EQ(--numExpectedResources, numResources);
1383
1384     EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
1385
1386     OCResourceHandle handle2;
1387     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1388                                             "core.led",
1389                                             "core.rw",
1390                                             "/a/led2",
1391                                             0,
1392                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1393     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1394     EXPECT_EQ(++numExpectedResources, numResources);
1395
1396     EXPECT_EQ(OC_STACK_OK, OCStop());
1397 }
1398
1399 TEST(StackResourceAccess, DeleteMiddleResource)
1400 {
1401     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1402     OC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1403     InitStack(OC_SERVER);
1404
1405     uint8_t numResources = 0;
1406     uint8_t numExpectedResources = 0;
1407     uint8_t resourceIndex = InitResourceIndex();
1408
1409     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1410     resourceIndex = numExpectedResources;
1411     OCResourceHandle handle0;
1412     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1413                                             "core.led",
1414                                             "core.rw",
1415                                             "/a/led0",
1416                                             0,
1417                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1418     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1419     EXPECT_EQ(++numExpectedResources, numResources);
1420
1421     OCResourceHandle handle1;
1422     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1423                                             "core.led",
1424                                             "core.rw",
1425                                             "/a/led1",
1426                                             0,
1427                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1428     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1429     EXPECT_EQ(++numExpectedResources, numResources);
1430
1431     OCResourceHandle handle2;
1432     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1433                                             "core.led",
1434                                             "core.rw",
1435                                             "/a/led2",
1436                                             0,
1437                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1438     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1439     EXPECT_EQ(++numExpectedResources, numResources);
1440
1441     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1442     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1443     EXPECT_EQ(--numExpectedResources, numResources);
1444
1445     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1446     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1447
1448     // Make sure the resource elements are still correct
1449     uint8_t numResourceInterfaces;
1450     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1451     EXPECT_EQ(1, numResourceInterfaces);
1452     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0);
1453     EXPECT_STREQ("core.rw", resourceInterfaceName);
1454
1455     EXPECT_EQ(OC_STACK_OK, OCStop());
1456 }
1457
1458
1459 #ifdef __cplusplus
1460 extern "C" {
1461 #endif // __cplusplus
1462     void parsePresencePayload(char* payload, uint32_t* seqNum,
1463             uint32_t* maxAge, OCPresenceTrigger* presenceTrigger, char** resType);
1464 #ifdef __cplusplus
1465 }
1466 #endif // __cplusplus
1467
1468 TEST(StackPresence, ParsePresencePayload)
1469 {
1470     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1471     OC_LOG(INFO, TAG, "Starting ParsePresencePayload test");
1472
1473     char payload[100];
1474     uint32_t seqNum = 0, maxAge = 0;
1475     OCPresenceTrigger presenceTrigger = OC_PRESENCE_TRIGGER_CHANGE;
1476     char * resType = NULL;
1477
1478     //Good Scenario
1479     strncpy(payload, "{\"oic\":[{\"ttl\":99,\"non\":100,\"trg\":"
1480             "\"delete\",\"rt\":\"presence\"}]}", sizeof(payload));
1481     parsePresencePayload(payload, &seqNum, &maxAge,
1482             &presenceTrigger, &resType);
1483     EXPECT_TRUE(100 == seqNum);
1484     EXPECT_TRUE(99 == maxAge);
1485     EXPECT_TRUE(OC_PRESENCE_TRIGGER_DELETE == presenceTrigger);
1486     EXPECT_TRUE(NULL != resType);
1487     EXPECT_STREQ("presence", resType);
1488     OICFree(resType);
1489
1490     presenceTrigger = OC_PRESENCE_TRIGGER_CHANGE;
1491
1492     //Bad Scenario -- should not result in Seg Fault
1493     parsePresencePayload(payload, NULL, &maxAge, &presenceTrigger, &resType);
1494
1495     //Bad Scenario
1496     seqNum = 0; maxAge = 0; resType = NULL;
1497     strncpy(payload, "{abracadabra}", sizeof(payload));
1498     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1499     EXPECT_TRUE(0 == seqNum);
1500     EXPECT_TRUE(0 == maxAge);
1501     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1502     EXPECT_TRUE(NULL == resType);
1503     EXPECT_EQ(NULL, resType);
1504     OICFree(resType);
1505
1506     //Bad Scenario
1507     seqNum = 0; maxAge = 0; resType = NULL;
1508     strncpy(payload, "{\"oic\":[100]}", sizeof(payload));
1509     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1510     EXPECT_TRUE(0 == seqNum);
1511     EXPECT_TRUE(0 == maxAge);
1512     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1513     EXPECT_TRUE(NULL == resType);
1514     EXPECT_EQ(NULL, resType);
1515     OICFree(resType);
1516
1517     //Bad Scenario
1518     seqNum = 0; maxAge = 0; resType = NULL;
1519     strncpy(payload, "{\"oic\":[]}", sizeof(payload));
1520     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1521     EXPECT_TRUE(0 == seqNum);
1522     EXPECT_TRUE(0 == maxAge);
1523     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1524     EXPECT_TRUE(NULL == resType);
1525     EXPECT_EQ(NULL, resType);
1526     OICFree(resType);
1527
1528     //Bad Scenario
1529     strncpy(payload, "{:]}", sizeof(payload));
1530     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1531     EXPECT_TRUE(0 == seqNum);
1532     EXPECT_TRUE(0 == maxAge);
1533     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1534     EXPECT_TRUE(NULL == resType);
1535     EXPECT_EQ(NULL, resType);
1536     OICFree(resType);
1537
1538     //Bad Scenario
1539     strncpy(payload, "{:[presence}", sizeof(payload));
1540     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1541     EXPECT_TRUE(0 == seqNum);
1542     EXPECT_TRUE(0 == maxAge);
1543     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1544     EXPECT_TRUE(NULL == resType);
1545     EXPECT_EQ(NULL, resType);
1546     OICFree(resType);
1547 }
1548
1549 TEST(PODTests, OCHeaderOption)
1550 {
1551     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1552 }
1553
1554 TEST(PODTests, OCCallbackData)
1555 {
1556     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1557 }