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