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 *uri65 = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKL";
 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                                             uri65, //"/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(1, numResourceInterfaces);
 735     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 736     EXPECT_STREQ("core.rw", resourceInterfaceName);
 737
 738     // try getting resource interface names with an invalid index
 739     resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
 740     EXPECT_STREQ(NULL, resourceInterfaceName);
 741     // try getting resource interface names with an invalid index
 742     resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
 743     EXPECT_STREQ(NULL, resourceInterfaceName);
 744
 745     EXPECT_EQ(OC_STACK_OK, OCStop());
 746 }
 747
 748 TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
 749 {
 750     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 751
 752     OIC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
 753
 754     InitStack(OC_SERVER);
 755
 756     OCResourceHandle handle;
 757     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 758                                             "core.led",
 759                                             "core.rw",
 760                                             "/a/led",
 761                                             0,
 762                                             NULL,
 763                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 764     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 765                                         OC_RSRVD_INTERFACE_DEFAULT));
 766     uint8_t numResourceInterfaces;
 767     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 768     EXPECT_EQ(2, numResourceInterfaces);
 769
 770     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
 771     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
 772
 773     const char*interfaceName_2 = OCGetResourceInterfaceName(handle, 1);
 774     EXPECT_STREQ("core.rw", interfaceName_2);
 775
 776     EXPECT_EQ(OC_STACK_OK, OCStop());
 777 }
 778
 779 TEST(StackResource, ResourceDuplicateDefaultInterfaces)
 780 {
 781     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 782
 783     OIC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
 784
 785     InitStack(OC_SERVER);
 786
 787     OCResourceHandle handle;
 788     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 789                                             "core.led",
 790                                             "core.rw",
 791                                             "/a/led",
 792                                             0,
 793                                             NULL,
 794                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 795
 796     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 797                                         OC_RSRVD_INTERFACE_DEFAULT));
 798     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 799                                         OC_RSRVD_INTERFACE_DEFAULT));
 800
 801     uint8_t numResourceInterfaces;
 802     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 803     EXPECT_EQ(2, numResourceInterfaces);
 804
 805     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
 806     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
 807
 808     EXPECT_EQ(OC_STACK_OK, OCStop());
 809 }
 810
 811 TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
 812 {
 813     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 814
 815     OIC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
 816
 817     InitStack(OC_SERVER);
 818
 819     OCResourceHandle handle;
 820     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 821                                             "core.led",
 822                                             "core.rw",
 823                                             "/a/led",
 824                                             0,
 825                                             NULL,
 826                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 827
 828     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 829                                         "core.rw"));
 830     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 831                                         "core.rw"));
 832
 833     uint8_t numResourceInterfaces;
 834     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 835     EXPECT_EQ(1, numResourceInterfaces);
 836
 837     EXPECT_EQ(OC_STACK_OK, OCStop());
 838 }
 839
 840 TEST(StackResource, ResourceTypeInterfaceMethods)
 841 {
 842     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 843     OIC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
 844     InitStack(OC_SERVER);
 845
 846     OCResourceHandle handle;
 847     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 848                                             "core.led",
 849                                             "core.rw",
 850                                             "/a/led",
 851                                             0,
 852                                             NULL,
 853                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 854
 855     uint8_t numResourceInterfaces;
 856     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 857     EXPECT_EQ(1, numResourceInterfaces);
 858
 859     EXPECT_EQ(OC_STACK_OK, OCStop());
 860 }
 861
 862 TEST(StackResource, GetResourceProperties)
 863 {
 864     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 865     OIC_LOG(INFO, TAG, "Starting GetResourceProperties test");
 866     InitStack(OC_SERVER);
 867
 868     OCResourceHandle handle;
 869     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 870                                             "core.led",
 871                                             "core.rw",
 872                                             "/a/led",
 873                                             0,
 874                                             NULL,
 875                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 876
 877     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
 878     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 879
 880     EXPECT_EQ(OC_STACK_OK, OCStop());
 881 }
 882
 883 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
 884 {
 885     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 886     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
 887     InitStack(OC_SERVER);
 888     uint8_t numResources = 0;
 889     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 890
 891     OCResourceHandle handle;
 892     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 893                                             "core.led",
 894                                             "core.rw",
 895                                             "/a1/led",
 896                                             0,
 897                                             NULL,
 898                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 899     const char *url = OCGetResourceUri(handle);
 900     EXPECT_STREQ("/a1/led", url);
 901
 902     //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
 903     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 904     uint8_t numExpectedResources = 0;
 905
 906     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
 907     EXPECT_EQ(numExpectedResources, numResources);
 908
 909     EXPECT_EQ(OC_STACK_OK, OCStop());
 910 }
 911
 912 TEST(StackResource, StackTestResourceDiscoverOneResource)
 913 {
 914     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 915     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
 916     InitStack(OC_SERVER);
 917
 918     OCResourceHandle handle;
 919     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 920                                             "core.led",
 921                                             "core.rw",
 922                                             "/a/led",
 923                                             0,
 924                                             NULL,
 925                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 926     const char *url = OCGetResourceUri(handle);
 927     EXPECT_STREQ("/a/led", url);
 928
 929     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 930     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 931
 932     EXPECT_EQ(OC_STACK_OK, OCStop());
 933 }
 934
 935 TEST(StackResource, StackTestResourceDiscoverManyResources)
 936 {
 937     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 938     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
 939     InitStack(OC_SERVER);
 940
 941     OCResourceHandle handle1;
 942     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 943                                             "core.led",
 944                                             "core.rw",
 945                                             "/a/led1",
 946                                             0,
 947                                             NULL,
 948                                             OC_DISCOVERABLE));
 949     const char *url = OCGetResourceUri(handle1);
 950     EXPECT_STREQ("/a/led1", url);
 951
 952     OCResourceHandle handle2;
 953     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 954                                             "core.led",
 955                                             "core.rw",
 956                                             "/a/led2",
 957                                             0,
 958                                             NULL,
 959                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 960     url = OCGetResourceUri(handle2);
 961     EXPECT_STREQ("/a/led2", url);
 962
 963     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
 964     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
 965
 966     OCResourceHandle handle3;
 967     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 968                                             "core.led",
 969                                             "core.rw",
 970                                             "/a/led3",
 971                                             0,
 972                                             NULL,
 973                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 974     url = OCGetResourceUri(handle3);
 975     EXPECT_STREQ("/a/led3", url);
 976
 977     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
 978     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
 979
 980     OCResourceHandle handle4;
 981     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
 982                                             "core.led",
 983                                             "core.rw",
 984                                             "/a/led4",
 985                                             0,
 986                                             NULL,
 987                                             OC_DISCOVERABLE));
 988     url = OCGetResourceUri(handle4);
 989     EXPECT_STREQ("/a/led4", url);
 990
 991     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
 992     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
 993     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
 994
 995     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 996
 997     EXPECT_EQ(OC_STACK_OK, OCStop());
 998 }
 999
