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