resource/csdk/stack/test/stacktests.cpp

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