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