resource/csdk/stack/test/stacktests.cpp

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