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