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