1000 TEST(StackBind, BindResourceTypeNameBad)
1001 {
1002     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1003     OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
1004     InitStack(OC_SERVER);
1005
1006     OCResourceHandle handle;
1007     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1008                                             "core.led",
1009                                             "core.rw",
1010                                             "/a/led",
1011                                             0,
1012                                             NULL,
1013                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1014
1015     uint8_t numResourceTypes;
1016     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1017     EXPECT_EQ(1, numResourceTypes);
1018     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1019     EXPECT_STREQ("core.led", resourceTypeName);
1020
1021     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
1022
1023     EXPECT_EQ(OC_STACK_OK, OCStop());
1024 }
1025
1026 TEST(StackBind, BindResourceTypeNameGood)
1027 {
1028     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1029     OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
1030     InitStack(OC_SERVER);
1031
1032     OCResourceHandle handle;
1033     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1034                                             "core.led",
1035                                             "core.rw",
1036                                             "/a/led",
1037                                             0,
1038                                             NULL,
1039                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1040
1041     uint8_t numResourceTypes;
1042     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1043     EXPECT_EQ(1, numResourceTypes);
1044     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1045     EXPECT_STREQ("core.led", resourceTypeName);
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     resourceTypeName = OCGetResourceTypeName(handle, 1);
1051     EXPECT_STREQ("core.brightled", resourceTypeName);
1052
1053     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1054     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1055     EXPECT_EQ(3, numResourceTypes);
1056     resourceTypeName = OCGetResourceTypeName(handle, 2);
1057     EXPECT_STREQ("core.reallybrightled", resourceTypeName);
1058
1059     EXPECT_EQ(OC_STACK_OK, OCStop());
1060 }
1061
1062 TEST(StackBind, BindResourceTypeAttribRepGood)
1063 {
1064     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1065     OIC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
1066     InitStack(OC_SERVER);
1067
1068     OCResourceHandle handle;
1069     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1070                                             "core.led",
1071                                             "core.rw",
1072                                             "/a/led",
1073                                             0,
1074                                             NULL,
1075                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1076
1077     uint8_t numResourceTypes;
1078     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1079     EXPECT_EQ(1, numResourceTypes);
1080
1081     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1082     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1083     EXPECT_EQ(2, numResourceTypes);
1084
1085     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1086     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1087     EXPECT_EQ(3, numResourceTypes);
1088
1089     EXPECT_EQ(OC_STACK_OK, OCStop());
1090 }
1091
1092
1093 TEST(StackBind, BindResourceInterfaceNameBad)
1094 {
1095     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1096     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
1097     InitStack(OC_SERVER);
1098
1099     OCResourceHandle handle;
1100     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1101                                             "core.led",
1102                                             "core.rw",
1103                                             "/a/led",
1104                                             0,
1105                                             NULL,
1106                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1107
1108     uint8_t numResourceInterfaces;
1109     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1110     EXPECT_EQ(1, numResourceInterfaces);
1111     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
1112     EXPECT_STREQ("core.rw", resourceInterfaceName);
1113
1114     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
1115
1116     EXPECT_EQ(OC_STACK_OK, OCStop());
1117 }
1118
1119 TEST(StackBind, BindResourceInterfaceNameGood)
1120 {
1121     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1122     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
1123     InitStack(OC_SERVER);
1124
1125     OCResourceHandle handle;
1126     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1127                                             "core.led",
1128                                             "core.rw",
1129                                             "/a/led",
1130                                             0,
1131                                             NULL,
1132                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1133
1134     uint8_t numResourceInterfaces;
1135     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1136     EXPECT_EQ(1, numResourceInterfaces);
1137     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
1138     EXPECT_STREQ("core.rw", resourceInterfaceName);
1139
1140     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1141
1142     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1143     EXPECT_EQ(2, numResourceInterfaces);
1144     resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1145     EXPECT_STREQ("core.r", resourceInterfaceName);
1146
1147     EXPECT_EQ(OC_STACK_OK, OCStop());
1148 }
1149
1150 TEST(StackBind, BindResourceInterfaceMethodsBad)
1151 {
1152     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1153     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
1154     InitStack(OC_SERVER);
1155
1156     OCResourceHandle handle;
1157     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1158                                             "core.led",
1159                                             "core.rw",
1160                                             "/a/led",
1161                                             0,
1162                                             NULL,
1163                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1164
1165     uint8_t numResourceInterfaces;
1166     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1167     EXPECT_EQ(1, numResourceInterfaces);
1168
1169     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
1170
1171     EXPECT_EQ(OC_STACK_OK, OCStop());
1172 }
1173
1174 TEST(StackBind, BindResourceInterfaceMethodsGood)
1175 {
1176     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1177     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
1178     InitStack(OC_SERVER);
1179
1180     OCResourceHandle handle;
1181     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1182                                             "core.led",
1183                                             "core.rw",
1184                                             "/a/led",
1185                                             0,
1186                                             NULL,
1187                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1188
1189     uint8_t numResourceInterfaces;
1190     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1191     EXPECT_EQ(1, numResourceInterfaces);
1192
1193     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1194
1195     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1196     EXPECT_EQ(2, numResourceInterfaces);
1197
1198     EXPECT_EQ(OC_STACK_OK, OCStop());
1199 }
1200
1201 TEST(StackBind, BindContainedResourceBad)
1202 {
1203     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1204     OIC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
1205     InitStack(OC_SERVER);
1206
1207     OCResourceHandle containerHandle;
1208     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1209                                             "core.led",
1210                                             "core.rw",
1211                                             "/a/kitchen",
1212                                             0,
1213                                             NULL,
1214                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1215
1216     OCResourceHandle handle0;
1217     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1218                                             "core.led",
1219                                             "core.rw",
1220                                             "/a/led",
1221                                             0,
1222                                             NULL,
1223                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1224
1225     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1226
1227     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1228
1229     EXPECT_EQ(OC_STACK_OK, OCStop());
1230 }
1231
1232 TEST(StackBind, BindContainedResourceGood)
1233 {
1234     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1235     OIC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1236     InitStack(OC_SERVER);
1237
1238     uint8_t numResources = 0;
1239     uint8_t numExpectedResources = 0;
1240
1241     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1242
1243     OCResourceHandle containerHandle;
1244     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1245                                             "core.led",
1246                                             "core.rw",
1247                                             "/a/kitchen",
1248                                             0,
1249                                             NULL,
1250                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1251     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1252     EXPECT_EQ(++numExpectedResources, numResources);
1253
1254     OCResourceHandle handle0;
1255     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1256                                             "core.led",
1257                                             "core.rw",
1258                                             "/a/led0",
1259                                             0,
1260                                             NULL,
1261                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1262     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1263     EXPECT_EQ(++numExpectedResources, numResources);
1264
1265     OCResourceHandle handle1;
1266     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1267                                             "core.led",
1268                                             "core.rw",
1269                                             "/a/led1",
1270                                             0,
1271                                             NULL,
1272                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1273     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1274     EXPECT_EQ(++numExpectedResources, numResources);
1275
1276     OCResourceHandle handle2;
1277     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1278                                             "core.led",
1279                                             "core.rw",
1280                                             "/a/led2",
1281                                             0,
1282                                             NULL,
1283                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1284     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1285     EXPECT_EQ(++numExpectedResources, numResources);
1286
1287     OCResourceHandle handle3;
1288     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1289                                             "core.led",
1290                                             "core.rw",
1291                                             "/a/led3",
1292                                             0,
1293                                             NULL,
1294                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1295     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1296     EXPECT_EQ(++numExpectedResources, numResources);
1297
1298     OCResourceHandle handle4;
1299     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1300                                             "core.led",
1301                                             "core.rw",
1302                                             "/a/led4",
1303                                             0,
1304                                             NULL,
1305                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1306     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1307     EXPECT_EQ(++numExpectedResources, numResources);
1308
1309     OCResourceHandle handle5;
1310     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1311                                             "core.led",
1312                                             "core.rw",
1313                                             "/a/led5",
1314                                             0,
1315                                             NULL,
1316                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1317     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1318     EXPECT_EQ(++numExpectedResources, numResources);
1319
1320
1321     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1322     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1323     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1324     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1325     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1326     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle5));
1327
1328     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1329     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1330     EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1331     EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1332     EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1333     EXPECT_EQ(handle5, OCGetResourceHandleFromCollection(containerHandle, 5));
1334
1335     EXPECT_EQ(OC_STACK_OK, OCStop());
1336 }
1337
1338
1339 TEST(StackBind, BindEntityHandlerBad)
1340 {
1341     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1342     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1343     InitStack(OC_SERVER);
1344
1345     OCResourceHandle handle;
1346     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1347                                             "core.led",
1348                                             "core.rw",
1349                                             "/a/led",
1350                                             0,
1351                                             NULL,
1352                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1353
1354     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
1355
1356     EXPECT_EQ(OC_STACK_OK, OCStop());
1357 }
1358
1359 TEST(StackBind, BindEntityHandlerGood)
1360 {
1361     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1362     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1363     InitStack(OC_SERVER);
1364
1365     OCResourceHandle handle;
1366     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1367                                             "core.led",
1368                                             "core.rw",
1369                                             "/a/led",
1370                                             0,
1371                                             NULL,
1372                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1373
1374     OCEntityHandler myHandler = entityHandler;
1375
1376     EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
1377
1378     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1379
1380     EXPECT_EQ(OC_STACK_OK, OCStop());
1381 }
1382
1383 TEST(StackResourceAccess, GetResourceByIndex)
1384 {
1385     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1386     OIC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1387     InitStack(OC_SERVER);
1388
1389     uint8_t numResources = 0;
1390     uint8_t numExpectedResources = 0;
1391     uint8_t resourceIndex = 0;
1392     uint8_t prevResources = 0;
1393     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1394     prevResources = numExpectedResources;
1395     OCResourceHandle containerHandle;
1396     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1397                                             "core.led",
1398                                             "core.rw",
1399                                             "/a/kitchen",
1400                                             0,
1401                                             NULL,
1402                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1403     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1404     EXPECT_EQ(++numExpectedResources, numResources);
1405
1406     OCResourceHandle handle0;
1407     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1408                                             "core.led",
1409                                             "core.rw",
1410                                             "/a/led0",
1411                                             0,
1412                                             NULL,
1413                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1414     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1415     EXPECT_EQ(++numExpectedResources, numResources);
1416
1417     OCResourceHandle handle1;
1418     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1419                                             "core.led",
1420                                             "core.rw",
1421                                             "/a/led1",
1422                                             0,
1423                                             NULL,
1424                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1425     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1426     EXPECT_EQ(++numExpectedResources, numResources);
1427
1428     OCResourceHandle handle2;
1429     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1430                                             "core.led",
1431                                             "core.rw",
1432                                             "/a/led2",
1433                                             0,
1434                                             NULL,
1435                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1436     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1437     EXPECT_EQ(++numExpectedResources, numResources);
1438
1439     OCResourceHandle handle3;
1440     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1441                                             "core.led",
1442                                             "core.rw",
1443                                             "/a/led3",
1444                                             0,
1445                                             NULL,
1446                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1447     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1448     EXPECT_EQ(++numExpectedResources, numResources);
1449
1450     OCResourceHandle handle4;
1451     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1452                                             "core.led",
1453                                             "core.rw",
1454                                             "/a/led4",
1455                                             0,
1456                                             NULL,
1457                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1458     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1459     EXPECT_EQ(++numExpectedResources, numResources);
1460
1461     OCResourceHandle handle5;
1462     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1463                                             "core.led",
1464                                             "core.rw",
1465                                             "/a/led5",
1466                                             0,
1467                                             NULL,
1468                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1469     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1470     EXPECT_EQ(++numExpectedResources, numResources);
1471     resourceIndex += prevResources;
1472     EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1473     EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1474     EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1475     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1476     EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1477     EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1478     EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1479
1480     EXPECT_EQ(OC_STACK_OK, OCStop());
1481 }
1482
1483 TEST(StackResourceAccess, DeleteHeadResource)
1484 {
1485     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1486     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1487     InitStack(OC_SERVER);
1488
1489     uint8_t numResources = 0;
1490     uint8_t numExpectedResources = 0;
1491
1492     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1493
1494     OCResourceHandle handle0;
1495     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1496                                             "core.led",
1497                                             "core.rw",
1498                                             "/a/led0",
1499                                             0,
1500                                             NULL,
1501                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1502     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1503     EXPECT_EQ(++numExpectedResources, numResources);
1504
1505     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1506     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1507     EXPECT_EQ(--numExpectedResources, numResources);
1508
1509     EXPECT_EQ(OC_STACK_OK, OCStop());
1510 }
1511
1512 TEST(StackResourceAccess, DeleteHeadResource2)
1513 {
1514     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1515     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1516     InitStack(OC_SERVER);
1517
1518     uint8_t numResources = 0;
1519     uint8_t numExpectedResources = 0;
1520
1521     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1522     OCResourceHandle handle0;
1523     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1524                                             "core.led",
1525                                             "core.rw",
1526                                             "/a/led0",
1527                                             0,
1528                                             NULL,
1529                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1530     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1531     EXPECT_EQ(++numExpectedResources, numResources);
1532
1533     OCResourceHandle handle1;
1534     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1535                                             "core.led",
1536                                             "core.rw",
1537                                             "/a/led1",
1538                                             0,
1539                                             NULL,
1540                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1541     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1542     EXPECT_EQ(++numExpectedResources, numResources);
1543
1544     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1545     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1546     EXPECT_EQ(--numExpectedResources, numResources);
1547
1548     EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
1549
1550     EXPECT_EQ(OC_STACK_OK, OCStop());
1551 }
1552
1553
1554 TEST(StackResourceAccess, DeleteLastResource)
1555 {
1556     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1557     OIC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1558     InitStack(OC_SERVER);
1559
1560     uint8_t numResources = 0;
1561     uint8_t numExpectedResources = 0;
1562
1563     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1564
1565     OCResourceHandle handle0;
1566     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1567                                             "core.led",
1568                                             "core.rw",
1569                                             "/a/led0",
1570                                             0,
1571                                             NULL,
1572                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1573     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1574     EXPECT_EQ(++numExpectedResources, numResources);
1575
1576     OCResourceHandle handle1;
1577     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1578                                             "core.led",
1579                                             "core.rw",
1580                                             "/a/led1",
1581                                             0,
1582                                             NULL,
1583                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1584     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1585     EXPECT_EQ(++numExpectedResources, numResources);
1586
1587     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1588     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1589     EXPECT_EQ(--numExpectedResources, numResources);
1590
1591     EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
1592
1593     OCResourceHandle handle2;
1594     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1595                                             "core.led",
1596                                             "core.rw",
1597                                             "/a/led2",
1598                                             0,
1599                                             NULL,
1600                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1601     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1602     EXPECT_EQ(++numExpectedResources, numResources);
1603
1604     EXPECT_EQ(OC_STACK_OK, OCStop());
1605 }
1606
1607 TEST(StackResourceAccess, DeleteMiddleResource)
1608 {
1609     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1610     OIC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1611     InitStack(OC_SERVER);
1612
1613     uint8_t numResources = 0;
1614     uint8_t numExpectedResources = 0;
1615     uint8_t resourceIndex = InitResourceIndex();
1616
1617     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1618     resourceIndex = numExpectedResources;
1619     OCResourceHandle handle0;
1620     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1621                                             "core.led",
1622                                             "core.rw",
1623                                             "/a/led0",
1624                                             0,
1625                                             NULL,
1626                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1627     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1628     EXPECT_EQ(++numExpectedResources, numResources);
1629
1630     OCResourceHandle handle1;
1631     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1632                                             "core.led",
1633                                             "core.rw",
1634                                             "/a/led1",
1635                                             0,
1636                                             NULL,
1637                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1638     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1639     EXPECT_EQ(++numExpectedResources, numResources);
1640
1641     OCResourceHandle handle2;
1642     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1643                                             "core.led",
1644                                             "core.rw",
1645                                             "/a/led2",
1646                                             0,
1647                                             NULL,
1648                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1649     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1650     EXPECT_EQ(++numExpectedResources, numResources);
1651
1652     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1653     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1654     EXPECT_EQ(--numExpectedResources, numResources);
1655
1656     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1657     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1658
1659     // Make sure the resource elements are still correct
1660     uint8_t numResourceInterfaces;
1661     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1662     EXPECT_EQ(1, numResourceInterfaces);
1663     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0);
1664     EXPECT_STREQ("core.rw", resourceInterfaceName);
1665
1666     EXPECT_EQ(OC_STACK_OK, OCStop());
1667 }
1668
1669 TEST(PODTests, OCHeaderOption)
1670 {
1671     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1672 }
1673
1674 TEST(PODTests, OCCallbackData)
1675 {
1676     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1677 }
1678
1679 TEST(OCDoDirectPairingTests, Nullpeer)
1680 {
1681     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, pmSel, &pinNumber, &resultCallback));
1682 }
1683
1684 TEST(OCDoDirectPairingTests, NullCallback)
1685 {
1686     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(&peer, pmSel, &pinNumber, NULL));
1687 }
1688
1689 TEST(OCDoDirectPairingTests, NullpinNumber)
1690 {
1691     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(&peer, pmSel, NULL, &resultCallback));
1692 }
1693
1694 TEST(StackResource, MultipleResourcesDiscovery)
1695 {
1696     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1697     OIC_LOG(INFO, TAG, "Starting MultipleResourcesDiscovery test");
1698     InitStack(OC_SERVER);
1699
1700     OCResourceHandle handle1;
1701     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1702                                             "core.led",
1703                                             "core.rw",
1704                                             "/a/led1",
1705                                             0,
1706                                             NULL,
1707                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1708
1709     OCResourceHandle handle2;
1710     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1711                                             "core.led",
1712                                             "core.rw",
1713                                             "/a/led2",
1714                                             0,
1715                                             NULL,
1716                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1717     OCResourceHandle handle3;
1718     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1719                                             "core.led",
1720                                             "core.rw",
1721                                             "/a/led3",
1722                                             0,
1723                                             NULL,
1724                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1725     /* Start a discovery query*/
1726     char szQueryUri[256] = "/oic/res?if=oic.if.ll";
1727     OCCallbackData cbData;
1728     cbData.cb = discoveryCallback;
1729     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
1730     cbData.cd = NULL;
1731
1732     OCDoHandle handle;
1733     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
1734                                         OC_REST_DISCOVER,
1735                                         szQueryUri,
1736                                         0,
1737                                         0,
1738                                         CT_ADAPTER_IP,
1739                                         OC_LOW_QOS,
1740                                         &cbData,
1741                                         NULL,
1742                                         0));
1743
1744     EXPECT_EQ(OC_STACK_OK, OCStop());
1745 }