resource/csdk/stack/test/stacktests.cpp

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