resource/csdk/stack/test/stacktests.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21
  22 extern "C"
  23 {
  24     #include "ocstack.h"
  25     #include "logger.h"
  26     #include "ocmalloc.h"
  27 }
  28
  29 #include "gtest/gtest.h"
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <errno.h>
  33 #include <fcntl.h>
  34 #include <unistd.h>
  35 #include <stdlib.h>
  36
  37 //-----------------------------------------------------------------------------
  38 // Includes
  39 //-----------------------------------------------------------------------------
  40 #include <stdio.h>
  41 #include <string.h>
  42
  43 #include <iostream>
  44 #include <stdint.h>
  45
  46 #include "gtest_helper.h"
  47
  48 using namespace std;
  49
  50 namespace itst = iotivity::test;
  51
  52 #define DEFAULT_CONTEXT_VALUE 0x99
  53
  54 //-----------------------------------------------------------------------------
  55 // Private variables
  56 //-----------------------------------------------------------------------------
  57 static const char TAG[] = "TestHarness";
  58
  59 std::chrono::seconds const SHORT_TEST_TIMEOUT = std::chrono::seconds(5);
  60
  61 //-----------------------------------------------------------------------------
  62 // Callback functions
  63 //-----------------------------------------------------------------------------
  64 extern "C"  OCStackApplicationResult asyncDoResourcesCallback(void* ctx, OCDoHandle handle, OCClientResponse * clientResponse)
  65 {
  66     OC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
  67
  68     EXPECT_EQ(OC_STACK_OK, clientResponse->result);
  69
  70     if(ctx == (void*)DEFAULT_CONTEXT_VALUE) {
  71         OC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
  72     }
  73     OC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
  74
  75     return OC_STACK_KEEP_TRANSACTION;
  76 }
  77
  78 //-----------------------------------------------------------------------------
  79 // Entity handler
  80 //-----------------------------------------------------------------------------
  81 OCEntityHandlerResult entityHandler(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest)
  82 {
  83     OC_LOG(INFO, TAG, "Entering entityHandler");
  84
  85     return OC_EH_OK;
  86 }
  87
  88 //-----------------------------------------------------------------------------
  89 //  Local functions
  90 //-----------------------------------------------------------------------------
  91 void InitStack(OCMode mode)
  92 {
  93     OC_LOG(INFO, TAG, "Entering InitStack");
  94
  95     EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, mode));
  96     OC_LOG(INFO, TAG, "Leaving InitStack");
  97 }
  98
  99 uint8_t InitNumExpectedResources()
 100 {
 101 #ifdef WITH_PRESENCE
 102     // When presence is enabled, it is a resource and so is (currently) included
 103     // in the returned resource count returned by the OCGetNumberOfResources API.
 104     return 1;
 105 #else
 106     return 0;
 107 #endif
 108 }
 109
 110 uint8_t InitResourceIndex()
 111 {
 112 #ifdef WITH_PRESENCE
 113     // When presence is enabled, it is a resource and so is (currently) included
 114     // in the returned resource count returned by the OCGetNumberOfResources API.
 115     // The index of the presence resource is 0, so the first user app resource index
 116     // is 1.
 117     return 1;
 118 #else
 119     return 0;
 120 #endif
 121 }
 122 //-----------------------------------------------------------------------------
 123 //  Tests
 124 //-----------------------------------------------------------------------------
 125
 126 TEST(StackInit, StackInitNullAddr)
 127 {
 128     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 129     EXPECT_EQ(OC_STACK_OK, OCInit(0, 5683, OC_SERVER));
 130     EXPECT_EQ(OC_STACK_OK, OCStop());
 131 }
 132
 133 TEST(StackInit, StackInitNullPort)
 134 {
 135     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 136     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 0, OC_SERVER));
 137     EXPECT_EQ(OC_STACK_OK, OCStop());
 138 }
 139
 140 TEST(StackInit, StackInitNullAddrAndPort)
 141 {
 142     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 143     EXPECT_EQ(OC_STACK_OK, OCInit(0, 0, OC_SERVER));
 144     EXPECT_EQ(OC_STACK_OK, OCStop());
 145 }
 146
 147 TEST(StackInit, StackInitInvalidMode)
 148 {
 149     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 150     EXPECT_EQ(OC_STACK_ERROR, OCInit(0, 0, (OCMode)10));
 151     EXPECT_EQ(OC_STACK_ERROR, OCStop());
 152 }
 153
 154 TEST(StackStart, StackStartSuccessClient)
 155 {
 156     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 157     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 158     EXPECT_EQ(OC_STACK_OK, OCStop());
 159 }
 160
 161 TEST(StackStart, StackStartSuccessServer)
 162 {
 163     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 164     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 165     EXPECT_EQ(OC_STACK_OK, OCStop());
 166 }
 167
 168 TEST(StackStart, StackStartSuccessClientServer)
 169 {
 170     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 171     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
 172     EXPECT_EQ(OC_STACK_OK, OCStop());
 173 }
 174
 175 TEST(StackStart, StackStartSuccessiveInits)
 176 {
 177     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 178     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 179     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.2", 5683, OC_SERVER));
 180     EXPECT_EQ(OC_STACK_OK, OCStop());
 181 }
 182
 183 TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery)
 184 {
 185     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 186     OCCallbackData cbData;
 187     OCDoHandle handle;
 188
 189     OC_LOG(INFO, TAG, "Starting DoResourceDeviceDiscovery test ");
 190     InitStack(OC_CLIENT);
 191
 192     /* Start a discovery query*/
 193     char szQueryUri[64] = { 0 };
 194     strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
 195     cbData.cb = asyncDoResourcesCallback;
 196     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 197     cbData.cd = NULL;
 198     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
 199                                         OC_REST_GET,
 200                                         szQueryUri,
 201                                         0,
 202                                         0,
 203                                         OC_IPV4,
 204                                         OC_LOW_QOS,
 205                                         &cbData,
 206                                         NULL,
 207                                         0));
 208     EXPECT_EQ(OC_STACK_OK, OCStop());
 209 }
 210
 211 TEST(StackStop, StackStopWithoutInit)
 212 {
 213     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 214     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 215     EXPECT_EQ(OC_STACK_OK, OCStop());
 216     EXPECT_EQ(OC_STACK_ERROR, OCStop());
 217 }
 218
 219 TEST(StackResource, DISABLED_UpdateResourceNullURI)
 220 {
 221     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 222     OCCallbackData cbData;
 223     OCDoHandle handle;
 224
 225     OC_LOG(INFO, TAG, "Starting UpdateResourceNullURI test");
 226     InitStack(OC_CLIENT);
 227
 228     /* Start a discovery query*/
 229     char szQueryUri[64] = { 0 };
 230     strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
 231     cbData.cb = asyncDoResourcesCallback;
 232     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 233     cbData.cd = NULL;
 234     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
 235                                         OC_REST_GET,
 236                                         szQueryUri,
 237                                         0,
 238                                         0,
 239                                         OC_IPV4,
 240                                         OC_LOW_QOS,
 241                                         &cbData,
 242                                         NULL,
 243                                         0));
 244     EXPECT_EQ(OC_STACK_OK, OCStop());
 245 }
 246
 247 TEST(StackResource, CreateResourceBadParams)
 248 {
 249     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 250     OC_LOG(INFO, TAG, "Starting CreateResourceBadParams test");
 251     InitStack(OC_SERVER);
 252
 253     OCResourceHandle handle;
 254
 255     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(NULL, //&handle,
 256                                             "core.led",
 257                                             "core.rw",
 258                                             "/a/led",
 259                                             0,
 260                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 261
 262     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 263                                             NULL, //"core.led",
 264                                             "core.rw",
 265                                             "/a/led",
 266                                             0,
 267                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 268
 269     // Property bitmask out of range
 270     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 271                                             "core.led",
 272                                             "core.rw",
 273                                             "/a/led",
 274                                             0,
 275                                             128));// invalid bitmask for OCResourceProperty
 276
 277     EXPECT_EQ(OC_STACK_OK, OCStop());
 278 }
 279
 280
 281 TEST(StackResource, CreateResourceSuccess)
 282 {
 283     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 284     OC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
 285     InitStack(OC_SERVER);
 286
 287     OCResourceHandle handle;
 288     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 289                                             "core.led",
 290                                             "core.rw",
 291                                             "/a/led",
 292                                             0,
 293                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 294     const char *url = OCGetResourceUri(handle);
 295     EXPECT_STREQ("/a/led", url);
 296
 297     EXPECT_EQ(OC_STACK_OK, OCStop());
 298 }
 299
 300 TEST(StackResource, CreateResourceFailDuplicateUri)
 301 {
 302     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 303     OC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
 304     InitStack(OC_SERVER);
 305
 306     OCResourceHandle handle;
 307     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 308                                             "core.led",
 309                                             "core.rw",
 310                                             "/a/led",
 311                                             0,
 312                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 313     const char *url = OCGetResourceUri(handle);
 314     EXPECT_STREQ("/a/led", url);
 315
 316     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 317                                             "core.led",
 318                                             "core.rw",
 319                                             "/a/led",
 320                                             0,
 321                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 322
 323     EXPECT_EQ(OC_STACK_OK, OCStop());
 324 }
 325
 326 TEST(StackResource, CreateResourceMultipleResources)
 327 {
 328     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 329     OC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
 330     InitStack(OC_SERVER);
 331
 332     OCResourceHandle handle1;
 333     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 334                                             "core.led",
 335                                             "core.rw",
 336                                             "/a/led1",
 337                                             0,
 338                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 339
 340     OCResourceHandle handle2;
 341     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 342                                             "core.led",
 343                                             "core.rw",
 344                                             "/a/led2",
 345                                             0,
 346                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 347     OCResourceHandle handle3;
 348     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 349                                             "core.led",
 350                                             "core.rw",
 351                                             "/a/led3",
 352                                             0,
 353                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 354
 355     const char *url = OCGetResourceUri(handle1);
 356     EXPECT_STREQ("/a/led1", url);
 357
 358     url = OCGetResourceUri(handle2);
 359     EXPECT_STREQ("/a/led2", url);
 360
 361     url = OCGetResourceUri(handle3);
 362     EXPECT_STREQ("/a/led3", url);
 363
 364     EXPECT_EQ(OC_STACK_OK, OCStop());
 365 }
 366
 367 TEST(StackResource, CreateResourceBadResoureType)
 368 {
 369     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 370     OC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
 371     InitStack(OC_SERVER);
 372
 373     OCResourceHandle handle;
 374     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 375                                             NULL, //"core.led",
 376                                             "core.rw",
 377                                             "/a/led",
 378                                             0,
 379                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 380
 381     EXPECT_EQ(OC_STACK_OK, OCStop());
 382 }
 383
 384 TEST(StackResource, CreateResourceGoodResourceType)
 385 {
 386     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 387     OC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
 388     InitStack(OC_SERVER);
 389
 390     OCResourceHandle handle;
 391     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 392                                             "core.led",
 393                                             "core.rw",
 394                                             "/a/led",
 395                                             0,
 396                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 397
 398     EXPECT_EQ(OC_STACK_OK, OCStop());
 399 }
 400
 401 TEST(StackResource, ResourceTypeName)
 402 {
 403     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 404     OC_LOG(INFO, TAG, "Starting ResourceTypeName test");
 405     InitStack(OC_SERVER);
 406
 407     OCResourceHandle handle;
 408     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 409                                             "core.led",
 410                                             "core.rw",
 411                                             "/a/led",
 412                                             0,
 413                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 414
 415     uint8_t numResourceTypes;
 416     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 417     EXPECT_EQ(1, numResourceTypes);
 418     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 419     EXPECT_STREQ("core.led", resourceTypeName);
 420
 421     // try getting resource type names with an invalid index
 422     resourceTypeName = OCGetResourceTypeName(handle, 1);
 423     EXPECT_STREQ(NULL, resourceTypeName);
 424     // try getting resource type names with an invalid index
 425     resourceTypeName = OCGetResourceTypeName(handle, 10);
 426     EXPECT_STREQ(NULL, resourceTypeName);
 427
 428     EXPECT_EQ(OC_STACK_OK, OCStop());
 429 }
 430
 431 TEST(StackResource, ResourceTypeAttrRepresentation)
 432 {
 433     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 434     OC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
 435     InitStack(OC_SERVER);
 436
 437     OCResourceHandle handle;
 438     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 439                                             "core.led",
 440                                             "core.rw",
 441                                             "/a/led",
 442                                             0,
 443                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 444
 445     uint8_t numResourceTypes;
 446     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 447     EXPECT_EQ(1, numResourceTypes);
 448
 449     EXPECT_EQ(OC_STACK_OK, OCStop());
 450 }
 451
 452 TEST(StackResource, ResourceTypeInterface)
 453 {
 454     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 455     OC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
 456     InitStack(OC_SERVER);
 457
 458     OCResourceHandle handle;
 459     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 460                                             "core.led",
 461                                             "core.rw",
 462                                             "/a/led",
 463                                             0,
 464                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 465
 466     uint8_t numResourceInterfaces;
 467     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 468     EXPECT_EQ(1, numResourceInterfaces);
 469     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 470     EXPECT_STREQ("core.rw", resourceInterfaceName);
 471
 472     // try getting resource interface names with an invalid index
 473     resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
 474     EXPECT_STREQ(NULL, resourceInterfaceName);
 475     // try getting resource interface names with an invalid index
 476     resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
 477     EXPECT_STREQ(NULL, resourceInterfaceName);
 478
 479     EXPECT_EQ(OC_STACK_OK, OCStop());
 480 }
 481
 482 TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
 483 {
 484     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 485
 486     OC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
 487
 488     InitStack(OC_SERVER);
 489
 490     OCResourceHandle handle;
 491     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 492                                             "core.led",
 493                                             "core.rw",
 494                                             "/a/led",
 495                                             0,
 496                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 497     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 498                                         OC_RSRVD_INTERFACE_DEFAULT));
 499     uint8_t numResourceInterfaces;
 500     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 501     EXPECT_EQ(2, numResourceInterfaces);
 502
 503     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
 504     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
 505
 506     const char*interfaceName_2 = OCGetResourceInterfaceName(handle, 1);
 507     EXPECT_STREQ("core.rw", interfaceName_2);
 508
 509     EXPECT_EQ(OC_STACK_OK, OCStop());
 510 }
 511
 512 TEST(StackResource, ResourceDuplicateDefaultInterfaces)
 513 {
 514     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 515
 516     OC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
 517
 518     InitStack(OC_SERVER);
 519
 520     OCResourceHandle handle;
 521     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 522                                             "core.led",
 523                                             "core.rw",
 524                                             "/a/led",
 525                                             0,
 526                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 527
 528     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 529                                         OC_RSRVD_INTERFACE_DEFAULT));
 530     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 531                                         OC_RSRVD_INTERFACE_DEFAULT));
 532
 533     uint8_t numResourceInterfaces;
 534     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 535     EXPECT_EQ(2, numResourceInterfaces);
 536
 537     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
 538     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
 539
 540     EXPECT_EQ(OC_STACK_OK, OCStop());
 541 }
 542
 543 TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
 544 {
 545     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 546
 547     OC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
 548
 549     InitStack(OC_SERVER);
 550
 551     OCResourceHandle handle;
 552     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 553                                             "core.led",
 554                                             "core.rw",
 555                                             "/a/led",
 556                                             0,
 557                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 558
 559     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 560                                         "core.rw"));
 561     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 562                                         "core.rw"));
 563
 564     uint8_t numResourceInterfaces;
 565     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 566     EXPECT_EQ(1, numResourceInterfaces);
 567
 568     EXPECT_EQ(OC_STACK_OK, OCStop());
 569 }
 570
 571 TEST(StackResource, ResourceTypeInterfaceMethods)
 572 {
 573     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 574     OC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
 575     InitStack(OC_SERVER);
 576
 577     OCResourceHandle handle;
 578     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 579                                             "core.led",
 580                                             "core.rw",
 581                                             "/a/led",
 582                                             0,
 583                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 584
 585     uint8_t numResourceInterfaces;
 586     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 587     EXPECT_EQ(1, numResourceInterfaces);
 588
 589     EXPECT_EQ(OC_STACK_OK, OCStop());
 590 }
 591
 592 TEST(StackResource, GetResourceProperties)
 593 {
 594     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 595     OC_LOG(INFO, TAG, "Starting GetResourceProperties test");
 596     InitStack(OC_SERVER);
 597
 598     OCResourceHandle handle;
 599     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 600                                             "core.led",
 601                                             "core.rw",
 602                                             "/a/led",
 603                                             0,
 604                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 605
 606     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
 607     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 608
 609     EXPECT_EQ(OC_STACK_OK, OCStop());
 610 }
 611
 612 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
 613 {
 614     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 615     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
 616     InitStack(OC_SERVER);
 617
 618     OCResourceHandle handle;
 619     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 620                                             "core.led",
 621                                             "core.rw",
 622                                             "/a1/led",
 623                                             0,
 624                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 625     const char *url = OCGetResourceUri(handle);
 626     EXPECT_STREQ("/a1/led", url);
 627
 628     //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
 629     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 630     uint8_t numResources = 0;
 631     uint8_t numExpectedResources = InitNumExpectedResources();
 632
 633     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 634     EXPECT_EQ(numExpectedResources, numResources);
 635
 636     EXPECT_EQ(OC_STACK_OK, OCStop());
 637 }
 638
 639 TEST(StackResource, StackTestResourceDiscoverOneResource)
 640 {
 641     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 642     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
 643     InitStack(OC_SERVER);
 644
 645     OCResourceHandle handle;
 646     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 647                                             "core.led",
 648                                             "core.rw",
 649                                             "/a/led",
 650                                             0,
 651                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 652     const char *url = OCGetResourceUri(handle);
 653     EXPECT_STREQ("/a/led", url);
 654
 655     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 656     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 657
 658     EXPECT_EQ(OC_STACK_OK, OCStop());
 659 }
 660
 661 TEST(StackResource, StackTestResourceDiscoverManyResources)
 662 {
 663     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 664     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
 665     InitStack(OC_SERVER);
 666
 667     OCResourceHandle handle1;
 668     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 669                                             "core.led",
 670                                             "core.rw",
 671                                             "/a/led1",
 672                                             0,
 673                                             OC_DISCOVERABLE));
 674     const char *url = OCGetResourceUri(handle1);
 675     EXPECT_STREQ("/a/led1", url);
 676
 677     OCResourceHandle handle2;
 678     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 679                                             "core.led",
 680                                             "core.rw",
 681                                             "/a/led2",
 682                                             0,
 683                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 684     url = OCGetResourceUri(handle2);
 685     EXPECT_STREQ("/a/led2", url);
 686
 687     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
 688     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
 689
 690     OCResourceHandle handle3;
 691     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 692                                             "core.led",
 693                                             "core.rw",
 694                                             "/a/led3",
 695                                             0,
 696                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 697     url = OCGetResourceUri(handle3);
 698     EXPECT_STREQ("/a/led3", url);
 699
 700     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
 701     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
 702
 703     OCResourceHandle handle4;
 704     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
 705                                             "core.led",
 706                                             "core.rw",
 707                                             "/a/led4",
 708                                             0,
 709                                             OC_DISCOVERABLE));
 710     url = OCGetResourceUri(handle4);
 711     EXPECT_STREQ("/a/led4", url);
 712
 713     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
 714     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
 715     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
 716
 717     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 718
 719     EXPECT_EQ(OC_STACK_OK, OCStop());
 720 }
 721
 722 TEST(StackBind, BindResourceTypeNameBad)
 723 {
 724     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 725     OC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
 726     InitStack(OC_SERVER);
 727
 728     OCResourceHandle handle;
 729     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 730                                             "core.led",
 731                                             "core.rw",
 732                                             "/a/led",
 733                                             0,
 734                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 735
 736     uint8_t numResourceTypes;
 737     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 738     EXPECT_EQ(1, numResourceTypes);
 739     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 740     EXPECT_STREQ("core.led", resourceTypeName);
 741
 742     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
 743
 744     EXPECT_EQ(OC_STACK_OK, OCStop());
 745 }
 746
 747 TEST(StackBind, BindResourceTypeNameGood)
 748 {
 749     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 750     OC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
 751     InitStack(OC_SERVER);
 752
 753     OCResourceHandle handle;
 754     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 755                                             "core.led",
 756                                             "core.rw",
 757                                             "/a/led",
 758                                             0,
 759                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 760
 761     uint8_t numResourceTypes;
 762     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 763     EXPECT_EQ(1, numResourceTypes);
 764     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 765     EXPECT_STREQ("core.led", resourceTypeName);
 766
 767     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
 768     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 769     EXPECT_EQ(2, numResourceTypes);
 770     resourceTypeName = OCGetResourceTypeName(handle, 1);
 771     EXPECT_STREQ("core.brightled", resourceTypeName);
 772
 773     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
 774     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 775     EXPECT_EQ(3, numResourceTypes);
 776     resourceTypeName = OCGetResourceTypeName(handle, 2);
 777     EXPECT_STREQ("core.reallybrightled", resourceTypeName);
 778
 779     EXPECT_EQ(OC_STACK_OK, OCStop());
 780 }
 781
 782 TEST(StackBind, BindResourceTypeAttribRepGood)
 783 {
 784     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 785     OC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
 786     InitStack(OC_SERVER);
 787
 788     OCResourceHandle handle;
 789     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 790                                             "core.led",
 791                                             "core.rw",
 792                                             "/a/led",
 793                                             0,
 794                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 795
 796     uint8_t numResourceTypes;
 797     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 798     EXPECT_EQ(1, numResourceTypes);
 799
 800     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
 801     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 802     EXPECT_EQ(2, numResourceTypes);
 803
 804     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
 805     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 806     EXPECT_EQ(3, numResourceTypes);
 807
 808     EXPECT_EQ(OC_STACK_OK, OCStop());
 809 }
 810
 811
 812 TEST(StackBind, BindResourceInterfaceNameBad)
 813 {
 814     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 815     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
 816     InitStack(OC_SERVER);
 817
 818     OCResourceHandle handle;
 819     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 820                                             "core.led",
 821                                             "core.rw",
 822                                             "/a/led",
 823                                             0,
 824                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 825
 826     uint8_t numResourceInterfaces;
 827     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 828     EXPECT_EQ(1, numResourceInterfaces);
 829     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 830     EXPECT_STREQ("core.rw", resourceInterfaceName);
 831
 832     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
 833
 834     EXPECT_EQ(OC_STACK_OK, OCStop());
 835 }
 836
 837 TEST(StackBind, BindResourceInterfaceNameGood)
 838 {
 839     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 840     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
 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                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 850
 851     uint8_t numResourceInterfaces;
 852     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 853     EXPECT_EQ(1, numResourceInterfaces);
 854     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 855     EXPECT_STREQ("core.rw", resourceInterfaceName);
 856
 857     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
 858
 859     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 860     EXPECT_EQ(2, numResourceInterfaces);
 861     resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
 862     EXPECT_STREQ("core.r", resourceInterfaceName);
 863
 864     EXPECT_EQ(OC_STACK_OK, OCStop());
 865 }
 866
 867 TEST(StackBind, BindResourceInterfaceMethodsBad)
 868 {
 869     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 870     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
 871     InitStack(OC_SERVER);
 872
 873     OCResourceHandle handle;
 874     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 875                                             "core.led",
 876                                             "core.rw",
 877                                             "/a/led",
 878                                             0,
 879                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 880
 881     uint8_t numResourceInterfaces;
 882     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 883     EXPECT_EQ(1, numResourceInterfaces);
 884
 885     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
 886
 887     EXPECT_EQ(OC_STACK_OK, OCStop());
 888 }
 889
 890 TEST(StackBind, BindResourceInterfaceMethodsGood)
 891 {
 892     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 893     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
 894     InitStack(OC_SERVER);
 895
 896     OCResourceHandle handle;
 897     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 898                                             "core.led",
 899                                             "core.rw",
 900                                             "/a/led",
 901                                             0,
 902                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 903
 904     uint8_t numResourceInterfaces;
 905     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 906     EXPECT_EQ(1, numResourceInterfaces);
 907
 908     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
 909
 910     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 911     EXPECT_EQ(2, numResourceInterfaces);
 912
 913     EXPECT_EQ(OC_STACK_OK, OCStop());
 914 }
 915
 916 TEST(StackBind, BindContainedResourceBad)
 917 {
 918     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 919     OC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
 920     InitStack(OC_SERVER);
 921
 922     OCResourceHandle containerHandle;
 923     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
 924                                             "core.led",
 925                                             "core.rw",
 926                                             "/a/kitchen",
 927                                             0,
 928                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 929
 930     OCResourceHandle handle0;
 931     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
 932                                             "core.led",
 933                                             "core.rw",
 934                                             "/a/led",
 935                                             0,
 936                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 937
 938     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
 939
 940     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
 941
 942     EXPECT_EQ(OC_STACK_OK, OCStop());
 943 }
 944
 945 TEST(StackBind, BindContainedResourceGood)
 946 {
 947     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 948     OC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
 949     InitStack(OC_SERVER);
 950
 951     uint8_t numResources = 0;
 952     uint8_t numExpectedResources = InitNumExpectedResources();
 953
 954     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 955     EXPECT_EQ(numExpectedResources, numResources);
 956
 957     OCResourceHandle containerHandle;
 958     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
 959                                             "core.led",
 960                                             "core.rw",
 961                                             "/a/kitchen",
 962                                             0,
 963                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 964     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 965     EXPECT_EQ(++numExpectedResources, numResources);
 966
 967     OCResourceHandle handle0;
 968     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
 969                                             "core.led",
 970                                             "core.rw",
 971                                             "/a/led0",
 972                                             0,
 973                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 974     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 975     EXPECT_EQ(++numExpectedResources, numResources);
 976
 977     OCResourceHandle handle1;
 978     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 979                                             "core.led",
 980                                             "core.rw",
 981                                             "/a/led1",
 982                                             0,
 983                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 984     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 985     EXPECT_EQ(++numExpectedResources, numResources);
 986
 987     OCResourceHandle handle2;
 988     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 989                                             "core.led",
 990                                             "core.rw",
 991                                             "/a/led2",
 992                                             0,
 993                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 994     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 995     EXPECT_EQ(++numExpectedResources, numResources);
 996
 997     OCResourceHandle handle3;
 998     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 999                                             "core.led",
1000                                             "core.rw",
1001                                             "/a/led3",
1002                                             0,
1003                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1004     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1005     EXPECT_EQ(++numExpectedResources, numResources);
1006
1007     OCResourceHandle handle4;
1008     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1009                                             "core.led",
1010                                             "core.rw",
1011                                             "/a/led4",
1012                                             0,
1013                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1014     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1015     EXPECT_EQ(++numExpectedResources, numResources);
1016
1017     OCResourceHandle handle5;
1018     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1019                                             "core.led",
1020                                             "core.rw",
1021                                             "/a/led5",
1022                                             0,
1023                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1024     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1025     EXPECT_EQ(++numExpectedResources, numResources);
1026
1027
1028     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1029     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1030     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1031     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1032     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1033     EXPECT_EQ(OC_STACK_ERROR, OCBindResource(containerHandle, handle5));
1034
1035     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1036     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1037     EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1038     EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1039     EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1040
1041     EXPECT_EQ(NULL, OCGetResourceHandleFromCollection(containerHandle, 5));
1042
1043     EXPECT_EQ(OC_STACK_OK, OCStop());
1044 }
1045
1046
1047 TEST(StackBind, BindEntityHandlerBad)
1048 {
1049     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1050     OC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1051     InitStack(OC_SERVER);
1052
1053     OCResourceHandle handle;
1054     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1055                                             "core.led",
1056                                             "core.rw",
1057                                             "/a/led",
1058                                             0,
1059                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1060
1061     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL));
1062
1063     EXPECT_EQ(OC_STACK_OK, OCStop());
1064 }
1065
1066 TEST(StackBind, BindEntityHandlerGood)
1067 {
1068     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1069     OC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1070     InitStack(OC_SERVER);
1071
1072     OCResourceHandle handle;
1073     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1074                                             "core.led",
1075                                             "core.rw",
1076                                             "/a/led",
1077                                             0,
1078                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1079
1080     OCEntityHandler myHandler = entityHandler;
1081
1082     EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler));
1083
1084     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1085
1086     EXPECT_EQ(OC_STACK_OK, OCStop());
1087 }
1088
1089 TEST(StackResourceAccess, GetResourceByIndex)
1090 {
1091     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1092     OC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1093     InitStack(OC_SERVER);
1094
1095     uint8_t numResources = 0;
1096     uint8_t numExpectedResources = InitNumExpectedResources();
1097     uint8_t resourceIndex = InitResourceIndex();
1098
1099     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1100     EXPECT_EQ(numExpectedResources, numResources);
1101
1102     OCResourceHandle containerHandle;
1103     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1104                                             "core.led",
1105                                             "core.rw",
1106                                             "/a/kitchen",
1107                                             0,
1108                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1109     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1110     EXPECT_EQ(++numExpectedResources, numResources);
1111
1112     OCResourceHandle handle0;
1113     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1114                                             "core.led",
1115                                             "core.rw",
1116                                             "/a/led0",
1117                                             0,
1118                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1119     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1120     EXPECT_EQ(++numExpectedResources, numResources);
1121
1122     OCResourceHandle handle1;
1123     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1124                                             "core.led",
1125                                             "core.rw",
1126                                             "/a/led1",
1127                                             0,
1128                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1129     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1130     EXPECT_EQ(++numExpectedResources, numResources);
1131
1132     OCResourceHandle handle2;
1133     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1134                                             "core.led",
1135                                             "core.rw",
1136                                             "/a/led2",
1137                                             0,
1138                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1139     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1140     EXPECT_EQ(++numExpectedResources, numResources);
1141
1142     OCResourceHandle handle3;
1143     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1144                                             "core.led",
1145                                             "core.rw",
1146                                             "/a/led3",
1147                                             0,
1148                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1149     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1150     EXPECT_EQ(++numExpectedResources, numResources);
1151
1152     OCResourceHandle handle4;
1153     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1154                                             "core.led",
1155                                             "core.rw",
1156                                             "/a/led4",
1157                                             0,
1158                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1159     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1160     EXPECT_EQ(++numExpectedResources, numResources);
1161
1162     OCResourceHandle handle5;
1163     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1164                                             "core.led",
1165                                             "core.rw",
1166                                             "/a/led5",
1167                                             0,
1168                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1169     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1170     EXPECT_EQ(++numExpectedResources, numResources);
1171
1172     EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1173     EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1174     EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1175     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1176     EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1177     EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1178     EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1179
1180     EXPECT_EQ(OC_STACK_OK, OCStop());
1181 }
1182
1183 TEST(StackResourceAccess, DeleteHeadResource)
1184 {
1185     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1186     OC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1187     InitStack(OC_SERVER);
1188
1189     uint8_t numResources = 0;
1190     uint8_t numExpectedResources = InitNumExpectedResources();
1191
1192     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1193     EXPECT_EQ(numExpectedResources, numResources);
1194
1195     OCResourceHandle handle0;
1196     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1197                                             "core.led",
1198                                             "core.rw",
1199                                             "/a/led0",
1200                                             0,
1201                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1202     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1203     EXPECT_EQ(++numExpectedResources, numResources);
1204
1205     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1206     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1207     EXPECT_EQ(--numExpectedResources, numResources);
1208
1209     EXPECT_EQ(OC_STACK_OK, OCStop());
1210 }
1211
1212 TEST(StackResourceAccess, DeleteHeadResource2)
1213 {
1214     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1215     OC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1216     InitStack(OC_SERVER);
1217
1218     uint8_t numResources = 0;
1219     uint8_t numExpectedResources = InitNumExpectedResources();
1220     uint8_t resourceIndex = InitResourceIndex();
1221
1222     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1223     EXPECT_EQ(numExpectedResources, numResources);
1224
1225     OCResourceHandle handle0;
1226     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1227                                             "core.led",
1228                                             "core.rw",
1229                                             "/a/led0",
1230                                             0,
1231                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1232     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1233     EXPECT_EQ(++numExpectedResources, numResources);
1234
1235     OCResourceHandle handle1;
1236     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1237                                             "core.led",
1238                                             "core.rw",
1239                                             "/a/led1",
1240                                             0,
1241                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1242     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1243     EXPECT_EQ(++numExpectedResources, numResources);
1244
1245     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1246     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1247     EXPECT_EQ(--numExpectedResources, numResources);
1248
1249     EXPECT_EQ(handle1, OCGetResourceHandle(resourceIndex));
1250
1251     EXPECT_EQ(OC_STACK_OK, OCStop());
1252 }
1253
1254
1255 TEST(StackResourceAccess, DeleteLastResource)
1256 {
1257     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1258     OC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1259     InitStack(OC_SERVER);
1260
1261     uint8_t numResources = 0;
1262     uint8_t numExpectedResources = InitNumExpectedResources();
1263     uint8_t resourceIndex = InitResourceIndex();
1264
1265     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1266     EXPECT_EQ(numExpectedResources, numResources);
1267
1268     OCResourceHandle handle0;
1269     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1270                                             "core.led",
1271                                             "core.rw",
1272                                             "/a/led0",
1273                                             0,
1274                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1275     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1276     EXPECT_EQ(++numExpectedResources, numResources);
1277
1278     OCResourceHandle handle1;
1279     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1280                                             "core.led",
1281                                             "core.rw",
1282                                             "/a/led1",
1283                                             0,
1284                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1285     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1286     EXPECT_EQ(++numExpectedResources, numResources);
1287
1288     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1289     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1290     EXPECT_EQ(--numExpectedResources, numResources);
1291
1292     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1293
1294     OCResourceHandle handle2;
1295     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1296                                             "core.led",
1297                                             "core.rw",
1298                                             "/a/led2",
1299                                             0,
1300                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1301     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1302     EXPECT_EQ(++numExpectedResources, numResources);
1303
1304     EXPECT_EQ(OC_STACK_OK, OCStop());
1305 }
1306
1307 TEST(StackResourceAccess, DeleteMiddleResource)
1308 {
1309     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1310     OC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1311     InitStack(OC_SERVER);
1312
1313     uint8_t numResources = 0;
1314     uint8_t numExpectedResources = InitNumExpectedResources();
1315     uint8_t resourceIndex = InitResourceIndex();
1316
1317     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1318     EXPECT_EQ(numExpectedResources, numResources);
1319
1320     OCResourceHandle handle0;
1321     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1322                                             "core.led",
1323                                             "core.rw",
1324                                             "/a/led0",
1325                                             0,
1326                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1327     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1328     EXPECT_EQ(++numExpectedResources, numResources);
1329
1330     OCResourceHandle handle1;
1331     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1332                                             "core.led",
1333                                             "core.rw",
1334                                             "/a/led1",
1335                                             0,
1336                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1337     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1338     EXPECT_EQ(++numExpectedResources, numResources);
1339
1340     OCResourceHandle handle2;
1341     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1342                                             "core.led",
1343                                             "core.rw",
1344                                             "/a/led2",
1345                                             0,
1346                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1347     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1348     EXPECT_EQ(++numExpectedResources, numResources);
1349
1350     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1351     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1352     EXPECT_EQ(--numExpectedResources, numResources);
1353
1354     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1355     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1356
1357     // Make sure the resource elements are still correct
1358     uint8_t numResourceInterfaces;
1359     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1360     EXPECT_EQ(1, numResourceInterfaces);
1361     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0);
1362     EXPECT_STREQ("core.rw", resourceInterfaceName);
1363
1364     EXPECT_EQ(OC_STACK_OK, OCStop());
1365 }
1366
1367
1368 #ifdef __cplusplus
1369 extern "C" {
1370 #endif // __cplusplus
1371     void parsePresencePayload(char* payload, uint32_t* seqNum, uint32_t* maxAge, char** resType);
1372 #ifdef __cplusplus
1373 }
1374 #endif // __cplusplus
1375
1376 TEST(StackPresence, ParsePresencePayload)
1377 {
1378     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1379     OC_LOG(INFO, TAG, "Starting ParsePresencePayload test");
1380
1381     char payload[100];
1382     uint32_t seqNum = 0, maxAge = 0;
1383     char * resType = NULL;
1384
1385     //Good Scenario
1386     strncpy(payload, "{\"oc\":[100:99:presence]}", sizeof(payload));
1387     parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1388     EXPECT_TRUE(100 == seqNum);
1389     EXPECT_TRUE(99 == maxAge);
1390     EXPECT_STREQ("presence", resType);
1391     OCFree(resType);
1392
1393     //Bad Scenario -- should not result in Seg Fault
1394     parsePresencePayload(payload, NULL, &maxAge, &resType);
1395
1396     //Bad Scenario
1397     seqNum = 0; maxAge = 0; resType = NULL;
1398     strncpy(payload, "{abracadabra}", sizeof(payload));
1399     parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1400     EXPECT_TRUE(0 == seqNum);
1401     EXPECT_TRUE(0 == maxAge);
1402     EXPECT_EQ(NULL, resType);
1403     OCFree(resType);
1404
1405     //Bad Scenario
1406     seqNum = 0; maxAge = 0; resType = NULL;
1407     strncpy(payload, "{\"oc\":[100]}", sizeof(payload));
1408     parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1409     EXPECT_TRUE(100 == seqNum);
1410     EXPECT_TRUE(0 == maxAge);
1411     EXPECT_EQ(NULL, resType);
1412     OCFree(resType);
1413
1414     //Bad Scenario
1415     seqNum = 0; maxAge = 0; resType = NULL;
1416     strncpy(payload, "{\"oc\":[]}", sizeof(payload));
1417     parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1418     EXPECT_TRUE(0 == seqNum);
1419     EXPECT_TRUE(0 == maxAge);
1420     EXPECT_EQ(NULL, resType);
1421     OCFree(resType);
1422
1423     //Bad Scenario
1424     strncpy(payload, "{:]}", sizeof(payload));
1425     parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1426     EXPECT_TRUE(0 == seqNum);
1427     EXPECT_TRUE(0 == maxAge);
1428     EXPECT_EQ(NULL, resType);
1429     OCFree(resType);
1430
1431     //Bad Scenario
1432     strncpy(payload, "{:[presence}", sizeof(payload));
1433     parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1434     EXPECT_TRUE(0 == seqNum);
1435     EXPECT_TRUE(0 == maxAge);
1436     EXPECT_EQ(NULL, resType);
1437     OCFree(resType);
1438 }