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