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