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[MAX_QUERY_LENGTH] = { 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[MAX_QUERY_LENGTH] = { 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                                             255));// 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 #ifdef MQ_PUBLISHER
 902     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE|OC_MQ_PUBLISHER, OCGetResourceProperties(handle));
 903 #else
 904     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
 905 #endif
 906     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 907
 908     EXPECT_EQ(OC_STACK_OK, OCStop());
 909 }
 910
 911 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
 912 {
 913     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 914     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
 915     InitStack(OC_SERVER);
 916     uint8_t numResources = 0;
 917     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 918
 919     OCResourceHandle handle;
 920     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 921                                             "core.led",
 922                                             "core.rw",
 923                                             "/a1/led",
 924                                             0,
 925                                             NULL,
 926                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 927     const char *url = OCGetResourceUri(handle);
 928     EXPECT_STREQ("/a1/led", url);
 929
 930     //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
 931     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 932     uint8_t numExpectedResources = 0;
 933
 934     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
 935     EXPECT_EQ(numExpectedResources, numResources);
 936
 937     EXPECT_EQ(OC_STACK_OK, OCStop());
 938 }
 939
 940 TEST(StackResource, StackTestResourceDiscoverOneResource)
 941 {
 942     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 943     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
 944     InitStack(OC_SERVER);
 945
 946     OCResourceHandle handle;
 947     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 948                                             "core.led",
 949                                             "core.rw",
 950                                             "/a/led",
 951                                             0,
 952                                             NULL,
 953                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 954     const char *url = OCGetResourceUri(handle);
 955     EXPECT_STREQ("/a/led", url);
 956
 957     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 958     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 959
 960     EXPECT_EQ(OC_STACK_OK, OCStop());
 961 }
 962
 963 TEST(StackResource, StackTestResourceDiscoverManyResources)
 964 {
 965     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 966     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
 967     InitStack(OC_SERVER);
 968
 969     OCResourceHandle handle1;
 970     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 971                                             "core.led",
 972                                             "core.rw",
 973                                             "/a/led1",
 974                                             0,
 975                                             NULL,
 976                                             OC_DISCOVERABLE));
 977     const char *url = OCGetResourceUri(handle1);
 978     EXPECT_STREQ("/a/led1", url);
 979
 980     OCResourceHandle handle2;
 981     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 982                                             "core.led",
 983                                             "core.rw",
 984                                             "/a/led2",
 985                                             0,
 986                                             NULL,
 987                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 988     url = OCGetResourceUri(handle2);
 989     EXPECT_STREQ("/a/led2", url);
 990
 991     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
 992     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
 993
 994     OCResourceHandle handle3;
 995     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 996                                             "core.led",
 997                                             "core.rw",
 998                                             "/a/led3",
 999                                             0,
