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