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