1000                                             NULL,
1001                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1002     url = OCGetResourceUri(handle3);
1003     EXPECT_STREQ("/a/led3", url);
1004
1005     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
1006     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
1007
1008     OCResourceHandle handle4;
1009     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1010                                             "core.led",
1011                                             "core.rw",
1012                                             "/a/led4",
1013                                             0,
1014                                             NULL,
1015                                             OC_DISCOVERABLE));
1016     url = OCGetResourceUri(handle4);
1017     EXPECT_STREQ("/a/led4", url);
1018
1019     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
1020     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
1021     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
1022
1023     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1024
1025     EXPECT_EQ(OC_STACK_OK, OCStop());
1026 }
1027
1028 TEST(StackBind, BindResourceTypeNameBad)
1029 {
1030     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1031     OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
1032     InitStack(OC_SERVER);
1033
1034     OCResourceHandle handle;
1035     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1036                                             "core.led",
1037                                             "core.rw",
1038                                             "/a/led",
1039                                             0,
1040                                             NULL,
1041                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1042
1043     uint8_t numResourceTypes;
1044     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1045     EXPECT_EQ(1, numResourceTypes);
1046     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1047     EXPECT_STREQ("core.led", resourceTypeName);
1048
1049     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
1050     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, "core.nameBad"));
1051     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, "core.name bad"));
1052
1053     EXPECT_EQ(OC_STACK_OK, OCStop());
1054 }
1055
1056 TEST(StackBind, BindResourceTypeNameGood)
1057 {
1058     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1059     OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
1060     InitStack(OC_SERVER);
1061
1062     OCResourceHandle handle;
1063     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1064                                             "core.led",
1065                                             "core.rw",
1066                                             "/a/led",
1067                                             0,
1068                                             NULL,
1069                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1070
1071     uint8_t numResourceTypes;
1072     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1073     EXPECT_EQ(1, numResourceTypes);
1074     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1075     EXPECT_STREQ("core.led", resourceTypeName);
1076
1077     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1078     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1079     EXPECT_EQ(2, numResourceTypes);
1080     resourceTypeName = OCGetResourceTypeName(handle, 1);
1081     EXPECT_STREQ("core.brightled", resourceTypeName);
1082
1083     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1084     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1085     EXPECT_EQ(3, numResourceTypes);
1086     resourceTypeName = OCGetResourceTypeName(handle, 2);
1087     EXPECT_STREQ("core.reallybrightled", resourceTypeName);
1088
1089     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "x.ReallyReallyBrightLED"));
1090     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1091     EXPECT_EQ(4, numResourceTypes);
1092     resourceTypeName = OCGetResourceTypeName(handle, 3);
1093     EXPECT_STREQ("x.ReallyReallyBrightLED", resourceTypeName);
1094
1095     EXPECT_EQ(OC_STACK_OK, OCStop());
1096 }
1097
1098 TEST(StackBind, BindResourceTypeAttribRepGood)
1099 {
1100     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1101     OIC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
1102     InitStack(OC_SERVER);
1103
1104     OCResourceHandle handle;
1105     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1106                                             "core.led",
1107                                             "core.rw",
1108                                             "/a/led",
1109                                             0,
1110                                             NULL,
1111                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1112
1113     uint8_t numResourceTypes;
1114     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1115     EXPECT_EQ(1, numResourceTypes);
1116
1117     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1118     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1119     EXPECT_EQ(2, numResourceTypes);
1120
1121     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1122     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1123     EXPECT_EQ(3, numResourceTypes);
1124
1125     EXPECT_EQ(OC_STACK_OK, OCStop());
1126 }
1127
1128
1129 TEST(StackBind, BindResourceInterfaceNameBad)
1130 {
1131     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1132     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
1133     InitStack(OC_SERVER);
1134
1135     OCResourceHandle handle;
1136     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1137                                             "core.led",
1138                                             "core.rw",
1139                                             "/a/led",
1140                                             0,
1141                                             NULL,
1142                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1143
1144     uint8_t numResourceInterfaces;
1145     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1146     EXPECT_EQ(2, numResourceInterfaces);
1147     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1148     EXPECT_STREQ("core.rw", resourceInterfaceName);
1149
1150     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
1151
1152     EXPECT_EQ(OC_STACK_OK, OCStop());
1153 }
1154
1155 TEST(StackBind, BindResourceInterfaceNameGood)
1156 {
1157     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1158     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
1159     InitStack(OC_SERVER);
1160
1161     OCResourceHandle handle;
1162     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1163                                             "core.led",
1164                                             "core.rw",
1165                                             "/a/led",
1166                                             0,
1167                                             NULL,
1168                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1169
1170     uint8_t numResourceInterfaces;
1171     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1172     EXPECT_EQ(2, numResourceInterfaces);
1173     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1174     EXPECT_STREQ("core.rw", resourceInterfaceName);
1175
1176     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1177
1178     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1179     EXPECT_EQ(3, numResourceInterfaces);
1180     resourceInterfaceName = OCGetResourceInterfaceName(handle, 2);
1181     EXPECT_STREQ("core.r", resourceInterfaceName);
1182
1183     EXPECT_EQ(OC_STACK_OK, OCStop());
1184 }
1185
1186 TEST(StackBind, BindResourceInterfaceMethodsBad)
1187 {
1188     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1189     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
1190     InitStack(OC_SERVER);
1191
1192     OCResourceHandle handle;
1193     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1194                                             "core.led",
1195                                             "core.rw",
1196                                             "/a/led",
1197                                             0,
1198                                             NULL,
1199                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1200
1201     uint8_t numResourceInterfaces;
1202     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1203     EXPECT_EQ(2, numResourceInterfaces);
1204
1205     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
1206
1207     EXPECT_EQ(OC_STACK_OK, OCStop());
1208 }
1209
1210 TEST(StackBind, BindResourceInterfaceMethodsGood)
1211 {
1212     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1213     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
1214     InitStack(OC_SERVER);
1215
1216     OCResourceHandle handle;
1217     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1218                                             "core.led",
1219                                             "core.rw",
1220                                             "/a/led",
1221                                             0,
1222                                             NULL,
1223                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1224
1225     uint8_t numResourceInterfaces;
1226     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1227     EXPECT_EQ(2, numResourceInterfaces);
1228
1229     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1230
1231     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1232     EXPECT_EQ(3, numResourceInterfaces);
1233
1234     EXPECT_EQ(OC_STACK_OK, OCStop());
1235 }
1236
1237 TEST(StackBind, BindContainedResourceBad)
1238 {
1239     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1240     OIC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
1241     InitStack(OC_SERVER);
1242
1243     OCResourceHandle containerHandle;
1244     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1245                                             "core.led",
1246                                             "core.rw",
1247                                             "/a/kitchen",
1248                                             0,
1249                                             NULL,
1250                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1251
1252     OCResourceHandle handle0;
1253     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1254                                             "core.led",
1255                                             "core.rw",
1256                                             "/a/led",
1257                                             0,
1258                                             NULL,
1259                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1260
1261     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1262
1263     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1264
1265     EXPECT_EQ(OC_STACK_OK, OCStop());
1266 }
1267
1268 TEST(StackBind, BindContainedResourceGood)
1269 {
1270     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1271     OIC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1272     InitStack(OC_SERVER);
1273
1274     uint8_t numResources = 0;
1275     uint8_t numExpectedResources = 0;
1276
1277     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1278
1279     OCResourceHandle containerHandle;
1280     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1281                                             "core.led",
1282                                             "core.rw",
1283                                             "/a/kitchen",
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 handle0;
1291     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1292                                             "core.led",
1293                                             "core.rw",
1294                                             "/a/led0",
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 handle1;
1302     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1303                                             "core.led",
1304                                             "core.rw",
1305                                             "/a/led1",
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 handle2;
1313     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1314                                             "core.led",
1315                                             "core.rw",
1316                                             "/a/led2",
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 handle3;
1324     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1325                                             "core.led",
1326                                             "core.rw",
1327                                             "/a/led3",
1328                                             0,
1329                                             NULL,
1330                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1331     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1332     EXPECT_EQ(++numExpectedResources, numResources);
1333
1334     OCResourceHandle handle4;
1335     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1336                                             "core.led",
1337                                             "core.rw",
1338                                             "/a/led4",
1339                                             0,
1340                                             NULL,
1341                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1342     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1343     EXPECT_EQ(++numExpectedResources, numResources);
1344
1345     OCResourceHandle handle5;
1346     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1347                                             "core.led",
1348                                             "core.rw",
1349                                             "/a/led5",
1350                                             0,
1351                                             NULL,
1352                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1353     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1354     EXPECT_EQ(++numExpectedResources, numResources);
1355
1356
1357     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1358     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1359     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1360     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1361     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1362     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle5));
1363
1364     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1365     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1366     EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1367     EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1368     EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1369     EXPECT_EQ(handle5, OCGetResourceHandleFromCollection(containerHandle, 5));
1370
1371     EXPECT_EQ(OC_STACK_OK, OCStop());
1372 }
1373
1374
1375 TEST(StackBind, BindEntityHandlerBad)
1376 {
1377     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1378     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1379     InitStack(OC_SERVER);
1380
1381     OCResourceHandle handle;
1382     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1383                                             "core.led",
1384                                             "core.rw",
1385                                             "/a/led",
1386                                             0,
1387                                             NULL,
1388                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1389
1390     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
1391
1392     EXPECT_EQ(OC_STACK_OK, OCStop());
1393 }
1394
1395 TEST(StackBind, BindEntityHandlerGood)
1396 {
1397     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1398     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1399     InitStack(OC_SERVER);
1400
1401     OCResourceHandle handle;
1402     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1403                                             "core.led",
1404                                             "core.rw",
1405                                             "/a/led",
1406                                             0,
1407                                             NULL,
1408                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1409
1410     OCEntityHandler myHandler = entityHandler;
1411
1412     EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
1413
1414     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1415
1416     EXPECT_EQ(OC_STACK_OK, OCStop());
1417 }
1418
1419 TEST(StackResourceAccess, GetResourceByIndex)
1420 {
1421     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1422     OIC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1423     InitStack(OC_SERVER);
1424
1425     uint8_t numResources = 0;
1426     uint8_t numExpectedResources = 0;
1427     uint8_t resourceIndex = 0;
1428     uint8_t prevResources = 0;
1429     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1430     prevResources = numExpectedResources;
1431     OCResourceHandle containerHandle;
1432     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1433                                             "core.led",
1434                                             "core.rw",
1435                                             "/a/kitchen",
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 handle0;
1443     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1444                                             "core.led",
1445                                             "core.rw",
1446                                             "/a/led0",
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 handle1;
1454     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1455                                             "core.led",
1456                                             "core.rw",
1457                                             "/a/led1",
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 handle2;
1465     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1466                                             "core.led",
1467                                             "core.rw",
1468                                             "/a/led2",
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 handle3;
1476     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1477                                             "core.led",
1478                                             "core.rw",
1479                                             "/a/led3",
1480                                             0,
1481                                             NULL,
1482                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1483     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1484     EXPECT_EQ(++numExpectedResources, numResources);
1485
1486     OCResourceHandle handle4;
1487     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1488                                             "core.led",
1489                                             "core.rw",
1490                                             "/a/led4",
1491                                             0,
1492                                             NULL,
1493                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1494     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1495     EXPECT_EQ(++numExpectedResources, numResources);
1496
1497     OCResourceHandle handle5;
1498     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1499                                             "core.led",
1500                                             "core.rw",
1501                                             "/a/led5",
1502                                             0,
1503                                             NULL,
1504                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1505     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1506     EXPECT_EQ(++numExpectedResources, numResources);
1507     resourceIndex += prevResources;
1508     EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1509     EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1510     EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1511     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1512     EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1513     EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1514     EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1515
1516     EXPECT_EQ(OC_STACK_OK, OCStop());
1517 }
1518
1519 TEST(StackResourceAccess, DeleteHeadResource)
1520 {
1521     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1522     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1523     InitStack(OC_SERVER);
1524
1525     uint8_t numResources = 0;
1526     uint8_t numExpectedResources = 0;
1527
1528     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1529
1530     OCResourceHandle handle0;
1531     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1532                                             "core.led",
1533                                             "core.rw",
1534                                             "/a/led0",
1535                                             0,
1536                                             NULL,
1537                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1538     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1539     EXPECT_EQ(++numExpectedResources, numResources);
1540
1541     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1542     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1543     EXPECT_EQ(--numExpectedResources, numResources);
1544
1545     EXPECT_EQ(OC_STACK_OK, OCStop());
1546 }
1547
1548 TEST(StackResourceAccess, DeleteHeadResource2)
1549 {
1550     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1551     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1552     InitStack(OC_SERVER);
1553
1554     uint8_t numResources = 0;
1555     uint8_t numExpectedResources = 0;
1556
1557     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1558     OCResourceHandle handle0;
1559     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1560                                             "core.led",
1561                                             "core.rw",
1562                                             "/a/led0",
1563                                             0,
1564                                             NULL,
1565                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1566     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1567     EXPECT_EQ(++numExpectedResources, numResources);
1568
1569     OCResourceHandle handle1;
1570     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1571                                             "core.led",
1572                                             "core.rw",
1573                                             "/a/led1",
1574                                             0,
1575                                             NULL,
1576                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1577     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1578     EXPECT_EQ(++numExpectedResources, numResources);
1579
1580     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1581     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1582     EXPECT_EQ(--numExpectedResources, numResources);
1583
1584     EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
1585
1586     EXPECT_EQ(OC_STACK_OK, OCStop());
1587 }
1588
1589
1590 TEST(StackResourceAccess, DeleteLastResource)
1591 {
1592     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1593     OIC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1594     InitStack(OC_SERVER);
1595
1596     uint8_t numResources = 0;
1597     uint8_t numExpectedResources = 0;
1598
1599     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1600
1601     OCResourceHandle handle0;
1602     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1603                                             "core.led",
1604                                             "core.rw",
1605                                             "/a/led0",
1606                                             0,
1607                                             NULL,
1608                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1609     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1610     EXPECT_EQ(++numExpectedResources, numResources);
1611
1612     OCResourceHandle handle1;
1613     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1614                                             "core.led",
1615                                             "core.rw",
1616                                             "/a/led1",
1617                                             0,
1618                                             NULL,
1619                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1620     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1621     EXPECT_EQ(++numExpectedResources, numResources);
1622
1623     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1624     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1625     EXPECT_EQ(--numExpectedResources, numResources);
1626
1627     EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
1628
1629     OCResourceHandle handle2;
1630     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1631                                             "core.led",
1632                                             "core.rw",
1633                                             "/a/led2",
1634                                             0,
1635                                             NULL,
1636                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1637     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1638     EXPECT_EQ(++numExpectedResources, numResources);
1639
1640     EXPECT_EQ(OC_STACK_OK, OCStop());
1641 }
1642
1643 TEST(StackResourceAccess, DeleteMiddleResource)
1644 {
1645     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1646     OIC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1647     InitStack(OC_SERVER);
1648
1649     uint8_t numResources = 0;
1650     uint8_t numExpectedResources = 0;
1651     uint8_t resourceIndex = InitResourceIndex();
1652
1653     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1654     resourceIndex = numExpectedResources;
1655     OCResourceHandle handle0;
1656     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1657                                             "core.led",
1658                                             "core.rw",
1659                                             "/a/led0",
1660                                             0,
1661                                             NULL,
1662                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1663     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1664     EXPECT_EQ(++numExpectedResources, numResources);
1665
1666     OCResourceHandle handle1;
1667     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1668                                             "core.led",
1669                                             "core.rw",
1670                                             "/a/led1",
1671                                             0,
1672                                             NULL,
1673                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1674     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1675     EXPECT_EQ(++numExpectedResources, numResources);
1676
1677     OCResourceHandle handle2;
1678     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1679                                             "core.led",
1680                                             "core.rw",
1681                                             "/a/led2",
1682                                             0,
1683                                             NULL,
1684                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1685     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1686     EXPECT_EQ(++numExpectedResources, numResources);
1687
1688     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1689     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1690     EXPECT_EQ(--numExpectedResources, numResources);
1691
1692     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1693     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1694
1695     // Make sure the resource elements are still correct
1696     uint8_t numResourceInterfaces;
1697     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1698     EXPECT_EQ(2, numResourceInterfaces);
1699     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 1);
1700     EXPECT_STREQ("core.rw", resourceInterfaceName);
1701
1702     EXPECT_EQ(OC_STACK_OK, OCStop());
1703 }
1704
1705 // Visual Studio versions earlier than 2015 have bugs in is_pod and report the wrong answer.
1706 #if !defined(_MSC_VER) || (_MSC_VER >= 1900)
1707 TEST(PODTests, OCHeaderOption)
1708 {
1709     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1710 }
1711
1712 TEST(PODTests, OCCallbackData)
1713 {
1714     EXPECT_TRUE(std::is_pod<OCCallbackData>::value);
1715 }
1716 #endif
1717
1718 TEST(OCDoDirectPairingTests, Nullpeer)
1719 {
1720     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, NULL, pmSel, &pinNumber, &resultCallback));
1721 }
1722
1723 TEST(OCDoDirectPairingTests, NullCallback)
1724 {
1725     EXPECT_EQ(OC_STACK_INVALID_CALLBACK,OCDoDirectPairing(NULL, &peer, pmSel, &pinNumber, NULL));
1726 }
1727
1728 TEST(OCDoDirectPairingTests, NullpinNumber)
1729 {
1730     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, &peer, pmSel, NULL, &resultCallback));
1731 }
1732
1733 TEST(StackResource, MultipleResourcesDiscovery)
1734 {
1735     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1736     OIC_LOG(INFO, TAG, "Starting MultipleResourcesDiscovery test");
1737     InitStack(OC_SERVER);
1738
1739     OCResourceHandle handle1;
1740     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1741                                             "core.led",
1742                                             "core.rw",
1743                                             "/a/led1",
1744                                             0,
1745                                             NULL,
1746                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1747
1748     OCResourceHandle handle2;
1749     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1750                                             "core.led",
1751                                             "core.rw",
1752                                             "/a/led2",
1753                                             0,
1754                                             NULL,
1755                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1756     OCResourceHandle handle3;
1757     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1758                                             "core.led",
1759                                             "core.rw",
1760                                             "/a/led3",
1761                                             0,
1762                                             NULL,
1763                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1764     /* Start a discovery query*/
1765     char szQueryUri[MAX_QUERY_LENGTH] = "/oic/res?if=oic.if.ll";
1766     OCCallbackData cbData;
1767     cbData.cb = discoveryCallback;
1768     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
1769     cbData.cd = NULL;
1770
1771     OCDoHandle handle;
1772     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
1773                                         OC_REST_DISCOVER,
1774                                         szQueryUri,
1775                                         0,
1776                                         0,
1777                                         CT_ADAPTER_IP,
1778                                         OC_LOW_QOS,
1779                                         &cbData,
1780                                         NULL,
1781                                         0));
1782
1783     EXPECT_EQ(OC_STACK_OK, OCStop());
1784 }
1785
1786 TEST(StackPayload, CloneByteString)
1787 {
1788     uint8_t bytes[] = { 0, 1, 2, 3 };
1789     OCByteString byteString;
1790     byteString.bytes = bytes;
1791     byteString.len = sizeof(bytes);
1792
1793     OCRepPayload *original = OCRepPayloadCreate();
1794     ASSERT_TRUE(original != NULL);
1795     EXPECT_TRUE(OCRepPayloadSetPropByteString(original, "name", byteString));
1796
1797     OCRepPayload *clone = OCRepPayloadClone(original);
1798     ASSERT_TRUE(clone != NULL);
1799
1800     OCRepPayloadDestroy(original);
1801
1802     OCByteString cloneByteString;
1803     EXPECT_TRUE(OCRepPayloadGetPropByteString(clone, "name", &cloneByteString));
1804     ASSERT_TRUE(cloneByteString.bytes != NULL);
1805     EXPECT_EQ(sizeof(bytes), cloneByteString.len);
1806     EXPECT_TRUE(0 == memcmp(bytes, cloneByteString.bytes, sizeof(bytes)));
1807     OICFree(cloneByteString.bytes);
1808
1809     OCRepPayloadDestroy(clone);
1810 }
1811
1812 TEST(StackUri, Rfc6874_Noop_1)
1813 {
1814     char validIPv6Address[] = "FF01:0:0:0:0:0:0:FB";
1815     char bytes[100] = {0};
1816     strncpy(bytes, validIPv6Address, sizeof(bytes));
1817
1818     OCStackResult result = encodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
1819
1820     // No % sign, should do nothing
1821     EXPECT_STREQ(bytes, validIPv6Address);
1822     EXPECT_EQ(OC_STACK_OK, result);
1823 }
1824
1825 TEST(StackUri, Rfc6874_Noop_2)
1826 {
1827     char validIPv6Address[] = "3812:a61::4:1";
1828     char bytes[100] = {0};
1829
1830     OCStackResult result = encodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
1831
1832     // No % sign, should do nothing
1833     EXPECT_STREQ(bytes, validIPv6Address);
1834     EXPECT_EQ(OC_STACK_OK, result);
1835 }
1836
1837 TEST(StackUri, Rfc6874_WithEncoding)
1838 {
1839     char validIPv6Address[] =        "fe80::dafe:e3ff:fe00:ebfa%wlan0";
1840     char validIPv6AddressEncoded[] = "fe80::dafe:e3ff:fe00:ebfa%25wlan0";
1841     char bytes[100] = "";
1842     strncpy(bytes, validIPv6Address, sizeof(bytes));
1843
1844     OCStackResult result = encodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
1845
1846     // Encoding should have occured
1847     EXPECT_STREQ(bytes, validIPv6AddressEncoded);
1848     EXPECT_EQ(OC_STACK_OK, result);
1849 }
1850
1851 TEST(StackUri, Rfc6874_WithEncoding_ExtraPercent)
1852 {
1853     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%%wlan0";
1854     char bytes[100] = {0};
1855
1856     OCStackResult result = encodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
1857
1858     // Encoding should have failed due to extra '%' character
1859     EXPECT_STREQ(bytes, "");
1860     EXPECT_EQ(OC_STACK_ERROR, result);
1861 }
1862
1863 TEST(StackUri, Rfc6874_AlreadyEncoded)
1864 {
1865     char validIPv6AddressEncoded[] = "fe80::dafe:e3ff:fe00:ebfa%25wlan0";
1866     char bytes[100] = {0};
1867
1868     OCStackResult result = encodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6AddressEncoded);
1869
1870     // Encoding should have failed due to extra '%' character
1871     EXPECT_STREQ(bytes, "");
1872     EXPECT_EQ(OC_STACK_ERROR, result);
1873 }
1874
1875 TEST(StackUri, Rfc6874_NoOverflow)
1876 {
1877     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0";
1878     char addrBuffer[100];
1879     char bytes[100] = {0};
1880     memset(addrBuffer, sizeof(addrBuffer), '_');
1881
1882     // Just enough room to encode
1883     addrBuffer[sizeof(addrBuffer) - sizeof(validIPv6Address) - 3] = '\0';
1884     strcat(addrBuffer, validIPv6Address);
1885
1886     OCStackResult result = encodeAddressForRFC6874(bytes, sizeof(bytes), addrBuffer);
1887
1888     // Encoding should have succeeded
1889     EXPECT_EQ(OC_STACK_OK, result);
1890 }
1891
1892 TEST(StackUri, Rfc6874_NoOverflow_2)
1893 {
1894     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0";
1895     char addrBuffer[100];
1896     char bytes[100] = {0};
1897     memset(addrBuffer, sizeof(addrBuffer), '_');
1898
1899     // Not enough room to encode
1900     addrBuffer[sizeof(addrBuffer) - sizeof(validIPv6Address) - 1] = '\0';
1901     strcat(addrBuffer, validIPv6Address);
1902
1903     OCStackResult result = encodeAddressForRFC6874(bytes, sizeof(bytes), addrBuffer);
1904
1905     // Encoding should have failed due to output size limitations
1906     EXPECT_STREQ(bytes, "");
1907     EXPECT_EQ(OC_STACK_ERROR, result);
1908 }
1909
1910 TEST(StackHeaderOption, setHeaderOption)
1911 {
1912     uint8_t optionValue1[MAX_HEADER_OPTION_DATA_LENGTH] =
1913     { 1 };
1914     OCHeaderOption options[MAX_HEADER_OPTIONS] =
1915     {
1916     { OC_COAP_ID, 6, 8, optionValue1 }, };
1917     uint8_t optionData = 255;
1918     size_t optionDataSize = sizeof(optionData);
1919     size_t numOptions = 1;
1920     uint16_t optionID = 2048;
1921     EXPECT_EQ(OC_STACK_OK, OCSetHeaderOption(options,
1922                                              &numOptions,
1923                                              optionID,
1924                                              &optionData,
1925                                              optionDataSize));
1926     EXPECT_EQ(options[1].optionID, optionID);
1927     EXPECT_EQ(options[1].optionData[0], 255);
1928 }
1929
1930 TEST(StackHeaderOption, getHeaderOption)
1931 {
1932     uint8_t optionValue1[MAX_HEADER_OPTION_DATA_LENGTH] =
1933     { 1 };
1934     uint8_t optionValue2[MAX_HEADER_OPTION_DATA_LENGTH] =
1935     { 255 };
1936     OCHeaderOption options[MAX_HEADER_OPTIONS] =
1937     {
1938     { OC_COAP_ID, 6, 8, optionValue1 },
1939     { OC_COAP_ID, 2048, 16, optionValue2 }, };
1940     uint8_t optionData[MAX_HEADER_OPTION_DATA_LENGTH];
1941     size_t optionDataSize = sizeof(optionData);
1942     size_t numOptions = 2;
1943     uint16_t optionID = 6;
1944     uint16_t actualDataSize = 0;
1945     EXPECT_EQ(OC_STACK_OK, OCGetHeaderOption(options,
1946                                              numOptions,
1947                                              optionID,
1948                                              optionData,
1949                                              optionDataSize,
1950                                              &actualDataSize));
1951     EXPECT_EQ(optionData[0], 1);
1952     EXPECT_EQ(actualDataSize, 8);
1953 }