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