resource/csdk/stack/test/stacktests.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21
  22 extern "C"
  23 {
  24     #include "ocstack.h"
  25     #include "ocstackinternal.h"
  26     #include "logger.h"
  27     #include "oic_malloc.h"
  28 }
  29
  30 #include "gtest/gtest.h"
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <errno.h>
  34 #include <fcntl.h>
  35 #include <unistd.h>
  36 #include <stdlib.h>
  37
  38 //-----------------------------------------------------------------------------
  39 // Includes
  40 //-----------------------------------------------------------------------------
  41 #include <stdio.h>
  42 #include <string.h>
  43
  44 #include <iostream>
  45 #include <stdint.h>
  46
  47 #include "gtest_helper.h"
  48
  49 using namespace std;
  50
  51 namespace itst = iotivity::test;
  52
  53 #define DEFAULT_CONTEXT_VALUE 0x99
  54
  55 //-----------------------------------------------------------------------------
  56 // Private variables
  57 //-----------------------------------------------------------------------------
  58 static const char TAG[] = "TestHarness";
  59
  60 char gDeviceUUID[] = "myDeviceUUID";
  61 char gManufacturerName[] = "myName";
  62 char gTooLongManufacturerName[] = "extremelylongmanufacturername";
  63 char gManufacturerUrl[] = "www.foooooooooooooooo.baaaaaaaaaaaaar";
  64 static OCPrm_t pmSel;
  65 static char pinNumber;
  66 static OCDPDev_t peer;
  67
  68 std::chrono::seconds const SHORT_TEST_TIMEOUT = std::chrono::seconds(5);
  69
  70 //-----------------------------------------------------------------------------
  71 // Callback functions
  72 //-----------------------------------------------------------------------------
  73 extern "C"  OCStackApplicationResult asyncDoResourcesCallback(void* ctx,
  74         OCDoHandle /*handle*/, OCClientResponse * clientResponse)
  75 {
  76     OIC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
  77
  78     EXPECT_EQ(OC_STACK_OK, clientResponse->result);
  79
  80     if(ctx == (void*)DEFAULT_CONTEXT_VALUE) {
  81         OIC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
  82     }
  83     OIC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
  84
  85     return OC_STACK_KEEP_TRANSACTION;
  86 }
  87
  88 static void resultCallback(void *UNUSED1, OCDPDev_t *UNUSED2, OCStackResult UNUSED3)
  89 {
  90     (void) (UNUSED1);
  91     (void) (UNUSED2);
  92     (void) (UNUSED3);
  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[MAX_QUERY_LENGTH] = { 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[MAX_QUERY_LENGTH] = { 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 *uri65 = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKL";
 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                                             uri65, //"/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
1026     EXPECT_EQ(OC_STACK_OK, OCStop());
1027 }
1028
1029 TEST(StackBind, BindResourceTypeNameGood)
1030 {
1031     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1032     OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
1033     InitStack(OC_SERVER);
1034
1035     OCResourceHandle handle;
1036     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1037                                             "core.led",
1038                                             "core.rw",
1039                                             "/a/led",
1040                                             0,
1041                                             NULL,
1042                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1043
1044     uint8_t numResourceTypes;
1045     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1046     EXPECT_EQ(1, numResourceTypes);
1047     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1048     EXPECT_STREQ("core.led", resourceTypeName);
1049
1050     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1051     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1052     EXPECT_EQ(2, numResourceTypes);
1053     resourceTypeName = OCGetResourceTypeName(handle, 1);
1054     EXPECT_STREQ("core.brightled", resourceTypeName);
1055
1056     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1057     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1058     EXPECT_EQ(3, numResourceTypes);
1059     resourceTypeName = OCGetResourceTypeName(handle, 2);
1060     EXPECT_STREQ("core.reallybrightled", resourceTypeName);
1061
1062     EXPECT_EQ(OC_STACK_OK, OCStop());
1063 }
1064
1065 TEST(StackBind, BindResourceTypeAttribRepGood)
1066 {
1067     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1068     OIC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
1069     InitStack(OC_SERVER);
1070
1071     OCResourceHandle handle;
1072     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1073                                             "core.led",
1074                                             "core.rw",
1075                                             "/a/led",
1076                                             0,
1077                                             NULL,
1078                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1079
1080     uint8_t numResourceTypes;
1081     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1082     EXPECT_EQ(1, numResourceTypes);
1083
1084     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1085     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1086     EXPECT_EQ(2, numResourceTypes);
1087
1088     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1089     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1090     EXPECT_EQ(3, numResourceTypes);
1091
1092     EXPECT_EQ(OC_STACK_OK, OCStop());
1093 }
1094
1095
1096 TEST(StackBind, BindResourceInterfaceNameBad)
1097 {
1098     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1099     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
1100     InitStack(OC_SERVER);
1101
1102     OCResourceHandle handle;
1103     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1104                                             "core.led",
1105                                             "core.rw",
1106                                             "/a/led",
1107                                             0,
1108                                             NULL,
1109                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1110
1111     uint8_t numResourceInterfaces;
1112     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1113     EXPECT_EQ(2, numResourceInterfaces);
1114     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1115     EXPECT_STREQ("core.rw", resourceInterfaceName);
1116
1117     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
1118
1119     EXPECT_EQ(OC_STACK_OK, OCStop());
1120 }
1121
1122 TEST(StackBind, BindResourceInterfaceNameGood)
1123 {
1124     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1125     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
1126     InitStack(OC_SERVER);
1127
1128     OCResourceHandle handle;
1129     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1130                                             "core.led",
1131                                             "core.rw",
1132                                             "/a/led",
1133                                             0,
1134                                             NULL,
1135                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1136
1137     uint8_t numResourceInterfaces;
1138     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1139     EXPECT_EQ(2, numResourceInterfaces);
1140     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1141     EXPECT_STREQ("core.rw", resourceInterfaceName);
1142
1143     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1144
1145     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1146     EXPECT_EQ(3, numResourceInterfaces);
1147     resourceInterfaceName = OCGetResourceInterfaceName(handle, 2);
1148     EXPECT_STREQ("core.r", resourceInterfaceName);
1149
1150     EXPECT_EQ(OC_STACK_OK, OCStop());
1151 }
1152
1153 TEST(StackBind, BindResourceInterfaceMethodsBad)
1154 {
1155     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1156     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
1157     InitStack(OC_SERVER);
1158
1159     OCResourceHandle handle;
1160     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1161                                             "core.led",
1162                                             "core.rw",
1163                                             "/a/led",
1164                                             0,
1165                                             NULL,
1166                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1167
1168     uint8_t numResourceInterfaces;
1169     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1170     EXPECT_EQ(2, numResourceInterfaces);
1171
1172     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
1173
1174     EXPECT_EQ(OC_STACK_OK, OCStop());
1175 }
1176
1177 TEST(StackBind, BindResourceInterfaceMethodsGood)
1178 {
1179     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1180     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
1181     InitStack(OC_SERVER);
1182
1183     OCResourceHandle handle;
1184     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1185                                             "core.led",
1186                                             "core.rw",
1187                                             "/a/led",
1188                                             0,
1189                                             NULL,
1190                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1191
1192     uint8_t numResourceInterfaces;
1193     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1194     EXPECT_EQ(2, numResourceInterfaces);
1195
1196     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1197
1198     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1199     EXPECT_EQ(3, numResourceInterfaces);
1200
1201     EXPECT_EQ(OC_STACK_OK, OCStop());
1202 }
1203
1204 TEST(StackBind, BindContainedResourceBad)
1205 {
1206     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1207     OIC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
1208     InitStack(OC_SERVER);
1209
1210     OCResourceHandle containerHandle;
1211     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1212                                             "core.led",
1213                                             "core.rw",
1214                                             "/a/kitchen",
1215                                             0,
1216                                             NULL,
1217                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1218
1219     OCResourceHandle handle0;
1220     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1221                                             "core.led",
1222                                             "core.rw",
1223                                             "/a/led",
1224                                             0,
1225                                             NULL,
1226                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1227
1228     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1229
1230     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1231
1232     EXPECT_EQ(OC_STACK_OK, OCStop());
1233 }
1234
1235 TEST(StackBind, BindContainedResourceGood)
1236 {
1237     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1238     OIC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1239     InitStack(OC_SERVER);
1240
1241     uint8_t numResources = 0;
1242     uint8_t numExpectedResources = 0;
1243
1244     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1245
1246     OCResourceHandle containerHandle;
1247     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1248                                             "core.led",
1249                                             "core.rw",
1250                                             "/a/kitchen",
1251                                             0,
1252                                             NULL,
1253                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1254     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1255     EXPECT_EQ(++numExpectedResources, numResources);
1256
1257     OCResourceHandle handle0;
1258     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1259                                             "core.led",
1260                                             "core.rw",
1261                                             "/a/led0",
1262                                             0,
1263                                             NULL,
1264                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1265     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1266     EXPECT_EQ(++numExpectedResources, numResources);
1267
1268     OCResourceHandle handle1;
1269     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1270                                             "core.led",
1271                                             "core.rw",
1272                                             "/a/led1",
1273                                             0,
1274                                             NULL,
1275                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1276     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1277     EXPECT_EQ(++numExpectedResources, numResources);
1278
1279     OCResourceHandle handle2;
1280     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1281                                             "core.led",
1282                                             "core.rw",
1283                                             "/a/led2",
1284                                             0,
1285                                             NULL,
1286                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1287     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1288     EXPECT_EQ(++numExpectedResources, numResources);
1289
1290     OCResourceHandle handle3;
1291     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1292                                             "core.led",
1293                                             "core.rw",
1294                                             "/a/led3",
1295                                             0,
1296                                             NULL,
1297                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1298     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1299     EXPECT_EQ(++numExpectedResources, numResources);
1300
1301     OCResourceHandle handle4;
1302     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1303                                             "core.led",
1304                                             "core.rw",
1305                                             "/a/led4",
1306                                             0,
1307                                             NULL,
1308                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1309     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1310     EXPECT_EQ(++numExpectedResources, numResources);
1311
1312     OCResourceHandle handle5;
1313     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1314                                             "core.led",
1315                                             "core.rw",
1316                                             "/a/led5",
1317                                             0,
1318                                             NULL,
1319                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1320     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1321     EXPECT_EQ(++numExpectedResources, numResources);
1322
1323
1324     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1325     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1326     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1327     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1328     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1329     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle5));
1330
1331     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1332     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1333     EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1334     EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1335     EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1336     EXPECT_EQ(handle5, OCGetResourceHandleFromCollection(containerHandle, 5));
1337
1338     EXPECT_EQ(OC_STACK_OK, OCStop());
1339 }
1340
1341
1342 TEST(StackBind, BindEntityHandlerBad)
1343 {
1344     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1345     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1346     InitStack(OC_SERVER);
1347
1348     OCResourceHandle handle;
1349     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1350                                             "core.led",
1351                                             "core.rw",
1352                                             "/a/led",
1353                                             0,
1354                                             NULL,
1355                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1356
1357     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
1358
1359     EXPECT_EQ(OC_STACK_OK, OCStop());
1360 }
1361
1362 TEST(StackBind, BindEntityHandlerGood)
1363 {
1364     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1365     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1366     InitStack(OC_SERVER);
1367
1368     OCResourceHandle handle;
1369     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1370                                             "core.led",
1371                                             "core.rw",
1372                                             "/a/led",
1373                                             0,
1374                                             NULL,
1375                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1376
1377     OCEntityHandler myHandler = entityHandler;
1378
1379     EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
1380
1381     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1382
1383     EXPECT_EQ(OC_STACK_OK, OCStop());
1384 }
1385
1386 TEST(StackResourceAccess, GetResourceByIndex)
1387 {
1388     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1389     OIC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1390     InitStack(OC_SERVER);
1391
1392     uint8_t numResources = 0;
1393     uint8_t numExpectedResources = 0;
1394     uint8_t resourceIndex = 0;
1395     uint8_t prevResources = 0;
1396     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1397     prevResources = numExpectedResources;
1398     OCResourceHandle containerHandle;
1399     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1400                                             "core.led",
1401                                             "core.rw",
1402                                             "/a/kitchen",
1403                                             0,
1404                                             NULL,
1405                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1406     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1407     EXPECT_EQ(++numExpectedResources, numResources);
1408
1409     OCResourceHandle handle0;
1410     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1411                                             "core.led",
1412                                             "core.rw",
1413                                             "/a/led0",
1414                                             0,
1415                                             NULL,
1416                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1417     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1418     EXPECT_EQ(++numExpectedResources, numResources);
1419
1420     OCResourceHandle handle1;
1421     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1422                                             "core.led",
1423                                             "core.rw",
1424                                             "/a/led1",
1425                                             0,
1426                                             NULL,
1427                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1428     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1429     EXPECT_EQ(++numExpectedResources, numResources);
1430
1431     OCResourceHandle handle2;
1432     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1433                                             "core.led",
1434                                             "core.rw",
1435                                             "/a/led2",
1436                                             0,
1437                                             NULL,
1438                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1439     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1440     EXPECT_EQ(++numExpectedResources, numResources);
1441
1442     OCResourceHandle handle3;
1443     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1444                                             "core.led",
1445                                             "core.rw",
1446                                             "/a/led3",
1447                                             0,
1448                                             NULL,
1449                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1450     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1451     EXPECT_EQ(++numExpectedResources, numResources);
1452
1453     OCResourceHandle handle4;
1454     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1455                                             "core.led",
1456                                             "core.rw",
1457                                             "/a/led4",
1458                                             0,
1459                                             NULL,
1460                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1461     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1462     EXPECT_EQ(++numExpectedResources, numResources);
1463
1464     OCResourceHandle handle5;
1465     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1466                                             "core.led",
1467                                             "core.rw",
1468                                             "/a/led5",
1469                                             0,
1470                                             NULL,
1471                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1472     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1473     EXPECT_EQ(++numExpectedResources, numResources);
1474     resourceIndex += prevResources;
1475     EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1476     EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1477     EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1478     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1479     EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1480     EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1481     EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1482
1483     EXPECT_EQ(OC_STACK_OK, OCStop());
1484 }
1485
1486 TEST(StackResourceAccess, DeleteHeadResource)
1487 {
1488     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1489     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1490     InitStack(OC_SERVER);
1491
1492     uint8_t numResources = 0;
1493     uint8_t numExpectedResources = 0;
1494
1495     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1496
1497     OCResourceHandle handle0;
1498     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1499                                             "core.led",
1500                                             "core.rw",
1501                                             "/a/led0",
1502                                             0,
1503                                             NULL,
1504                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1505     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1506     EXPECT_EQ(++numExpectedResources, numResources);
1507
1508     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1509     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1510     EXPECT_EQ(--numExpectedResources, numResources);
1511
1512     EXPECT_EQ(OC_STACK_OK, OCStop());
1513 }
1514
1515 TEST(StackResourceAccess, DeleteHeadResource2)
1516 {
1517     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1518     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1519     InitStack(OC_SERVER);
1520
1521     uint8_t numResources = 0;
1522     uint8_t numExpectedResources = 0;
1523
1524     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1525     OCResourceHandle handle0;
1526     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1527                                             "core.led",
1528                                             "core.rw",
1529                                             "/a/led0",
1530                                             0,
1531                                             NULL,
1532                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1533     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1534     EXPECT_EQ(++numExpectedResources, numResources);
1535
1536     OCResourceHandle handle1;
1537     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1538                                             "core.led",
1539                                             "core.rw",
1540                                             "/a/led1",
1541                                             0,
1542                                             NULL,
1543                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1544     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1545     EXPECT_EQ(++numExpectedResources, numResources);
1546
1547     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1548     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1549     EXPECT_EQ(--numExpectedResources, numResources);
1550
1551     EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
1552
1553     EXPECT_EQ(OC_STACK_OK, OCStop());
1554 }
1555
1556
1557 TEST(StackResourceAccess, DeleteLastResource)
1558 {
1559     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1560     OIC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1561     InitStack(OC_SERVER);
1562
1563     uint8_t numResources = 0;
1564     uint8_t numExpectedResources = 0;
1565
1566     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1567
1568     OCResourceHandle handle0;
1569     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1570                                             "core.led",
1571                                             "core.rw",
1572                                             "/a/led0",
1573                                             0,
1574                                             NULL,
1575                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1576     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1577     EXPECT_EQ(++numExpectedResources, numResources);
1578
1579     OCResourceHandle handle1;
1580     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1581                                             "core.led",
1582                                             "core.rw",
1583                                             "/a/led1",
1584                                             0,
1585                                             NULL,
1586                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1587     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1588     EXPECT_EQ(++numExpectedResources, numResources);
1589
1590     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1591     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1592     EXPECT_EQ(--numExpectedResources, numResources);
1593
1594     EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
1595
1596     OCResourceHandle handle2;
1597     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1598                                             "core.led",
1599                                             "core.rw",
1600                                             "/a/led2",
1601                                             0,
1602                                             NULL,
1603                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1604     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1605     EXPECT_EQ(++numExpectedResources, numResources);
1606
1607     EXPECT_EQ(OC_STACK_OK, OCStop());
1608 }
1609
1610 TEST(StackResourceAccess, DeleteMiddleResource)
1611 {
1612     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1613     OIC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1614     InitStack(OC_SERVER);
1615
1616     uint8_t numResources = 0;
1617     uint8_t numExpectedResources = 0;
1618     uint8_t resourceIndex = InitResourceIndex();
1619
1620     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1621     resourceIndex = numExpectedResources;
1622     OCResourceHandle handle0;
1623     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1624                                             "core.led",
1625                                             "core.rw",
1626                                             "/a/led0",
1627                                             0,
1628                                             NULL,
1629                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1630     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1631     EXPECT_EQ(++numExpectedResources, numResources);
1632
1633     OCResourceHandle handle1;
1634     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1635                                             "core.led",
1636                                             "core.rw",
1637                                             "/a/led1",
1638                                             0,
1639                                             NULL,
1640                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1641     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1642     EXPECT_EQ(++numExpectedResources, numResources);
1643
1644     OCResourceHandle handle2;
1645     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1646                                             "core.led",
1647                                             "core.rw",
1648                                             "/a/led2",
1649                                             0,
1650                                             NULL,
1651                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1652     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1653     EXPECT_EQ(++numExpectedResources, numResources);
1654
1655     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1656     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1657     EXPECT_EQ(--numExpectedResources, numResources);
1658
1659     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1660     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1661
1662     // Make sure the resource elements are still correct
1663     uint8_t numResourceInterfaces;
1664     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1665     EXPECT_EQ(2, numResourceInterfaces);
1666     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 1);
1667     EXPECT_STREQ("core.rw", resourceInterfaceName);
1668
1669     EXPECT_EQ(OC_STACK_OK, OCStop());
1670 }
1671
1672 TEST(PODTests, OCHeaderOption)
1673 {
1674     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1675 }
1676
1677 TEST(PODTests, OCCallbackData)
1678 {
1679     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1680 }
1681
1682 TEST(OCDoDirectPairingTests, Nullpeer)
1683 {
1684     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, NULL, pmSel, &pinNumber, &resultCallback));
1685 }
1686
1687 TEST(OCDoDirectPairingTests, NullCallback)
1688 {
1689     EXPECT_EQ(OC_STACK_INVALID_CALLBACK,OCDoDirectPairing(NULL, &peer, pmSel, &pinNumber, NULL));
1690 }
1691
1692 TEST(OCDoDirectPairingTests, NullpinNumber)
1693 {
1694     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, &peer, pmSel, NULL, &resultCallback));
1695 }
1696
1697 TEST(StackResource, MultipleResourcesDiscovery)
1698 {
1699     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1700     OIC_LOG(INFO, TAG, "Starting MultipleResourcesDiscovery test");
1701     InitStack(OC_SERVER);
1702
1703     OCResourceHandle handle1;
1704     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1705                                             "core.led",
1706                                             "core.rw",
1707                                             "/a/led1",
1708                                             0,
1709                                             NULL,
1710                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1711
1712     OCResourceHandle handle2;
1713     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1714                                             "core.led",
1715                                             "core.rw",
1716                                             "/a/led2",
1717                                             0,
1718                                             NULL,
1719                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1720     OCResourceHandle handle3;
1721     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1722                                             "core.led",
1723                                             "core.rw",
1724                                             "/a/led3",
1725                                             0,
1726                                             NULL,
1727                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1728     /* Start a discovery query*/
1729     char szQueryUri[MAX_QUERY_LENGTH] = "/oic/res?if=oic.if.ll";
1730     OCCallbackData cbData;
1731     cbData.cb = discoveryCallback;
1732     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
1733     cbData.cd = NULL;
1734
1735     OCDoHandle handle;
1736     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
1737                                         OC_REST_DISCOVER,
1738                                         szQueryUri,
1739                                         0,
1740                                         0,
1741                                         CT_ADAPTER_IP,
1742                                         OC_LOW_QOS,
1743                                         &cbData,
1744                                         NULL,
1745                                         0));
1746
1747     EXPECT_EQ(OC_STACK_OK, OCStop());
1748 }