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