resource/csdk/stack/test/stacktests.cpp

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