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     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, "core.nameBad"));
1027     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, "core.name bad"));
1028
1029     EXPECT_EQ(OC_STACK_OK, OCStop());
1030 }
1031
1032 TEST(StackBind, BindResourceTypeNameGood)
1033 {
1034     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1035     OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
1036     InitStack(OC_SERVER);
1037
1038     OCResourceHandle handle;
1039     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1040                                             "core.led",
1041                                             "core.rw",
1042                                             "/a/led",
1043                                             0,
1044                                             NULL,
1045                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1046
1047     uint8_t numResourceTypes;
1048     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1049     EXPECT_EQ(1, numResourceTypes);
1050     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1051     EXPECT_STREQ("core.led", resourceTypeName);
1052
1053     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1054     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1055     EXPECT_EQ(2, numResourceTypes);
1056     resourceTypeName = OCGetResourceTypeName(handle, 1);
1057     EXPECT_STREQ("core.brightled", resourceTypeName);
1058
1059     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1060     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1061     EXPECT_EQ(3, numResourceTypes);
1062     resourceTypeName = OCGetResourceTypeName(handle, 2);
1063     EXPECT_STREQ("core.reallybrightled", resourceTypeName);
1064
1065     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "x.ReallyReallyBrightLED"));
1066     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1067     EXPECT_EQ(4, numResourceTypes);
1068     resourceTypeName = OCGetResourceTypeName(handle, 3);
1069     EXPECT_STREQ("x.ReallyReallyBrightLED", resourceTypeName);
1070
1071     EXPECT_EQ(OC_STACK_OK, OCStop());
1072 }
1073
1074 TEST(StackBind, BindResourceTypeAttribRepGood)
1075 {
1076     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1077     OIC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
1078     InitStack(OC_SERVER);
1079
1080     OCResourceHandle handle;
1081     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1082                                             "core.led",
1083                                             "core.rw",
1084                                             "/a/led",
1085                                             0,
1086                                             NULL,
1087                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1088
1089     uint8_t numResourceTypes;
1090     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1091     EXPECT_EQ(1, numResourceTypes);
1092
1093     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1094     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1095     EXPECT_EQ(2, numResourceTypes);
1096
1097     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1098     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1099     EXPECT_EQ(3, numResourceTypes);
1100
1101     EXPECT_EQ(OC_STACK_OK, OCStop());
1102 }
1103
1104
1105 TEST(StackBind, BindResourceInterfaceNameBad)
1106 {
1107     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1108     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
1109     InitStack(OC_SERVER);
1110
1111     OCResourceHandle handle;
1112     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1113                                             "core.led",
1114                                             "core.rw",
1115                                             "/a/led",
1116                                             0,
1117                                             NULL,
1118                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1119
1120     uint8_t numResourceInterfaces;
1121     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1122     EXPECT_EQ(2, numResourceInterfaces);
1123     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1124     EXPECT_STREQ("core.rw", resourceInterfaceName);
1125
1126     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
1127
1128     EXPECT_EQ(OC_STACK_OK, OCStop());
1129 }
1130
1131 TEST(StackBind, BindResourceInterfaceNameGood)
1132 {
1133     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1134     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
1135     InitStack(OC_SERVER);
1136
1137     OCResourceHandle handle;
1138     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1139                                             "core.led",
1140                                             "core.rw",
1141                                             "/a/led",
1142                                             0,
1143                                             NULL,
1144                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1145
1146     uint8_t numResourceInterfaces;
1147     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1148     EXPECT_EQ(2, numResourceInterfaces);
1149     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1150     EXPECT_STREQ("core.rw", resourceInterfaceName);
1151
1152     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1153
1154     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1155     EXPECT_EQ(3, numResourceInterfaces);
1156     resourceInterfaceName = OCGetResourceInterfaceName(handle, 2);
1157     EXPECT_STREQ("core.r", resourceInterfaceName);
1158
1159     EXPECT_EQ(OC_STACK_OK, OCStop());
1160 }
1161
1162 TEST(StackBind, BindResourceInterfaceMethodsBad)
1163 {
1164     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1165     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
1166     InitStack(OC_SERVER);
1167
1168     OCResourceHandle handle;
1169     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1170                                             "core.led",
1171                                             "core.rw",
1172                                             "/a/led",
1173                                             0,
1174                                             NULL,
1175                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1176
1177     uint8_t numResourceInterfaces;
1178     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1179     EXPECT_EQ(2, numResourceInterfaces);
1180
1181     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
1182
1183     EXPECT_EQ(OC_STACK_OK, OCStop());
1184 }
1185
1186 TEST(StackBind, BindResourceInterfaceMethodsGood)
1187 {
1188     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1189     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
1190     InitStack(OC_SERVER);
1191
1192     OCResourceHandle handle;
1193     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1194                                             "core.led",
1195                                             "core.rw",
1196                                             "/a/led",
1197                                             0,
1198                                             NULL,
1199                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1200
1201     uint8_t numResourceInterfaces;
1202     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1203     EXPECT_EQ(2, numResourceInterfaces);
1204
1205     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1206
1207     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1208     EXPECT_EQ(3, numResourceInterfaces);
1209
1210     EXPECT_EQ(OC_STACK_OK, OCStop());
1211 }
1212
1213 TEST(StackBind, BindContainedResourceBad)
1214 {
1215     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1216     OIC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
1217     InitStack(OC_SERVER);
1218
1219     OCResourceHandle containerHandle;
1220     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1221                                             "core.led",
1222                                             "core.rw",
1223                                             "/a/kitchen",
1224                                             0,
1225                                             NULL,
1226                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1227
1228     OCResourceHandle handle0;
1229     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1230                                             "core.led",
1231                                             "core.rw",
1232                                             "/a/led",
1233                                             0,
1234                                             NULL,
1235                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1236
1237     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1238
1239     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1240
1241     EXPECT_EQ(OC_STACK_OK, OCStop());
1242 }
1243
1244 TEST(StackBind, BindContainedResourceGood)
1245 {
1246     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1247     OIC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1248     InitStack(OC_SERVER);
1249
1250     uint8_t numResources = 0;
1251     uint8_t numExpectedResources = 0;
1252
1253     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1254
1255     OCResourceHandle containerHandle;
1256     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1257                                             "core.led",
1258                                             "core.rw",
1259                                             "/a/kitchen",
1260                                             0,
1261                                             NULL,
1262                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1263     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1264     EXPECT_EQ(++numExpectedResources, numResources);
1265
1266     OCResourceHandle handle0;
1267     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1268                                             "core.led",
1269                                             "core.rw",
1270                                             "/a/led0",
1271                                             0,
1272                                             NULL,
1273                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1274     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1275     EXPECT_EQ(++numExpectedResources, numResources);
1276
1277     OCResourceHandle handle1;
1278     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1279                                             "core.led",
1280                                             "core.rw",
1281                                             "/a/led1",
1282                                             0,
1283                                             NULL,
1284                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1285     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1286     EXPECT_EQ(++numExpectedResources, numResources);
1287
1288     OCResourceHandle handle2;
1289     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1290                                             "core.led",
1291                                             "core.rw",
1292                                             "/a/led2",
1293                                             0,
1294                                             NULL,
1295                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1296     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1297     EXPECT_EQ(++numExpectedResources, numResources);
1298
1299     OCResourceHandle handle3;
1300     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1301                                             "core.led",
1302                                             "core.rw",
1303                                             "/a/led3",
1304                                             0,
1305                                             NULL,
1306                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1307     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1308     EXPECT_EQ(++numExpectedResources, numResources);
1309
1310     OCResourceHandle handle4;
1311     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1312                                             "core.led",
1313                                             "core.rw",
1314                                             "/a/led4",
1315                                             0,
1316                                             NULL,
1317                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1318     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1319     EXPECT_EQ(++numExpectedResources, numResources);
1320
1321     OCResourceHandle handle5;
1322     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1323                                             "core.led",
1324                                             "core.rw",
1325                                             "/a/led5",
1326                                             0,
1327                                             NULL,
1328                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1329     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1330     EXPECT_EQ(++numExpectedResources, numResources);
1331
1332
1333     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1334     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1335     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1336     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1337     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1338     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle5));
1339
1340     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1341     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1342     EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1343     EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1344     EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1345     EXPECT_EQ(handle5, OCGetResourceHandleFromCollection(containerHandle, 5));
1346
1347     EXPECT_EQ(OC_STACK_OK, OCStop());
1348 }
1349
1350
1351 TEST(StackBind, BindEntityHandlerBad)
1352 {
1353     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1354     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1355     InitStack(OC_SERVER);
1356
1357     OCResourceHandle handle;
1358     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1359                                             "core.led",
1360                                             "core.rw",
1361                                             "/a/led",
1362                                             0,
1363                                             NULL,
1364                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1365
1366     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
1367
1368     EXPECT_EQ(OC_STACK_OK, OCStop());
1369 }
1370
1371 TEST(StackBind, BindEntityHandlerGood)
1372 {
1373     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1374     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1375     InitStack(OC_SERVER);
1376
1377     OCResourceHandle handle;
1378     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1379                                             "core.led",
1380                                             "core.rw",
1381                                             "/a/led",
1382                                             0,
1383                                             NULL,
1384                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1385
1386     OCEntityHandler myHandler = entityHandler;
1387
1388     EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
1389
1390     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1391
1392     EXPECT_EQ(OC_STACK_OK, OCStop());
1393 }
1394
1395 TEST(StackResourceAccess, GetResourceByIndex)
1396 {
1397     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1398     OIC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1399     InitStack(OC_SERVER);
1400
1401     uint8_t numResources = 0;
1402     uint8_t numExpectedResources = 0;
1403     uint8_t resourceIndex = 0;
1404     uint8_t prevResources = 0;
1405     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1406     prevResources = numExpectedResources;
1407     OCResourceHandle containerHandle;
1408     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1409                                             "core.led",
1410                                             "core.rw",
1411                                             "/a/kitchen",
1412                                             0,
1413                                             NULL,
1414                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1415     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1416     EXPECT_EQ(++numExpectedResources, numResources);
1417
1418     OCResourceHandle handle0;
1419     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1420                                             "core.led",
1421                                             "core.rw",
1422                                             "/a/led0",
1423                                             0,
1424                                             NULL,
1425                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1426     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1427     EXPECT_EQ(++numExpectedResources, numResources);
1428
1429     OCResourceHandle handle1;
1430     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1431                                             "core.led",
1432                                             "core.rw",
1433                                             "/a/led1",
1434                                             0,
1435                                             NULL,
1436                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1437     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1438     EXPECT_EQ(++numExpectedResources, numResources);
1439
1440     OCResourceHandle handle2;
1441     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1442                                             "core.led",
1443                                             "core.rw",
1444                                             "/a/led2",
1445                                             0,
1446                                             NULL,
1447                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1448     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1449     EXPECT_EQ(++numExpectedResources, numResources);
1450
1451     OCResourceHandle handle3;
1452     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1453                                             "core.led",
1454                                             "core.rw",
1455                                             "/a/led3",
1456                                             0,
1457                                             NULL,
1458                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1459     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1460     EXPECT_EQ(++numExpectedResources, numResources);
1461
1462     OCResourceHandle handle4;
1463     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1464                                             "core.led",
1465                                             "core.rw",
1466                                             "/a/led4",
1467                                             0,
1468                                             NULL,
1469                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1470     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1471     EXPECT_EQ(++numExpectedResources, numResources);
1472
1473     OCResourceHandle handle5;
1474     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1475                                             "core.led",
1476                                             "core.rw",
1477                                             "/a/led5",
1478                                             0,
1479                                             NULL,
1480                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1481     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1482     EXPECT_EQ(++numExpectedResources, numResources);
1483     resourceIndex += prevResources;
1484     EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1485     EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1486     EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1487     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1488     EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1489     EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1490     EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1491
1492     EXPECT_EQ(OC_STACK_OK, OCStop());
1493 }
1494
1495 TEST(StackResourceAccess, DeleteHeadResource)
1496 {
1497     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1498     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1499     InitStack(OC_SERVER);
1500
1501     uint8_t numResources = 0;
1502     uint8_t numExpectedResources = 0;
1503
1504     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1505
1506     OCResourceHandle handle0;
1507     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1508                                             "core.led",
1509                                             "core.rw",
1510                                             "/a/led0",
1511                                             0,
1512                                             NULL,
1513                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1514     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1515     EXPECT_EQ(++numExpectedResources, numResources);
1516
1517     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1518     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1519     EXPECT_EQ(--numExpectedResources, numResources);
1520
1521     EXPECT_EQ(OC_STACK_OK, OCStop());
1522 }
1523
1524 TEST(StackResourceAccess, DeleteHeadResource2)
1525 {
1526     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1527     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1528     InitStack(OC_SERVER);
1529
1530     uint8_t numResources = 0;
1531     uint8_t numExpectedResources = 0;
1532
1533     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1534     OCResourceHandle handle0;
1535     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1536                                             "core.led",
1537                                             "core.rw",
1538                                             "/a/led0",
1539                                             0,
1540                                             NULL,
1541                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1542     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1543     EXPECT_EQ(++numExpectedResources, numResources);
1544
1545     OCResourceHandle handle1;
1546     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1547                                             "core.led",
1548                                             "core.rw",
1549                                             "/a/led1",
1550                                             0,
1551                                             NULL,
1552                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1553     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1554     EXPECT_EQ(++numExpectedResources, numResources);
1555
1556     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1557     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1558     EXPECT_EQ(--numExpectedResources, numResources);
1559
1560     EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
1561
1562     EXPECT_EQ(OC_STACK_OK, OCStop());
1563 }
1564
1565
1566 TEST(StackResourceAccess, DeleteLastResource)
1567 {
1568     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1569     OIC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1570     InitStack(OC_SERVER);
1571
1572     uint8_t numResources = 0;
1573     uint8_t numExpectedResources = 0;
1574
1575     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1576
1577     OCResourceHandle handle0;
1578     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1579                                             "core.led",
1580                                             "core.rw",
1581                                             "/a/led0",
1582                                             0,
1583                                             NULL,
1584                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1585     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1586     EXPECT_EQ(++numExpectedResources, numResources);
1587
1588     OCResourceHandle handle1;
1589     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1590                                             "core.led",
1591                                             "core.rw",
1592                                             "/a/led1",
1593                                             0,
1594                                             NULL,
1595                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1596     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1597     EXPECT_EQ(++numExpectedResources, numResources);
1598
1599     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1600     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1601     EXPECT_EQ(--numExpectedResources, numResources);
1602
1603     EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
1604
1605     OCResourceHandle handle2;
1606     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1607                                             "core.led",
1608                                             "core.rw",
1609                                             "/a/led2",
1610                                             0,
1611                                             NULL,
1612                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1613     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1614     EXPECT_EQ(++numExpectedResources, numResources);
1615
1616     EXPECT_EQ(OC_STACK_OK, OCStop());
1617 }
1618
1619 TEST(StackResourceAccess, DeleteMiddleResource)
1620 {
1621     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1622     OIC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1623     InitStack(OC_SERVER);
1624
1625     uint8_t numResources = 0;
1626     uint8_t numExpectedResources = 0;
1627     uint8_t resourceIndex = InitResourceIndex();
1628
1629     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1630     resourceIndex = numExpectedResources;
1631     OCResourceHandle handle0;
1632     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1633                                             "core.led",
1634                                             "core.rw",
1635                                             "/a/led0",
1636                                             0,
1637                                             NULL,
1638                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1639     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1640     EXPECT_EQ(++numExpectedResources, numResources);
1641
1642     OCResourceHandle handle1;
1643     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1644                                             "core.led",
1645                                             "core.rw",
1646                                             "/a/led1",
1647                                             0,
1648                                             NULL,
1649                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1650     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1651     EXPECT_EQ(++numExpectedResources, numResources);
1652
1653     OCResourceHandle handle2;
1654     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1655                                             "core.led",
1656                                             "core.rw",
1657                                             "/a/led2",
1658                                             0,
1659                                             NULL,
1660                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1661     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1662     EXPECT_EQ(++numExpectedResources, numResources);
1663
1664     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1665     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1666     EXPECT_EQ(--numExpectedResources, numResources);
1667
1668     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1669     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1670
1671     // Make sure the resource elements are still correct
1672     uint8_t numResourceInterfaces;
1673     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1674     EXPECT_EQ(2, numResourceInterfaces);
1675     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 1);
1676     EXPECT_STREQ("core.rw", resourceInterfaceName);
1677
1678     EXPECT_EQ(OC_STACK_OK, OCStop());
1679 }
1680
1681 TEST(PODTests, OCHeaderOption)
1682 {
1683     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1684 }
1685
1686 TEST(PODTests, OCCallbackData)
1687 {
1688     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1689 }
1690
1691 TEST(OCDoDirectPairingTests, Nullpeer)
1692 {
1693     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, pmSel, &pinNumber, &resultCallback));
1694 }
1695
1696 TEST(OCDoDirectPairingTests, NullCallback)
1697 {
1698     EXPECT_EQ(OC_STACK_INVALID_CALLBACK,OCDoDirectPairing(&peer, pmSel, &pinNumber, NULL));
1699 }
1700
1701 TEST(OCDoDirectPairingTests, NullpinNumber)
1702 {
1703     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(&peer, pmSel, NULL, &resultCallback));
1704 }
1705
1706 TEST(StackResource, MultipleResourcesDiscovery)
1707 {
1708     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1709     OIC_LOG(INFO, TAG, "Starting MultipleResourcesDiscovery test");
1710     InitStack(OC_SERVER);
1711
1712     OCResourceHandle handle1;
1713     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1714                                             "core.led",
1715                                             "core.rw",
1716                                             "/a/led1",
1717                                             0,
1718                                             NULL,
1719                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1720
1721     OCResourceHandle handle2;
1722     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1723                                             "core.led",
1724                                             "core.rw",
1725                                             "/a/led2",
1726                                             0,
1727                                             NULL,
1728                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1729     OCResourceHandle handle3;
1730     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1731                                             "core.led",
1732                                             "core.rw",
1733                                             "/a/led3",
1734                                             0,
1735                                             NULL,
1736                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1737     /* Start a discovery query*/
1738     char szQueryUri[256] = "/oic/res?if=oic.if.ll";
1739     OCCallbackData cbData;
1740     cbData.cb = discoveryCallback;
1741     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
1742     cbData.cd = NULL;
1743
1744     OCDoHandle handle;
1745     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
1746                                         OC_REST_DISCOVER,
1747                                         szQueryUri,
1748                                         0,
1749                                         0,
1750                                         CT_ADAPTER_IP,
1751                                         OC_LOW_QOS,
1752                                         &cbData,
1753                                         NULL,
1754                                         0));
1755
1756     EXPECT_EQ(OC_STACK_OK, OCStop());
1757 }