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