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