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, 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_WIFI,
 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, 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_WIFI,
 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, ResourceTypeInterfaceMethods)
 483 {
 484     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 485     OC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
 486     InitStack(OC_SERVER);
 487
 488     OCResourceHandle handle;
 489     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 490                                             "core.led",
 491                                             "core.rw",
 492                                             "/a/led",
 493                                             0,
 494                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 495
 496     uint8_t numResourceInterfaces;
 497     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 498     EXPECT_EQ(1, numResourceInterfaces);
 499
 500     EXPECT_EQ(OC_STACK_OK, OCStop());
 501 }
 502
 503 TEST(StackResource, GetResourceProperties)
 504 {
 505     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 506     OC_LOG(INFO, TAG, "Starting GetResourceProperties test");
 507     InitStack(OC_SERVER);
 508
 509     OCResourceHandle handle;
 510     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 511                                             "core.led",
 512                                             "core.rw",
 513                                             "/a/led",
 514                                             0,
 515                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 516
 517     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
 518     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 519
 520     EXPECT_EQ(OC_STACK_OK, OCStop());
 521 }
 522
 523 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
 524 {
 525     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 526     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
 527     InitStack(OC_SERVER);
 528
 529     OCResourceHandle handle;
 530     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 531                                             "core.led",
 532                                             "core.rw",
 533                                             "/a1/led",
 534                                             0,
 535                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 536     const char *url = OCGetResourceUri(handle);
 537     EXPECT_STREQ("/a1/led", url);
 538
 539     //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
 540     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 541     uint8_t numResources = 0;
 542     uint8_t numExpectedResources = InitNumExpectedResources();
 543
 544     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 545     EXPECT_EQ(numExpectedResources, numResources);
 546
 547     EXPECT_EQ(OC_STACK_OK, OCStop());
 548 }
 549
 550 TEST(StackResource, StackTestResourceDiscoverOneResource)
 551 {
 552     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 553     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
 554     InitStack(OC_SERVER);
 555
 556     OCResourceHandle handle;
 557     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 558                                             "core.led",
 559                                             "core.rw",
 560                                             "/a/led",
 561                                             0,
 562                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 563     const char *url = OCGetResourceUri(handle);
 564     EXPECT_STREQ("/a/led", url);
 565
 566     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 567     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 568
 569     EXPECT_EQ(OC_STACK_OK, OCStop());
 570 }
 571
 572 TEST(StackResource, StackTestResourceDiscoverManyResources)
 573 {
 574     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 575     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
 576     InitStack(OC_SERVER);
 577
 578     OCResourceHandle handle1;
 579     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 580                                             "core.led",
 581                                             "core.rw",
 582                                             "/a/led1",
 583                                             0,
 584                                             OC_DISCOVERABLE));
 585     const char *url = OCGetResourceUri(handle1);
 586     EXPECT_STREQ("/a/led1", url);
 587
 588     OCResourceHandle handle2;
 589     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 590                                             "core.led",
 591                                             "core.rw",
 592                                             "/a/led2",
 593                                             0,
 594                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 595     url = OCGetResourceUri(handle2);
 596     EXPECT_STREQ("/a/led2", url);
 597
 598     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
 599     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
 600
 601     OCResourceHandle handle3;
 602     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 603                                             "core.led",
 604                                             "core.rw",
 605                                             "/a/led3",
 606                                             0,
 607                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 608     url = OCGetResourceUri(handle3);
 609     EXPECT_STREQ("/a/led3", url);
 610
 611     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, "oc.mi.ll"));
 612     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, "oc.mi.b"));
 613
 614     OCResourceHandle handle4;
 615     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
 616                                             "core.led",
 617                                             "core.rw",
 618                                             "/a/led4",
 619                                             0,
 620                                             OC_DISCOVERABLE));
 621     url = OCGetResourceUri(handle4);
 622     EXPECT_STREQ("/a/led4", url);
 623
 624     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
 625     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, "oc.mi.ll"));
 626     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, "oc.mi.b"));
 627
 628     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 629
 630     EXPECT_EQ(OC_STACK_OK, OCStop());
 631 }
 632
 633 TEST(StackBind, BindResourceTypeNameBad)
 634 {
 635     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 636     OC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
 637     InitStack(OC_SERVER);
 638
 639     OCResourceHandle handle;
 640     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 641                                             "core.led",
 642                                             "core.rw",
 643                                             "/a/led",
 644                                             0,
 645                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 646
 647     uint8_t numResourceTypes;
 648     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 649     EXPECT_EQ(1, numResourceTypes);
 650     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 651     EXPECT_STREQ("core.led", resourceTypeName);
 652
 653     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
 654
 655     EXPECT_EQ(OC_STACK_OK, OCStop());
 656 }
 657
 658 TEST(StackBind, BindResourceTypeNameGood)
 659 {
 660     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 661     OC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
 662     InitStack(OC_SERVER);
 663
 664     OCResourceHandle handle;
 665     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 666                                             "core.led",
 667                                             "core.rw",
 668                                             "/a/led",
 669                                             0,
 670                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 671
 672     uint8_t numResourceTypes;
 673     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 674     EXPECT_EQ(1, numResourceTypes);
 675     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 676     EXPECT_STREQ("core.led", resourceTypeName);
 677
 678     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
 679     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 680     EXPECT_EQ(2, numResourceTypes);
 681     resourceTypeName = OCGetResourceTypeName(handle, 1);
 682     EXPECT_STREQ("core.brightled", resourceTypeName);
 683
 684     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
 685     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 686     EXPECT_EQ(3, numResourceTypes);
 687     resourceTypeName = OCGetResourceTypeName(handle, 2);
 688     EXPECT_STREQ("core.reallybrightled", resourceTypeName);
 689
 690     EXPECT_EQ(OC_STACK_OK, OCStop());
 691 }
 692
 693 TEST(StackBind, BindResourceTypeAttribRepGood)
 694 {
 695     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 696     OC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
 697     InitStack(OC_SERVER);
 698
 699     OCResourceHandle handle;
 700     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 701                                             "core.led",
 702                                             "core.rw",
 703                                             "/a/led",
 704                                             0,
 705                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 706
 707     uint8_t numResourceTypes;
 708     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 709     EXPECT_EQ(1, numResourceTypes);
 710
 711     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
 712     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 713     EXPECT_EQ(2, numResourceTypes);
 714
 715     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
 716     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 717     EXPECT_EQ(3, numResourceTypes);
 718
 719     EXPECT_EQ(OC_STACK_OK, OCStop());
 720 }
 721
 722
 723 TEST(StackBind, BindResourceInterfaceNameBad)
 724 {
 725     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 726     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
 727     InitStack(OC_SERVER);
 728
 729     OCResourceHandle handle;
 730     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 731                                             "core.led",
 732                                             "core.rw",
 733                                             "/a/led",
 734                                             0,
 735                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 736
 737     uint8_t numResourceInterfaces;
 738     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 739     EXPECT_EQ(1, numResourceInterfaces);
 740     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 741     EXPECT_STREQ("core.rw", resourceInterfaceName);
 742
 743     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
 744
 745     EXPECT_EQ(OC_STACK_OK, OCStop());
 746 }
 747
 748 TEST(StackBind, BindResourceInterfaceNameGood)
 749 {
 750     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 751     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
 752     InitStack(OC_SERVER);
 753
 754     OCResourceHandle handle;
 755     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 756                                             "core.led",
 757                                             "core.rw",
 758                                             "/a/led",
 759                                             0,
 760                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 761
 762     uint8_t numResourceInterfaces;
 763     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 764     EXPECT_EQ(1, numResourceInterfaces);
 765     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 766     EXPECT_STREQ("core.rw", resourceInterfaceName);
 767
 768     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
 769
 770     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 771     EXPECT_EQ(2, numResourceInterfaces);
 772     resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
 773     EXPECT_STREQ("core.r", resourceInterfaceName);
 774
 775     EXPECT_EQ(OC_STACK_OK, OCStop());
 776 }
 777
 778 TEST(StackBind, BindResourceInterfaceMethodsBad)
 779 {
 780     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 781     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
 782     InitStack(OC_SERVER);
 783
 784     OCResourceHandle handle;
 785     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 786                                             "core.led",
 787                                             "core.rw",
 788                                             "/a/led",
 789                                             0,
 790                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 791
 792     uint8_t numResourceInterfaces;
 793     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 794     EXPECT_EQ(1, numResourceInterfaces);
 795
 796     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
 797
 798     EXPECT_EQ(OC_STACK_OK, OCStop());
 799 }
 800
 801 TEST(StackBind, BindResourceInterfaceMethodsGood)
 802 {
 803     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 804     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
 805     InitStack(OC_SERVER);
 806
 807     OCResourceHandle handle;
 808     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 809                                             "core.led",
 810                                             "core.rw",
 811                                             "/a/led",
 812                                             0,
 813                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 814
 815     uint8_t numResourceInterfaces;
 816     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 817     EXPECT_EQ(1, numResourceInterfaces);
 818
 819     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
 820
 821     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 822     EXPECT_EQ(2, numResourceInterfaces);
 823
 824     EXPECT_EQ(OC_STACK_OK, OCStop());
 825 }
 826
 827 TEST(StackBind, BindContainedResourceBad)
 828 {
 829     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 830     OC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
 831     InitStack(OC_SERVER);
 832
 833     OCResourceHandle containerHandle;
 834     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
 835                                             "core.led",
 836                                             "core.rw",
 837                                             "/a/kitchen",
 838                                             0,
 839                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 840
 841     OCResourceHandle handle0;
 842     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
 843                                             "core.led",
 844                                             "core.rw",
 845                                             "/a/led",
 846                                             0,
 847                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 848
 849     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
 850
 851     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
 852
 853     EXPECT_EQ(OC_STACK_OK, OCStop());
 854 }
 855
 856 TEST(StackBind, BindContainedResourceGood)
 857 {
 858     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 859     OC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
 860     InitStack(OC_SERVER);
 861
 862     uint8_t numResources = 0;
 863     uint8_t numExpectedResources = InitNumExpectedResources();
 864
 865     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 866     EXPECT_EQ(numExpectedResources, numResources);
 867
 868     OCResourceHandle containerHandle;
 869     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
 870                                             "core.led",
 871                                             "core.rw",
 872                                             "/a/kitchen",
 873                                             0,
 874                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 875     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 876     EXPECT_EQ(++numExpectedResources, numResources);
 877
 878     OCResourceHandle handle0;
 879     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
 880                                             "core.led",
 881                                             "core.rw",
 882                                             "/a/led0",
 883                                             0,
 884                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 885     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 886     EXPECT_EQ(++numExpectedResources, numResources);
 887
 888     OCResourceHandle handle1;
 889     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 890                                             "core.led",
 891                                             "core.rw",
 892                                             "/a/led1",
 893                                             0,
 894                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 895     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 896     EXPECT_EQ(++numExpectedResources, numResources);
 897
 898     OCResourceHandle handle2;
 899     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 900                                             "core.led",
 901                                             "core.rw",
 902                                             "/a/led2",
 903                                             0,
 904                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 905     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 906     EXPECT_EQ(++numExpectedResources, numResources);
 907
 908     OCResourceHandle handle3;
 909     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 910                                             "core.led",
 911                                             "core.rw",
 912                                             "/a/led3",
 913                                             0,
 914                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 915     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 916     EXPECT_EQ(++numExpectedResources, numResources);
 917
 918     OCResourceHandle handle4;
 919     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
 920                                             "core.led",
 921                                             "core.rw",
 922                                             "/a/led4",
 923                                             0,
 924                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 925     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 926     EXPECT_EQ(++numExpectedResources, numResources);
 927
 928     OCResourceHandle handle5;
 929     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
 930                                             "core.led",
 931                                             "core.rw",
 932                                             "/a/led5",
 933                                             0,
 934                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 935     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 936     EXPECT_EQ(++numExpectedResources, numResources);
 937
 938
 939     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
 940     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
 941     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
 942     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
 943     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
 944     EXPECT_EQ(OC_STACK_ERROR, OCBindResource(containerHandle, handle5));
 945
 946     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
 947     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
 948     EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
 949     EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
 950     EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
 951
 952     EXPECT_EQ(NULL, OCGetResourceHandleFromCollection(containerHandle, 5));
 953
 954     EXPECT_EQ(OC_STACK_OK, OCStop());
 955 }
 956
 957
 958 TEST(StackBind, BindEntityHandlerBad)
 959 {
 960     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 961     OC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
 962     InitStack(OC_SERVER);
 963
 964     OCResourceHandle handle;
 965     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 966                                             "core.led",
 967                                             "core.rw",
 968                                             "/a/led",
 969                                             0,
 970                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 971
 972     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL));
 973
 974     EXPECT_EQ(OC_STACK_OK, OCStop());
 975 }
 976
 977 TEST(StackBind, BindEntityHandlerGood)
 978 {
 979     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 980     OC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
 981     InitStack(OC_SERVER);
 982
 983     OCResourceHandle handle;
 984     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 985                                             "core.led",
 986                                             "core.rw",
 987                                             "/a/led",
 988                                             0,
 989                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 990
 991     OCEntityHandler myHandler = entityHandler;
 992
 993     EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler));
 994
 995     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
 996
 997     EXPECT_EQ(OC_STACK_OK, OCStop());
 998 }
 999
