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