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                                         OC_IPV4,
 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                                         OC_IPV4,
 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, CreateResourceFailDuplicateUri)
 427 {
 428     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 429     OC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
 430     InitStack(OC_SERVER);
 431
 432     OCResourceHandle handle;
 433     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 434                                             "core.led",
 435                                             "core.rw",
 436                                             "/a/led",
 437                                             0,
 438                                             NULL,
 439                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 440     const char *url = OCGetResourceUri(handle);
 441     EXPECT_STREQ("/a/led", url);
 442
 443     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 444                                             "core.led",
 445                                             "core.rw",
 446                                             "/a/led",
 447                                             0,
 448                                             NULL,
 449                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 450
 451     EXPECT_EQ(OC_STACK_OK, OCStop());
 452 }
 453
 454 TEST(StackResource, CreateResourceMultipleResources)
 455 {
 456     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 457     OC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
 458     InitStack(OC_SERVER);
 459
 460     OCResourceHandle handle1;
 461     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 462                                             "core.led",
 463                                             "core.rw",
 464                                             "/a/led1",
 465                                             0,
 466                                             NULL,
 467                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 468
 469     OCResourceHandle handle2;
 470     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 471                                             "core.led",
 472                                             "core.rw",
 473                                             "/a/led2",
 474                                             0,
 475                                             NULL,
 476                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 477     OCResourceHandle handle3;
 478     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 479                                             "core.led",
 480                                             "core.rw",
 481                                             "/a/led3",
 482                                             0,
 483                                             NULL,
 484                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 485
 486     const char *url = OCGetResourceUri(handle1);
 487     EXPECT_STREQ("/a/led1", url);
 488
 489     url = OCGetResourceUri(handle2);
 490     EXPECT_STREQ("/a/led2", url);
 491
 492     url = OCGetResourceUri(handle3);
 493     EXPECT_STREQ("/a/led3", url);
 494
 495     EXPECT_EQ(OC_STACK_OK, OCStop());
 496 }
 497
 498 TEST(StackResource, CreateResourceBadResoureType)
 499 {
 500     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 501     OC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
 502     InitStack(OC_SERVER);
 503
 504     OCResourceHandle handle;
 505     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 506                                             NULL, //"core.led",
 507                                             "core.rw",
 508                                             "/a/led",
 509                                             0,
 510                                             NULL,
 511                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 512
 513     EXPECT_EQ(OC_STACK_OK, OCStop());
 514 }
 515
 516 TEST(StackResource, CreateResourceGoodResourceType)
 517 {
 518     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 519     OC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
 520     InitStack(OC_SERVER);
 521
 522     OCResourceHandle handle;
 523     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 524                                             "core.led",
 525                                             "core.rw",
 526                                             "/a/led",
 527                                             0,
 528                                             NULL,
 529                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 530
 531     EXPECT_EQ(OC_STACK_OK, OCStop());
 532 }
 533
 534 TEST(StackResource, ResourceTypeName)
 535 {
 536     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 537     OC_LOG(INFO, TAG, "Starting ResourceTypeName test");
 538     InitStack(OC_SERVER);
 539
 540     OCResourceHandle handle;
 541     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 542                                             "core.led",
 543                                             "core.rw",
 544                                             "/a/led",
 545                                             0,
 546                                             NULL,
 547                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 548
 549     uint8_t numResourceTypes;
 550     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 551     EXPECT_EQ(1, numResourceTypes);
 552     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 553     EXPECT_STREQ("core.led", resourceTypeName);
 554
 555     // try getting resource type names with an invalid index
 556     resourceTypeName = OCGetResourceTypeName(handle, 1);
 557     EXPECT_STREQ(NULL, resourceTypeName);
 558     // try getting resource type names with an invalid index
 559     resourceTypeName = OCGetResourceTypeName(handle, 10);
 560     EXPECT_STREQ(NULL, resourceTypeName);
 561
 562     EXPECT_EQ(OC_STACK_OK, OCStop());
 563 }
 564
 565 TEST(StackResource, ResourceTypeAttrRepresentation)
 566 {
 567     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 568     OC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
 569     InitStack(OC_SERVER);
 570
 571     OCResourceHandle handle;
 572     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 573                                             "core.led",
 574                                             "core.rw",
 575                                             "/a/led",
 576                                             0,
 577                                             NULL,
 578                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 579
 580     uint8_t numResourceTypes;
 581     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 582     EXPECT_EQ(1, numResourceTypes);
 583
 584     EXPECT_EQ(OC_STACK_OK, OCStop());
 585 }
 586
 587 TEST(StackResource, ResourceTypeInterface)
 588 {
 589     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 590     OC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
 591     InitStack(OC_SERVER);
 592
 593     OCResourceHandle handle;
 594     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 595                                             "core.led",
 596                                             "core.rw",
 597                                             "/a/led",
 598                                             0,
 599                                             NULL,
 600                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 601
 602     uint8_t numResourceInterfaces;
 603     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 604     EXPECT_EQ(1, numResourceInterfaces);
 605     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 606     EXPECT_STREQ("core.rw", resourceInterfaceName);
 607
 608     // try getting resource interface names with an invalid index
 609     resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
 610     EXPECT_STREQ(NULL, resourceInterfaceName);
 611     // try getting resource interface names with an invalid index
 612     resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
 613     EXPECT_STREQ(NULL, resourceInterfaceName);
 614
 615     EXPECT_EQ(OC_STACK_OK, OCStop());
 616 }
 617
 618 TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
 619 {
 620     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 621
 622     OC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
 623
 624     InitStack(OC_SERVER);
 625
 626     OCResourceHandle handle;
 627     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 628                                             "core.led",
 629                                             "core.rw",
 630                                             "/a/led",
 631                                             0,
 632                                             NULL,
 633                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 634     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 635                                         OC_RSRVD_INTERFACE_DEFAULT));
 636     uint8_t numResourceInterfaces;
 637     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 638     EXPECT_EQ(2, numResourceInterfaces);
 639
 640     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
 641     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
 642
 643     const char*interfaceName_2 = OCGetResourceInterfaceName(handle, 1);
 644     EXPECT_STREQ("core.rw", interfaceName_2);
 645
 646     EXPECT_EQ(OC_STACK_OK, OCStop());
 647 }
 648
 649 TEST(StackResource, ResourceDuplicateDefaultInterfaces)
 650 {
 651     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 652
 653     OC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
 654
 655     InitStack(OC_SERVER);
 656
 657     OCResourceHandle handle;
 658     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 659                                             "core.led",
 660                                             "core.rw",
 661                                             "/a/led",
 662                                             0,
 663                                             NULL,
 664                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 665
 666     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 667                                         OC_RSRVD_INTERFACE_DEFAULT));
 668     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 669                                         OC_RSRVD_INTERFACE_DEFAULT));
 670
 671     uint8_t numResourceInterfaces;
 672     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 673     EXPECT_EQ(2, numResourceInterfaces);
 674
 675     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
 676     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
 677
 678     EXPECT_EQ(OC_STACK_OK, OCStop());
 679 }
 680
 681 TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
 682 {
 683     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 684
 685     OC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
 686
 687     InitStack(OC_SERVER);
 688
 689     OCResourceHandle handle;
 690     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 691                                             "core.led",
 692                                             "core.rw",
 693                                             "/a/led",
 694                                             0,
 695                                             NULL,
 696                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 697
 698     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 699                                         "core.rw"));
 700     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 701                                         "core.rw"));
 702
 703     uint8_t numResourceInterfaces;
 704     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 705     EXPECT_EQ(1, numResourceInterfaces);
 706
 707     EXPECT_EQ(OC_STACK_OK, OCStop());
 708 }
 709
 710 TEST(StackResource, ResourceTypeInterfaceMethods)
 711 {
 712     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 713     OC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
 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     uint8_t numResourceInterfaces;
 726     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 727     EXPECT_EQ(1, numResourceInterfaces);
 728
 729     EXPECT_EQ(OC_STACK_OK, OCStop());
 730 }
 731
 732 TEST(StackResource, GetResourceProperties)
 733 {
 734     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 735     OC_LOG(INFO, TAG, "Starting GetResourceProperties test");
 736     InitStack(OC_SERVER);
 737
 738     OCResourceHandle handle;
 739     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 740                                             "core.led",
 741                                             "core.rw",
 742                                             "/a/led",
 743                                             0,
 744                                             NULL,
 745                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 746
 747     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
 748     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 749
 750     EXPECT_EQ(OC_STACK_OK, OCStop());
 751 }
 752
 753 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
 754 {
 755     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 756     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
 757     InitStack(OC_SERVER);
 758     uint8_t numResources = 0;
 759     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 760
 761     OCResourceHandle handle;
 762     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 763                                             "core.led",
 764                                             "core.rw",
 765                                             "/a1/led",
 766                                             0,
 767                                             NULL,
 768                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 769     const char *url = OCGetResourceUri(handle);
 770     EXPECT_STREQ("/a1/led", url);
 771
 772     //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
 773     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 774     uint8_t numExpectedResources = 0;
 775
 776     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
 777     EXPECT_EQ(numExpectedResources, numResources);
 778
 779     EXPECT_EQ(OC_STACK_OK, OCStop());
 780 }
 781
 782 TEST(StackResource, StackTestResourceDiscoverOneResource)
 783 {
 784     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 785     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
 786     InitStack(OC_SERVER);
 787
 788     OCResourceHandle handle;
 789     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 790                                             "core.led",
 791                                             "core.rw",
 792                                             "/a/led",
 793                                             0,
 794                                             NULL,
 795                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 796     const char *url = OCGetResourceUri(handle);
 797     EXPECT_STREQ("/a/led", url);
 798
 799     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 800     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
 801
 802     EXPECT_EQ(OC_STACK_OK, OCStop());
 803 }
 804
 805 TEST(StackResource, StackTestResourceDiscoverManyResources)
 806 {
 807     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 808     OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
 809     InitStack(OC_SERVER);
 810
 811     OCResourceHandle handle1;
 812     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 813                                             "core.led",
 814                                             "core.rw",
 815                                             "/a/led1",
 816                                             0,
 817                                             NULL,
 818                                             OC_DISCOVERABLE));
 819     const char *url = OCGetResourceUri(handle1);
 820     EXPECT_STREQ("/a/led1", url);
 821
 822     OCResourceHandle handle2;
 823     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 824                                             "core.led",
 825                                             "core.rw",
 826                                             "/a/led2",
 827                                             0,
 828                                             NULL,
 829                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 830     url = OCGetResourceUri(handle2);
 831     EXPECT_STREQ("/a/led2", url);
 832
 833     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
 834     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
 835
 836     OCResourceHandle handle3;
 837     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 838                                             "core.led",
 839                                             "core.rw",
 840                                             "/a/led3",
 841                                             0,
 842                                             NULL,
 843                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 844     url = OCGetResourceUri(handle3);
 845     EXPECT_STREQ("/a/led3", url);
 846
 847     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
 848     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
 849
 850     OCResourceHandle handle4;
 851     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
 852                                             "core.led",
 853                                             "core.rw",
 854                                             "/a/led4",
 855                                             0,
 856                                             NULL,
 857                                             OC_DISCOVERABLE));
 858     url = OCGetResourceUri(handle4);
 859     EXPECT_STREQ("/a/led4", url);
 860
 861     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
 862     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
 863     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
 864
 865     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 866
 867     EXPECT_EQ(OC_STACK_OK, OCStop());
 868 }
 869
 870 TEST(StackBind, BindResourceTypeNameBad)
 871 {
 872     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 873     OC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
 874     InitStack(OC_SERVER);
 875
 876     OCResourceHandle handle;
 877     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 878                                             "core.led",
 879                                             "core.rw",
 880                                             "/a/led",
 881                                             0,
 882                                             NULL,
 883                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 884
 885     uint8_t numResourceTypes;
 886     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 887     EXPECT_EQ(1, numResourceTypes);
 888     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 889     EXPECT_STREQ("core.led", resourceTypeName);
 890
 891     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
 892
 893     EXPECT_EQ(OC_STACK_OK, OCStop());
 894 }
 895
 896 TEST(StackBind, BindResourceTypeNameGood)
 897 {
 898     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 899     OC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
 900     InitStack(OC_SERVER);
 901
 902     OCResourceHandle handle;
 903     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 904                                             "core.led",
 905                                             "core.rw",
 906                                             "/a/led",
 907                                             0,
 908                                             NULL,
 909                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 910
 911     uint8_t numResourceTypes;
 912     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 913     EXPECT_EQ(1, numResourceTypes);
 914     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 915     EXPECT_STREQ("core.led", resourceTypeName);
 916
 917     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
 918     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 919     EXPECT_EQ(2, numResourceTypes);
 920     resourceTypeName = OCGetResourceTypeName(handle, 1);
 921     EXPECT_STREQ("core.brightled", resourceTypeName);
 922
 923     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
 924     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 925     EXPECT_EQ(3, numResourceTypes);
 926     resourceTypeName = OCGetResourceTypeName(handle, 2);
 927     EXPECT_STREQ("core.reallybrightled", resourceTypeName);
 928
 929     EXPECT_EQ(OC_STACK_OK, OCStop());
 930 }
 931
 932 TEST(StackBind, BindResourceTypeAttribRepGood)
 933 {
 934     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 935     OC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood 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                                             NULL,
 945                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 946
 947     uint8_t numResourceTypes;
 948     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 949     EXPECT_EQ(1, numResourceTypes);
 950
 951     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
 952     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 953     EXPECT_EQ(2, numResourceTypes);
 954
 955     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
 956     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 957     EXPECT_EQ(3, numResourceTypes);
 958
 959     EXPECT_EQ(OC_STACK_OK, OCStop());
 960 }
 961
 962
 963 TEST(StackBind, BindResourceInterfaceNameBad)
 964 {
 965     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 966     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
 967     InitStack(OC_SERVER);
 968
 969     OCResourceHandle handle;
 970     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 971                                             "core.led",
 972                                             "core.rw",
 973                                             "/a/led",
 974                                             0,
 975                                             NULL,
 976                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 977
 978     uint8_t numResourceInterfaces;
 979     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 980     EXPECT_EQ(1, numResourceInterfaces);
 981     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
 982     EXPECT_STREQ("core.rw", resourceInterfaceName);
 983
 984     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
 985
 986     EXPECT_EQ(OC_STACK_OK, OCStop());
 987 }
 988
 989 TEST(StackBind, BindResourceInterfaceNameGood)
 990 {
 991     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 992     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
 993     InitStack(OC_SERVER);
 994
 995     OCResourceHandle handle;
 996     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 997                                             "core.led",
 998                                             "core.rw",
 999                                             "/a/led",
1000                                             0,
1001                                             NULL,
1002                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1003
1004     uint8_t numResourceInterfaces;
1005     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1006     EXPECT_EQ(1, numResourceInterfaces);
1007     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
1008     EXPECT_STREQ("core.rw", resourceInterfaceName);
1009
1010     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1011
1012     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1013     EXPECT_EQ(2, numResourceInterfaces);
1014     resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1015     EXPECT_STREQ("core.r", resourceInterfaceName);
1016
1017     EXPECT_EQ(OC_STACK_OK, OCStop());
1018 }
1019
1020 TEST(StackBind, BindResourceInterfaceMethodsBad)
1021 {
1022     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1023     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
1024     InitStack(OC_SERVER);
1025
1026     OCResourceHandle handle;
1027     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1028                                             "core.led",
1029                                             "core.rw",
1030                                             "/a/led",
1031                                             0,
1032                                             NULL,
1033                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1034
1035     uint8_t numResourceInterfaces;
1036     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1037     EXPECT_EQ(1, numResourceInterfaces);
1038
1039     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
1040
1041     EXPECT_EQ(OC_STACK_OK, OCStop());
1042 }
1043
1044 TEST(StackBind, BindResourceInterfaceMethodsGood)
1045 {
1046     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1047     OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
1048     InitStack(OC_SERVER);
1049
1050     OCResourceHandle handle;
1051     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1052                                             "core.led",
1053                                             "core.rw",
1054                                             "/a/led",
1055                                             0,
1056                                             NULL,
1057                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1058
1059     uint8_t numResourceInterfaces;
1060     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1061     EXPECT_EQ(1, numResourceInterfaces);
1062
1063     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1064
1065     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1066     EXPECT_EQ(2, numResourceInterfaces);
1067
1068     EXPECT_EQ(OC_STACK_OK, OCStop());
1069 }
1070
1071 TEST(StackBind, BindContainedResourceBad)
1072 {
1073     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1074     OC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
1075     InitStack(OC_SERVER);
1076
1077     OCResourceHandle containerHandle;
1078     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1079                                             "core.led",
1080                                             "core.rw",
1081                                             "/a/kitchen",
1082                                             0,
1083                                             NULL,
1084                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1085
1086     OCResourceHandle handle0;
1087     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1088                                             "core.led",
1089                                             "core.rw",
1090                                             "/a/led",
1091                                             0,
1092                                             NULL,
1093                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1094
1095     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1096
1097     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1098
1099     EXPECT_EQ(OC_STACK_OK, OCStop());
1100 }
1101
1102 TEST(StackBind, BindContainedResourceGood)
1103 {
1104     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1105     OC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1106     InitStack(OC_SERVER);
1107
1108     uint8_t numResources = 0;
1109     uint8_t numExpectedResources = 0;
1110
1111     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1112
1113     OCResourceHandle containerHandle;
1114     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1115                                             "core.led",
1116                                             "core.rw",
1117                                             "/a/kitchen",
1118                                             0,
1119                                             NULL,
1120                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1121     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1122     EXPECT_EQ(++numExpectedResources, numResources);
1123
1124     OCResourceHandle handle0;
1125     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1126                                             "core.led",
1127                                             "core.rw",
1128                                             "/a/led0",
1129                                             0,
1130                                             NULL,
1131                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1132     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1133     EXPECT_EQ(++numExpectedResources, numResources);
1134
1135     OCResourceHandle handle1;
1136     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1137                                             "core.led",
1138                                             "core.rw",
1139                                             "/a/led1",
1140                                             0,
1141                                             NULL,
1142                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1143     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1144     EXPECT_EQ(++numExpectedResources, numResources);
1145
1146     OCResourceHandle handle2;
1147     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1148                                             "core.led",
1149                                             "core.rw",
1150                                             "/a/led2",
1151                                             0,
1152                                             NULL,
1153                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1154     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1155     EXPECT_EQ(++numExpectedResources, numResources);
1156
1157     OCResourceHandle handle3;
1158     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1159                                             "core.led",
1160                                             "core.rw",
1161                                             "/a/led3",
1162                                             0,
1163                                             NULL,
1164                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1165     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1166     EXPECT_EQ(++numExpectedResources, numResources);
1167
1168     OCResourceHandle handle4;
1169     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1170                                             "core.led",
1171                                             "core.rw",
1172                                             "/a/led4",
1173                                             0,
1174                                             NULL,
1175                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1176     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1177     EXPECT_EQ(++numExpectedResources, numResources);
1178
1179     OCResourceHandle handle5;
1180     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1181                                             "core.led",
1182                                             "core.rw",
1183                                             "/a/led5",
1184                                             0,
1185                                             NULL,
1186                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1187     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1188     EXPECT_EQ(++numExpectedResources, numResources);
1189
1190
1191     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1192     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1193     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1194     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1195     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1196     EXPECT_EQ(OC_STACK_ERROR, OCBindResource(containerHandle, handle5));
1197
1198     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1199     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1200     EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1201     EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1202     EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1203
1204     EXPECT_EQ(NULL, OCGetResourceHandleFromCollection(containerHandle, 5));
1205
1206     EXPECT_EQ(OC_STACK_OK, OCStop());
1207 }
1208
1209
1210 TEST(StackBind, BindEntityHandlerBad)
1211 {
1212     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1213     OC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1214     InitStack(OC_SERVER);
1215
1216     OCResourceHandle handle;
1217     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1218                                             "core.led",
1219                                             "core.rw",
1220                                             "/a/led",
1221                                             0,
1222                                             NULL,
1223                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1224
1225     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
1226
1227     EXPECT_EQ(OC_STACK_OK, OCStop());
1228 }
1229
1230 TEST(StackBind, BindEntityHandlerGood)
1231 {
1232     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1233     OC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1234     InitStack(OC_SERVER);
1235
1236     OCResourceHandle handle;
1237     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1238                                             "core.led",
1239                                             "core.rw",
1240                                             "/a/led",
1241                                             0,
1242                                             NULL,
1243                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1244
1245     OCEntityHandler myHandler = entityHandler;
1246
1247     EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
1248
1249     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1250
1251     EXPECT_EQ(OC_STACK_OK, OCStop());
1252 }
1253
1254 TEST(StackResourceAccess, GetResourceByIndex)
1255 {
1256     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1257     OC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1258     InitStack(OC_SERVER);
1259
1260     uint8_t numResources = 0;
1261     uint8_t numExpectedResources = 0;
1262     uint8_t resourceIndex = 0;
1263     uint8_t prevResources = 0;
1264     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1265     prevResources = numExpectedResources;
1266     OCResourceHandle containerHandle;
1267     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1268                                             "core.led",
1269                                             "core.rw",
1270                                             "/a/kitchen",
1271                                             0,
1272                                             NULL,
1273                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1274     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1275     EXPECT_EQ(++numExpectedResources, numResources);
1276
1277     OCResourceHandle handle0;
1278     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1279                                             "core.led",
1280                                             "core.rw",
1281                                             "/a/led0",
1282                                             0,
1283                                             NULL,
1284                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1285     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1286     EXPECT_EQ(++numExpectedResources, numResources);
1287
1288     OCResourceHandle handle1;
1289     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1290                                             "core.led",
1291                                             "core.rw",
1292                                             "/a/led1",
1293                                             0,
1294                                             NULL,
1295                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1296     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1297     EXPECT_EQ(++numExpectedResources, numResources);
1298
1299     OCResourceHandle handle2;
1300     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1301                                             "core.led",
1302                                             "core.rw",
1303                                             "/a/led2",
1304                                             0,
1305                                             NULL,
1306                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1307     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1308     EXPECT_EQ(++numExpectedResources, numResources);
1309
1310     OCResourceHandle handle3;
1311     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1312                                             "core.led",
1313                                             "core.rw",
1314                                             "/a/led3",
1315                                             0,
1316                                             NULL,
1317                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1318     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1319     EXPECT_EQ(++numExpectedResources, numResources);
1320
1321     OCResourceHandle handle4;
1322     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1323                                             "core.led",
1324                                             "core.rw",
1325                                             "/a/led4",
1326                                             0,
1327                                             NULL,
1328                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1329     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1330     EXPECT_EQ(++numExpectedResources, numResources);
1331
1332     OCResourceHandle handle5;
1333     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1334                                             "core.led",
1335                                             "core.rw",
1336                                             "/a/led5",
1337                                             0,
1338                                             NULL,
1339                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1340     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1341     EXPECT_EQ(++numExpectedResources, numResources);
1342     resourceIndex += prevResources;
1343     EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1344     EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1345     EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1346     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1347     EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1348     EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1349     EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1350
1351     EXPECT_EQ(OC_STACK_OK, OCStop());
1352 }
1353
1354 TEST(StackResourceAccess, DeleteHeadResource)
1355 {
1356     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1357     OC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1358     InitStack(OC_SERVER);
1359
1360     uint8_t numResources = 0;
1361     uint8_t numExpectedResources = 0;
1362
1363     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1364
1365     OCResourceHandle handle0;
1366     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1367                                             "core.led",
1368                                             "core.rw",
1369                                             "/a/led0",
1370                                             0,
1371                                             NULL,
1372                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1373     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1374     EXPECT_EQ(++numExpectedResources, numResources);
1375
1376     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1377     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1378     EXPECT_EQ(--numExpectedResources, numResources);
1379
1380     EXPECT_EQ(OC_STACK_OK, OCStop());
1381 }
1382
1383 TEST(StackResourceAccess, DeleteHeadResource2)
1384 {
1385     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1386     OC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1387     InitStack(OC_SERVER);
1388
1389     uint8_t numResources = 0;
1390     uint8_t numExpectedResources = 0;
1391
1392     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1393     OCResourceHandle handle0;
1394     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1395                                             "core.led",
1396                                             "core.rw",
1397                                             "/a/led0",
1398                                             0,
1399                                             NULL,
1400                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1401     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1402     EXPECT_EQ(++numExpectedResources, numResources);
1403
1404     OCResourceHandle handle1;
1405     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1406                                             "core.led",
1407                                             "core.rw",
1408                                             "/a/led1",
1409                                             0,
1410                                             NULL,
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(handle0));
1416     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1417     EXPECT_EQ(--numExpectedResources, numResources);
1418
1419     EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
1420
1421     EXPECT_EQ(OC_STACK_OK, OCStop());
1422 }
1423
1424
1425 TEST(StackResourceAccess, DeleteLastResource)
1426 {
1427     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1428     OC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1429     InitStack(OC_SERVER);
1430
1431     uint8_t numResources = 0;
1432     uint8_t numExpectedResources = 0;
1433
1434     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1435
1436     OCResourceHandle handle0;
1437     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1438                                             "core.led",
1439                                             "core.rw",
1440                                             "/a/led0",
1441                                             0,
1442                                             NULL,
1443                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1444     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1445     EXPECT_EQ(++numExpectedResources, numResources);
1446
1447     OCResourceHandle handle1;
1448     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1449                                             "core.led",
1450                                             "core.rw",
1451                                             "/a/led1",
1452                                             0,
1453                                             NULL,
1454                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1455     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1456     EXPECT_EQ(++numExpectedResources, numResources);
1457
1458     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1459     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1460     EXPECT_EQ(--numExpectedResources, numResources);
1461
1462     EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
1463
1464     OCResourceHandle handle2;
1465     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1466                                             "core.led",
1467                                             "core.rw",
1468                                             "/a/led2",
1469                                             0,
1470                                             NULL,
1471                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1472     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1473     EXPECT_EQ(++numExpectedResources, numResources);
1474
1475     EXPECT_EQ(OC_STACK_OK, OCStop());
1476 }
1477
1478 TEST(StackResourceAccess, DeleteMiddleResource)
1479 {
1480     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1481     OC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1482     InitStack(OC_SERVER);
1483
1484     uint8_t numResources = 0;
1485     uint8_t numExpectedResources = 0;
1486     uint8_t resourceIndex = InitResourceIndex();
1487
1488     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1489     resourceIndex = numExpectedResources;
1490     OCResourceHandle handle0;
1491     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1492                                             "core.led",
1493                                             "core.rw",
1494                                             "/a/led0",
1495                                             0,
1496                                             NULL,
1497                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1498     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1499     EXPECT_EQ(++numExpectedResources, numResources);
1500
1501     OCResourceHandle handle1;
1502     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1503                                             "core.led",
1504                                             "core.rw",
1505                                             "/a/led1",
1506                                             0,
1507                                             NULL,
1508                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1509     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1510     EXPECT_EQ(++numExpectedResources, numResources);
1511
1512     OCResourceHandle handle2;
1513     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1514                                             "core.led",
1515                                             "core.rw",
1516                                             "/a/led2",
1517                                             0,
1518                                             NULL,
1519                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1520     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1521     EXPECT_EQ(++numExpectedResources, numResources);
1522
1523     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1524     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1525     EXPECT_EQ(--numExpectedResources, numResources);
1526
1527     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1528     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1529
1530     // Make sure the resource elements are still correct
1531     uint8_t numResourceInterfaces;
1532     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1533     EXPECT_EQ(1, numResourceInterfaces);
1534     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0);
1535     EXPECT_STREQ("core.rw", resourceInterfaceName);
1536
1537     EXPECT_EQ(OC_STACK_OK, OCStop());
1538 }
1539
1540
1541 #ifdef __cplusplus
1542 extern "C" {
1543 #endif // __cplusplus
1544     void parsePresencePayload(char* payload, uint32_t* seqNum,
1545             uint32_t* maxAge, OCPresenceTrigger* presenceTrigger, char** resType);
1546 #ifdef __cplusplus
1547 }
1548 #endif // __cplusplus
1549
1550 TEST(StackPresence, ParsePresencePayload)
1551 {
1552     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1553     OC_LOG(INFO, TAG, "Starting ParsePresencePayload test");
1554
1555     char payload[100];
1556     uint32_t seqNum = 0, maxAge = 0;
1557     OCPresenceTrigger presenceTrigger = OC_PRESENCE_TRIGGER_CHANGE;
1558     char * resType = NULL;
1559
1560     //Good Scenario
1561     strncpy(payload, "{\"oic\":[{\"ttl\":99,\"non\":100,\"trg\":"
1562             "\"delete\",\"rt\":\"presence\"}]}", sizeof(payload));
1563     parsePresencePayload(payload, &seqNum, &maxAge,
1564             &presenceTrigger, &resType);
1565     EXPECT_TRUE(100 == seqNum);
1566     EXPECT_TRUE(99 == maxAge);
1567     EXPECT_TRUE(OC_PRESENCE_TRIGGER_DELETE == presenceTrigger);
1568     EXPECT_TRUE(NULL != resType);
1569     EXPECT_STREQ("presence", resType);
1570     OICFree(resType);
1571
1572     presenceTrigger = OC_PRESENCE_TRIGGER_CHANGE;
1573
1574     //Bad Scenario -- should not result in Seg Fault
1575     parsePresencePayload(payload, NULL, &maxAge, &presenceTrigger, &resType);
1576
1577     //Bad Scenario
1578     seqNum = 0; maxAge = 0; resType = NULL;
1579     strncpy(payload, "{abracadabra}", sizeof(payload));
1580     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1581     EXPECT_TRUE(0 == seqNum);
1582     EXPECT_TRUE(0 == maxAge);
1583     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1584     EXPECT_TRUE(NULL == resType);
1585     EXPECT_EQ(NULL, resType);
1586     OICFree(resType);
1587
1588     //Bad Scenario
1589     seqNum = 0; maxAge = 0; resType = NULL;
1590     strncpy(payload, "{\"oic\":[100]}", sizeof(payload));
1591     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1592     EXPECT_TRUE(0 == seqNum);
1593     EXPECT_TRUE(0 == maxAge);
1594     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1595     EXPECT_TRUE(NULL == resType);
1596     EXPECT_EQ(NULL, resType);
1597     OICFree(resType);
1598
1599     //Bad Scenario
1600     seqNum = 0; maxAge = 0; resType = NULL;
1601     strncpy(payload, "{\"oic\":[]}", sizeof(payload));
1602     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1603     EXPECT_TRUE(0 == seqNum);
1604     EXPECT_TRUE(0 == maxAge);
1605     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1606     EXPECT_TRUE(NULL == resType);
1607     EXPECT_EQ(NULL, resType);
1608     OICFree(resType);
1609
1610     //Bad Scenario
1611     strncpy(payload, "{:]}", sizeof(payload));
1612     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1613     EXPECT_TRUE(0 == seqNum);
1614     EXPECT_TRUE(0 == maxAge);
1615     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1616     EXPECT_TRUE(NULL == resType);
1617     EXPECT_EQ(NULL, resType);
1618     OICFree(resType);
1619
1620     //Bad Scenario
1621     strncpy(payload, "{:[presence}", sizeof(payload));
1622     parsePresencePayload(payload, &seqNum, &maxAge, &presenceTrigger, &resType);
1623     EXPECT_TRUE(0 == seqNum);
1624     EXPECT_TRUE(0 == maxAge);
1625     EXPECT_TRUE(OC_PRESENCE_TRIGGER_CHANGE == presenceTrigger);
1626     EXPECT_TRUE(NULL == resType);
1627     EXPECT_EQ(NULL, resType);
1628     OICFree(resType);
1629 }
1630
1631 TEST(PODTests, OCHeaderOption)
1632 {
1633     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1634 }
1635
1636 TEST(PODTests, OCCallbackData)
1637 {
1638     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1639 }