1000 TEST(StackResourceAccess, GetResourceByIndex)
1001 {
1002     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1003     OC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1004     InitStack(OC_SERVER);
1005
1006     uint8_t numResources = 0;
1007     uint8_t numExpectedResources = InitNumExpectedResources();
1008     uint8_t resourceIndex = InitResourceIndex();
1009
1010     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1011     EXPECT_EQ(numExpectedResources, numResources);
1012
1013     OCResourceHandle containerHandle;
1014     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1015                                             "core.led",
1016                                             "core.rw",
1017                                             "/a/kitchen",
1018                                             0,
1019                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1020     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1021     EXPECT_EQ(++numExpectedResources, numResources);
1022
1023     OCResourceHandle handle0;
1024     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1025                                             "core.led",
1026                                             "core.rw",
1027                                             "/a/led0",
1028                                             0,
1029                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1030     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1031     EXPECT_EQ(++numExpectedResources, numResources);
1032
1033     OCResourceHandle handle1;
1034     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1035                                             "core.led",
1036                                             "core.rw",
1037                                             "/a/led1",
1038                                             0,
1039                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1040     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1041     EXPECT_EQ(++numExpectedResources, numResources);
1042
1043     OCResourceHandle handle2;
1044     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1045                                             "core.led",
1046                                             "core.rw",
1047                                             "/a/led2",
1048                                             0,
1049                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1050     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1051     EXPECT_EQ(++numExpectedResources, numResources);
1052
1053     OCResourceHandle handle3;
1054     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1055                                             "core.led",
1056                                             "core.rw",
1057                                             "/a/led3",
1058                                             0,
1059                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1060     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1061     EXPECT_EQ(++numExpectedResources, numResources);
1062
1063     OCResourceHandle handle4;
1064     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1065                                             "core.led",
1066                                             "core.rw",
1067                                             "/a/led4",
1068                                             0,
1069                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1070     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1071     EXPECT_EQ(++numExpectedResources, numResources);
1072
1073     OCResourceHandle handle5;
1074     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1075                                             "core.led",
1076                                             "core.rw",
1077                                             "/a/led5",
1078                                             0,
1079                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1080     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1081     EXPECT_EQ(++numExpectedResources, numResources);
1082
1083     EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1084     EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1085     EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1086     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1087     EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1088     EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1089     EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1090
1091     EXPECT_EQ(OC_STACK_OK, OCStop());
1092 }
1093
1094 TEST(StackResourceAccess, DeleteHeadResource)
1095 {
1096     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1097     OC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1098     InitStack(OC_SERVER);
1099
1100     uint8_t numResources = 0;
1101     uint8_t numExpectedResources = InitNumExpectedResources();
1102
1103     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1104     EXPECT_EQ(numExpectedResources, numResources);
1105
1106     OCResourceHandle handle0;
1107     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1108                                             "core.led",
1109                                             "core.rw",
1110                                             "/a/led0",
1111                                             0,
1112                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1113     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1114     EXPECT_EQ(++numExpectedResources, numResources);
1115
1116     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1117     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1118     EXPECT_EQ(--numExpectedResources, numResources);
1119
1120     EXPECT_EQ(OC_STACK_OK, OCStop());
1121 }
1122
1123 TEST(StackResourceAccess, DeleteHeadResource2)
1124 {
1125     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1126     OC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1127     InitStack(OC_SERVER);
1128
1129     uint8_t numResources = 0;
1130     uint8_t numExpectedResources = InitNumExpectedResources();
1131     uint8_t resourceIndex = InitResourceIndex();
1132
1133     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1134     EXPECT_EQ(numExpectedResources, numResources);
1135
1136     OCResourceHandle handle0;
1137     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1138                                             "core.led",
1139                                             "core.rw",
1140                                             "/a/led0",
1141                                             0,
1142                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1143     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1144     EXPECT_EQ(++numExpectedResources, numResources);
1145
1146     OCResourceHandle handle1;
1147     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1148                                             "core.led",
1149                                             "core.rw",
1150                                             "/a/led1",
1151                                             0,
1152                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1153     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1154     EXPECT_EQ(++numExpectedResources, numResources);
1155
1156     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1157     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1158     EXPECT_EQ(--numExpectedResources, numResources);
1159
1160     EXPECT_EQ(handle1, OCGetResourceHandle(resourceIndex));
1161
1162     EXPECT_EQ(OC_STACK_OK, OCStop());
1163 }
1164
1165
1166 TEST(StackResourceAccess, DeleteLastResource)
1167 {
1168     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1169     OC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1170     InitStack(OC_SERVER);
1171
1172     uint8_t numResources = 0;
1173     uint8_t numExpectedResources = InitNumExpectedResources();
1174     uint8_t resourceIndex = InitResourceIndex();
1175
1176     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1177     EXPECT_EQ(numExpectedResources, numResources);
1178
1179     OCResourceHandle handle0;
1180     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1181                                             "core.led",
1182                                             "core.rw",
1183                                             "/a/led0",
1184                                             0,
1185                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1186     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1187     EXPECT_EQ(++numExpectedResources, numResources);
1188
1189     OCResourceHandle handle1;
1190     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1191                                             "core.led",
1192                                             "core.rw",
1193                                             "/a/led1",
1194                                             0,
1195                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1196     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1197     EXPECT_EQ(++numExpectedResources, numResources);
1198
1199     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1200     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1201     EXPECT_EQ(--numExpectedResources, numResources);
1202
1203     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1204
1205     OCResourceHandle handle2;
1206     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1207                                             "core.led",
1208                                             "core.rw",
1209                                             "/a/led2",
1210                                             0,
1211                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1212     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1213     EXPECT_EQ(++numExpectedResources, numResources);
1214
1215     EXPECT_EQ(OC_STACK_OK, OCStop());
1216 }
1217
1218 TEST(StackResourceAccess, DeleteMiddleResource)
1219 {
1220     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1221     OC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1222     InitStack(OC_SERVER);
1223
1224     uint8_t numResources = 0;
1225     uint8_t numExpectedResources = InitNumExpectedResources();
1226     uint8_t resourceIndex = InitResourceIndex();
1227
1228     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1229     EXPECT_EQ(numExpectedResources, numResources);
1230
1231     OCResourceHandle handle0;
1232     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1233                                             "core.led",
1234                                             "core.rw",
1235                                             "/a/led0",
1236                                             0,
1237                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1238     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1239     EXPECT_EQ(++numExpectedResources, numResources);
1240
1241     OCResourceHandle handle1;
1242     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1243                                             "core.led",
1244                                             "core.rw",
1245                                             "/a/led1",
1246                                             0,
1247                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1248     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1249     EXPECT_EQ(++numExpectedResources, numResources);
1250
1251     OCResourceHandle handle2;
1252     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1253                                             "core.led",
1254                                             "core.rw",
1255                                             "/a/led2",
1256                                             0,
1257                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1258     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1259     EXPECT_EQ(++numExpectedResources, numResources);
1260
1261     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1262     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1263     EXPECT_EQ(--numExpectedResources, numResources);
1264
1265     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1266     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1267
1268     // Make sure the resource elements are still correct
1269     uint8_t numResourceInterfaces;
1270     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1271     EXPECT_EQ(1, numResourceInterfaces);
1272     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0);
1273     EXPECT_STREQ("core.rw", resourceInterfaceName);
1274
1275     EXPECT_EQ(OC_STACK_OK, OCStop());
1276 }
1277
1278
1279 #ifdef __cplusplus
1280 extern "C" {
1281 #endif // __cplusplus
1282     void parsePresencePayload(char* payload, uint32_t* seqNum, uint32_t* maxAge, char** resType);
1283 #ifdef __cplusplus
1284 }
1285 #endif // __cplusplus
1286
1287 TEST(StackPresence, ParsePresencePayload)
1288 {
1289     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1290     OC_LOG(INFO, TAG, "Starting ParsePresencePayload test");
1291
1292     char payload[100];
1293     uint32_t seqNum = 0, maxAge = 0;
1294     char * resType = NULL;
1295
1296     //Good Scenario
1297     strncpy(payload, "{\"oc\":[100:99:presence]}", sizeof(payload));
1298     parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1299     EXPECT_TRUE(100 == seqNum);
1300     EXPECT_TRUE(99 == maxAge);
1301     EXPECT_STREQ("presence", resType);
1302     OCFree(resType);
1303
1304     //Bad Scenario -- should not result in Seg Fault
1305     parsePresencePayload(payload, NULL, &maxAge, &resType);
1306
1307     //Bad Scenario
1308     seqNum = 0; maxAge = 0; resType = NULL;
1309     strncpy(payload, "{abracadabra}", sizeof(payload));
1310     parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1311     EXPECT_TRUE(0 == seqNum);
1312     EXPECT_TRUE(0 == maxAge);
1313     EXPECT_EQ(NULL, resType);
1314     OCFree(resType);
1315
1316     //Bad Scenario
1317     seqNum = 0; maxAge = 0; resType = NULL;
1318     strncpy(payload, "{\"oc\":[100]}", sizeof(payload));
1319     parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1320     EXPECT_TRUE(100 == seqNum);
1321     EXPECT_TRUE(0 == maxAge);
1322     EXPECT_EQ(NULL, resType);
1323     OCFree(resType);
1324
1325     //Bad Scenario
1326     seqNum = 0; maxAge = 0; resType = NULL;
1327     strncpy(payload, "{\"oc\":[]}", sizeof(payload));
1328     parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1329     EXPECT_TRUE(0 == seqNum);
1330     EXPECT_TRUE(0 == maxAge);
1331     EXPECT_EQ(NULL, resType);
1332     OCFree(resType);
1333
1334     //Bad Scenario
1335     strncpy(payload, "{:]}", sizeof(payload));
1336     parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1337     EXPECT_TRUE(0 == seqNum);
1338     EXPECT_TRUE(0 == maxAge);
1339     EXPECT_EQ(NULL, resType);
1340     OCFree(resType);
1341
1342     //Bad Scenario
1343     strncpy(payload, "{:[presence}", sizeof(payload));
1344     parsePresencePayload(payload, &seqNum, &maxAge, &resType);
1345     EXPECT_TRUE(0 == seqNum);
1346     EXPECT_TRUE(0 == maxAge);
1347     EXPECT_EQ(NULL, resType);
1348     OCFree(resType);
1349 }