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 "ocpayload.h"
  25     #include "ocstack.h"
  26     #include "ocstackinternal.h"
  27     #include "logger.h"
  28     #include "oic_malloc.h"
  29     #include "oic_string.h"
  30     #include "oic_time.h"
  31     #include "ocresourcehandler.h"
  32 }
  33
  34 #include "gtest/gtest.h"
  35 #include <sys/types.h>
  36 #include <sys/stat.h>
  37 #include <errno.h>
  38 #include <fcntl.h>
  39 #ifdef HAVE_UNISTD_H
  40 #include <unistd.h>
  41 #endif
  42 #include <stdlib.h>
  43
  44 //-----------------------------------------------------------------------------
  45 // Includes
  46 //-----------------------------------------------------------------------------
  47 #include <stdio.h>
  48 #include <string.h>
  49
  50 #include <iostream>
  51 #include <stdint.h>
  52
  53 #include "gtest_helper.h"
  54
  55 using namespace std;
  56
  57 namespace itst = iotivity::test;
  58
  59 #define DEFAULT_CONTEXT_VALUE 0x99
  60 #define INVALID_TPS_FLAGS (250)
  61 #define INVALID_TPS_FLAGS_ZERO (0)
  62
  63 //-----------------------------------------------------------------------------
  64 // Private variables
  65 //-----------------------------------------------------------------------------
  66 #define TAG "TestHarness"
  67
  68 char gDeviceUUID[] = "fe3f9a68-4931-4cb0-9ea4-81702b43116c";
  69 char gDevicePIID[] = "32684bf3-4c44-47b0-99fe-6a9a59b73a8d";
  70 char gManufacturerName[] = "myName";
  71 static OCPrm_t pmSel;
  72 static char pinNumber;
  73 static OCDPDev_t peer;
  74
  75 std::chrono::seconds const SHORT_TEST_TIMEOUT = std::chrono::seconds(5);
  76 std::chrono::seconds const LONG_TEST_TIMEOUT = std::chrono::seconds(450);
  77
  78 //-----------------------------------------------------------------------------
  79 // Callback functions
  80 //-----------------------------------------------------------------------------
  81 extern "C"  OCStackApplicationResult asyncDoResourcesCallback(void* ctx,
  82         OCDoHandle /*handle*/, OCClientResponse * clientResponse)
  83 {
  84     OIC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
  85
  86     EXPECT_EQ(OC_STACK_OK, clientResponse->result);
  87
  88     if(ctx == (void*)DEFAULT_CONTEXT_VALUE) {
  89         OIC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
  90     }
  91     OIC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
  92
  93     return OC_STACK_KEEP_TRANSACTION;
  94 }
  95
  96 static void resultCallback(void *UNUSED1, OCDPDev_t *UNUSED2, OCStackResult UNUSED3)
  97 {
  98     (void) (UNUSED1);
  99     (void) (UNUSED2);
 100     (void) (UNUSED3);
 101 }
 102
 103 extern "C" OCStackApplicationResult discoveryCallback(void* ctx,
 104         OCDoHandle /*handle*/, OCClientResponse * clientResponse)
 105 {
 106     OIC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
 107
 108     EXPECT_EQ(OC_STACK_OK, clientResponse->result);
 109
 110     if(ctx == (void*)DEFAULT_CONTEXT_VALUE)
 111     {
 112         OIC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
 113     }
 114
 115     OIC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
 116
 117     OCDiscoveryPayload *discoveryPayload = ((OCDiscoveryPayload *) clientResponse->payload);
 118     EXPECT_TRUE(discoveryPayload != NULL);
 119     OCResourcePayload *res = discoveryPayload->resources;
 120     int count = 0;
 121     for (OCResourcePayload *res1 = discoveryPayload->resources; res1; res1 = res1->next)
 122     {
 123         count++;
 124     }
 125     EXPECT_EQ(3, count);
 126     EXPECT_EQ("/a/led1", res->uri);
 127     res = res->next;
 128     EXPECT_EQ("/a/led2", res->uri);
 129     res = res->next;
 130     EXPECT_EQ("/a/led3", res->uri);
 131     res = res->next;
 132     EXPECT_TRUE(res == NULL);
 133
 134     return OC_STACK_KEEP_TRANSACTION;
 135 }
 136
 137 //-----------------------------------------------------------------------------
 138 // Entity handler
 139 //-----------------------------------------------------------------------------
 140 OCEntityHandlerResult entityHandler(OCEntityHandlerFlag /*flag*/,
 141         OCEntityHandlerRequest * /*entityHandlerRequest*/,
 142         void* /*callbackParam*/)
 143 {
 144     OIC_LOG(INFO, TAG, "Entering entityHandler");
 145
 146     return OC_EH_OK;
 147 }
 148
 149 //-----------------------------------------------------------------------------
 150 //  Local functions
 151 //-----------------------------------------------------------------------------
 152 void InitStack(OCMode mode)
 153 {
 154     OIC_LOG(INFO, TAG, "Entering InitStack");
 155
 156     EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, mode));
 157     OIC_LOG(INFO, TAG, "Leaving InitStack");
 158 }
 159
 160 uint8_t InitNumExpectedResources()
 161 {
 162 #ifdef WITH_PRESENCE
 163     // When presence is enabled, it is a resource and so is (currently) included
 164     // in the returned resource count returned by the OCGetNumberOfResources API.
 165     return 1;
 166 #else
 167     return 0;
 168 #endif
 169 }
 170
 171 uint8_t InitResourceIndex()
 172 {
 173 #ifdef WITH_PRESENCE
 174     // When presence is enabled, it is a resource and so is (currently) included
 175     // in the returned resource count returned by the OCGetNumberOfResources API.
 176     // The index of the presence resource is 0, so the first user app resource index
 177     // is 1.
 178     return 1;
 179 #else
 180     return 0;
 181 #endif
 182 }
 183
 184 extern "C" uint32_t g_ocStackStartCount;
 185
 186 OCDeviceProperties* getTestDeviceProps()
 187 {
 188     OCDeviceProperties* deviceProps = (OCDeviceProperties*)OICCalloc(1, sizeof(OCDeviceProperties));
 189     if (NULL != deviceProps)
 190     {
 191         OICStrcpy(deviceProps->protocolIndependentId, UUID_STRING_SIZE, gDevicePIID);
 192     }
 193
 194     return deviceProps;
 195 }
 196
 197 class OCDiscoverTests : public testing::Test
 198 {
 199     protected:
 200         virtual void SetUp()
 201         {
 202             EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
 203         }
 204
 205         virtual void TearDown()
 206         {
 207             OCStop();
 208         }
 209 };
 210
 211 class OCDevicePropertiesTests : public testing::Test
 212 {
 213 protected:
 214     virtual void SetUp()
 215     {
 216         itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 217     }
 218 };
 219 //-----------------------------------------------------------------------------
 220 //  Tests
 221 //-----------------------------------------------------------------------------
 222
 223 TEST(StackInit, StackInitNullAddr)
 224 {
 225     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 226     EXPECT_EQ(OC_STACK_OK, OCInit(0, 5683, OC_SERVER));
 227     EXPECT_EQ(1u, g_ocStackStartCount);
 228     EXPECT_EQ(OC_STACK_OK, OCStop());
 229     EXPECT_EQ(0u, g_ocStackStartCount);
 230 }
 231
 232 TEST(StackInit, StackInitNullPort)
 233 {
 234     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 235     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 0, OC_SERVER));
 236     EXPECT_EQ(OC_STACK_OK, OCStop());
 237 }
 238
 239 TEST(StackInit, StackInitNullAddrAndPort)
 240 {
 241     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 242     EXPECT_EQ(OC_STACK_OK, OCInit(0, 0, OC_SERVER));
 243     EXPECT_EQ(OC_STACK_OK, OCStop());
 244 }
 245
 246 TEST(StackInit, StackInitInvalidMode)
 247 {
 248     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 249     EXPECT_EQ(OC_STACK_ERROR, OCInit(0, 0, (OCMode)10));
 250     EXPECT_EQ(0u, g_ocStackStartCount);
 251 }
 252
 253 TEST(StackStart, StackStartSuccessClient)
 254 {
 255     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 256     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 257     EXPECT_EQ(OC_STACK_OK, OCStop());
 258 }
 259
 260 TEST(StackStart, StackStartSuccessServer)
 261 {
 262     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 263     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 264     EXPECT_EQ(OC_STACK_OK, OCStop());
 265 }
 266
 267 TEST(StackStart, StackStartSuccessClientServer)
 268 {
 269     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 270     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
 271     EXPECT_EQ(OC_STACK_OK, OCStop());
 272 }
 273
 274 TEST(StackStart, StackStartSuccessServerThenClient)
 275 {
 276     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 277     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 278     EXPECT_EQ(OC_STACK_OK, OCStop());
 279     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 280     EXPECT_EQ(OC_STACK_OK, OCStop());
 281 }
 282
 283 TEST(StackStart, StackStartSuccessClientThenServer)
 284 {
 285     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 286     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 287     EXPECT_EQ(OC_STACK_OK, OCStop());
 288     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 289     EXPECT_EQ(OC_STACK_OK, OCStop());
 290 }
 291
 292 TEST(StackStart, StackStartSuccessiveInits)
 293 {
 294     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 295     EXPECT_EQ(0u, g_ocStackStartCount);
 296     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 297     EXPECT_EQ(1u, g_ocStackStartCount);
 298     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.2", 5683, OC_SERVER));
 299     EXPECT_EQ(2u, g_ocStackStartCount);
 300     EXPECT_EQ(OC_STACK_OK, OCStop());
 301     EXPECT_EQ(1u, g_ocStackStartCount);
 302     EXPECT_EQ(OC_STACK_OK, OCStop());
 303     EXPECT_EQ(0u, g_ocStackStartCount);
 304 }
 305
 306 TEST(StackStart, SetPlatformInfoValid)
 307 {
 308     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 309     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 310
 311     OCPlatformInfo info =
 312     {
 313         gDeviceUUID,
 314         gManufacturerName,
 315         0, 0, 0, 0, 0, 0, 0, 0, 0
 316     };
 317     EXPECT_EQ(OC_STACK_OK, OCSetPlatformInfo(info));
 318     EXPECT_EQ(OC_STACK_OK, OCStop());
 319 }
 320
 321 TEST(StackStart, SetPlatformInfoWithClientMode)
 322 {
 323     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 324     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 325
 326     OCPlatformInfo info =
 327     {
 328         gDeviceUUID,
 329         gManufacturerName,
 330         0, 0, 0, 0, 0, 0, 0, 0, 0
 331     };
 332     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 333     EXPECT_EQ(OC_STACK_OK, OCStop());
 334 }
 335
 336 TEST(StackStart, SetPlatformInfoWithNoPlatformID)
 337 {
 338     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 339     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 340
 341     OCPlatformInfo info =
 342      {
 343          0,
 344          gDeviceUUID,
 345          0, 0, 0, 0, 0, 0, 0, 0, 0
 346      };
 347
 348     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 349     EXPECT_EQ(OC_STACK_OK, OCStop());
 350 }
 351
 352 TEST(StackStart, SetPlatformInfoWithBadPlatformID)
 353 {
 354     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 355     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 356
 357     char invalidId[] = "myDeviceUUID";
 358     OCPlatformInfo info =
 359      {
 360         invalidId,
 361         gManufacturerName,
 362         0, 0, 0, 0, 0, 0, 0, 0, 0
 363      };
 364
 365     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 366     EXPECT_EQ(OC_STACK_OK, OCStop());
 367 }
 368
 369 TEST(StackStart, SetPlatformInfoWithNoManufacturerName)
 370 {
 371     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 372     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 373
 374     OCPlatformInfo info =
 375     {
 376         gDeviceUUID,
 377         0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 378     };
 379
 380     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 381     EXPECT_EQ(OC_STACK_OK, OCStop());
 382 }
 383
 384 TEST(StackStart, SetPlatformInfoWithZeroLengthManufacturerName)
 385 {
 386     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 387     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 388
 389     OCPlatformInfo info =
 390     {
 391         gDeviceUUID,
 392         0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 393     };
 394     info.manufacturerName = (char *) "";
 395
 396     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 397     EXPECT_EQ(OC_STACK_OK, OCStop());
 398 }
 399
 400 TEST(StackStart, SetPlatformInfoWithTooLongManufacName)
 401 {
 402     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 403     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 404     char gTooLongManufacturerName[MAX_PLATFORM_NAME_LENGTH+2];
 405     for (int i = 0; i <= MAX_PLATFORM_NAME_LENGTH; i++ )
 406     {
 407         gTooLongManufacturerName[i] = 'a';
 408     }
 409     gTooLongManufacturerName[MAX_PLATFORM_NAME_LENGTH+1] = '\0';
 410     OCPlatformInfo info =
 411     {
 412         gDeviceUUID,
 413         gTooLongManufacturerName,
 414         0, 0, 0, 0, 0, 0, 0, 0, 0
 415     };
 416
 417     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 418     EXPECT_EQ(OC_STACK_OK, OCStop());
 419 }
 420
 421 TEST(StackStart, SetPlatformInfoWithTooLongManufacURL)
 422 {
 423     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 424     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 425     char gManufacturerUrl[MAX_PLATFORM_URL_LENGTH+2];
 426     for (int i = 0; i <= MAX_PLATFORM_URL_LENGTH; i++ )
 427     {
 428         gManufacturerUrl[i] = 'a';
 429     }
 430     gManufacturerUrl[MAX_PLATFORM_URL_LENGTH+1] = '\0';
 431     OCPlatformInfo info =
 432     {
 433         gDeviceUUID,
 434         gManufacturerName,
 435         gManufacturerUrl,
 436         0, 0, 0, 0, 0, 0, 0, 0
 437     };
 438
 439     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 440     EXPECT_EQ(OC_STACK_OK, OCStop());
 441 }
 442
 443 TEST(StackStart, SetPlatformInfoWithOCSetPropertyValueAPI)
 444 {
 445     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 446     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 447     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, gDeviceUUID));
 448     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, gManufacturerName));
 449     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, "http://www.iotivity.org"));
 450     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, "S777"));
 451     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, "15 Nov, 2016"));
 452     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, "1.1"));
 453     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, "14"));
 454     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, "0.1"));
 455     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, "0.1"));
 456     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, "http://www.iotivity.org"));
 457     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, ""));
 458     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", "value"));
 459     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, NULL, ""));
 460     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL));
 461     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL));
 462     EXPECT_EQ(OC_STACK_OK, OCStop());
 463 }
 464
 465 TEST(StackStart, GetPlatformInfoWithOCGetPropertyValueAPI)
 466 {
 467     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 468     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 469     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, gDeviceUUID));
 470     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, gManufacturerName));
 471     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, "http://www.iotivity.org"));
 472     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, "S777"));
 473     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, "15 Nov, 2016"));
 474     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, "1.1"));
 475     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, "14"));
 476     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, "0.1"));
 477     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, "0.1"));
 478     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, "http://www.iotivity.org"));
 479     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, ""));
 480     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", "value"));
 481
 482     void *value = NULL;
 483     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, &value));
 484     ASSERT_TRUE(value != NULL);
 485     EXPECT_STREQ(gDeviceUUID, (char *)value);
 486     OICFree(value);
 487     value = NULL;
 488
 489     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, &value));
 490     ASSERT_TRUE(value != NULL);
 491     EXPECT_STREQ(gManufacturerName, (char *)value);
 492     OICFree(value);
 493     value = NULL;
 494
 495     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, &value));
 496     ASSERT_TRUE(value != NULL);
 497     EXPECT_STREQ("http://www.iotivity.org", (char *)value);
 498     OICFree(value);
 499     value = NULL;
 500
 501     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, &value));
 502     ASSERT_TRUE(value != NULL);
 503     EXPECT_STREQ("S777", (char *)value);
 504     OICFree(value);
 505     value = NULL;
 506
 507     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, &value));
 508     ASSERT_TRUE(value != NULL);
 509     EXPECT_STREQ("15 Nov, 2016", (char *)value);
 510     OICFree(value);
 511     value = NULL;
 512
 513     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, &value));
 514     ASSERT_TRUE(value != NULL);
 515     EXPECT_STREQ("1.1", (char *)value);
 516     OICFree(value);
 517     value = NULL;
 518
 519     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, &value));
 520     ASSERT_TRUE(value != NULL);
 521     EXPECT_STREQ("14", (char *)value);
 522     OICFree(value);
 523     value = NULL;
 524
 525     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, &value));
 526     ASSERT_TRUE(value != NULL);
 527     EXPECT_STREQ("0.1", (char *)value);
 528     OICFree(value);
 529     value = NULL;
 530
 531     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, &value));
 532     ASSERT_TRUE(value != NULL);
 533     EXPECT_STREQ("0.1", (char *)value);
 534     OICFree(value);
 535     value = NULL;
 536
 537     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, &value));
 538     ASSERT_TRUE(value != NULL);
 539     EXPECT_STREQ("http://www.iotivity.org", (char *)value);
 540     OICFree(value);
 541     value = NULL;
 542
 543     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, &value));
 544     ASSERT_TRUE(value != NULL);
 545     EXPECT_STREQ("", (char *)value);
 546     OICFree(value);
 547     value = NULL;
 548
 549     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", &value));
 550     ASSERT_TRUE(value != NULL);
 551     EXPECT_STREQ("value", (char *)value);
 552     OICFree(value);
 553
 554     EXPECT_EQ(OC_STACK_OK, OCStop());
 555 }
 556
 557 TEST(StackStart, SetDeviceInfoAPI)
 558 {
 559     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 560     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 561     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, "Sample"));
 562     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, "specVersion"));
 563     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", "value"));
 564     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION,
 565         "Data Model Version"));
 566     OCResourceHandle handle = OCGetResourceHandleAtUri(OC_RSRVD_DEVICE_URI);
 567     EXPECT_TRUE(handle != NULL);
 568     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "oic.wk.tv"));
 569     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL));
 570     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, "", NULL));
 571     EXPECT_EQ(OC_STACK_OK, OCStop());
 572 }
 573
 574 TEST(StackStart, GetDeviceInfoAPI)
 575 {
 576     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 577     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 578     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, "Sample"));
 579     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, "specVersion"));
 580     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", "value"));
 581     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION,
 582         "Data Model Version"));
 583     OCResourceHandle handle = OCGetResourceHandleAtUri(OC_RSRVD_DEVICE_URI);
 584     EXPECT_TRUE(handle != NULL);
 585     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "oic.wk.tv"));
 586
 587     void *value = NULL;
 588     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, &value));
 589     ASSERT_TRUE(value != NULL);
 590     EXPECT_STREQ("Sample", (char *)value);
 591     OICFree(value);
 592     value = NULL;
 593
 594     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, &value));
 595     ASSERT_TRUE(value != NULL);
 596     EXPECT_STREQ("specVersion", (char *)value);
 597     OICFree(value);
 598     value = NULL;
 599
 600     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", &value));
 601     ASSERT_TRUE(value != NULL);
 602     EXPECT_STREQ("value", (char *)value);
 603     OICFree(value);
 604     value = NULL;
 605
 606     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION, &value));
 607     ASSERT_TRUE(value != NULL);
 608     ASSERT_TRUE(((OCStringLL *)value)->value != NULL);
 609     EXPECT_STREQ("Data Model Version", ((OCStringLL *)value)->value);
 610     OCFreeOCStringLL((OCStringLL *) value);
 611     value = NULL;
 612
 613     EXPECT_STREQ("oic.wk.d", OCGetResourceTypeName(handle, 0));
 614     EXPECT_STREQ("oic.wk.tv", OCGetResourceTypeName(handle, 1));
 615
 616     EXPECT_EQ(OC_STACK_OK, OCStop());
 617 }
 618
 619 TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery)
 620 {
 621     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 622     OCCallbackData cbData;
 623     OCDoHandle handle;
 624
 625     OIC_LOG(INFO, TAG, "Starting DoResourceDeviceDiscovery test ");
 626     InitStack(OC_CLIENT);
 627
 628     /* Start a discovery query*/
 629     char szQueryUri[MAX_QUERY_LENGTH] = { 0 };
 630     strcpy(szQueryUri, OC_RSRVD_WELL_KNOWN_URI);
 631     cbData.cb = asyncDoResourcesCallback;
 632     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 633     cbData.cd = NULL;
 634     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
 635                                         OC_REST_GET,
 636                                         szQueryUri,
 637                                         0,
 638                                         0,
 639                                         CT_ADAPTER_IP,
 640                                         OC_LOW_QOS,
 641                                         &cbData,
 642                                         NULL,
 643                                         0));
 644     EXPECT_EQ(OC_STACK_OK, OCStop());
 645 }
 646
 647 TEST(StackResource, DISABLED_UpdateResourceNullURI)
 648 {
 649     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 650     OCCallbackData cbData;
 651     OCDoHandle handle;
 652
 653     OIC_LOG(INFO, TAG, "Starting UpdateResourceNullURI test");
 654     InitStack(OC_CLIENT);
 655
 656     /* Start a discovery query*/
 657     char szQueryUri[MAX_QUERY_LENGTH] = { 0 };
 658     strcpy(szQueryUri, OC_RSRVD_WELL_KNOWN_URI);
 659     cbData.cb = asyncDoResourcesCallback;
 660     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 661     cbData.cd = NULL;
 662     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
 663                                         OC_REST_GET,
 664                                         szQueryUri,
 665                                         0,
 666                                         0,
 667                                         CT_ADAPTER_IP,
 668                                         OC_LOW_QOS,
 669                                         &cbData,
 670                                         NULL,
 671                                         0));
 672     EXPECT_EQ(OC_STACK_OK, OCStop());
 673 }
 674
 675 TEST(StackResource, CreateResourceBadParams)
 676 {
 677     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 678     OIC_LOG(INFO, TAG, "Starting CreateResourceBadParams test");
 679     InitStack(OC_SERVER);
 680
 681     OCResourceHandle handle;
 682
 683     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(NULL, //&handle,
 684                                             "core.led",
 685                                             "core.rw",
 686                                             "/a/led",
 687                                             0,
 688                                             NULL,
 689                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 690
 691     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 692                                             NULL, //"core.led",
 693                                             "core.rw",
 694                                             "/a/led",
 695                                             0,
 696                                             NULL,
 697                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 698
 699     // Property bitmask out of range
 700     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 701                                             "core.led",
 702                                             "core.rw",
 703                                             "/a/led",
 704                                             0,
 705                                             NULL,
 706                                             255));// invalid bitmask for OCResourceProperty
 707
 708     EXPECT_EQ(OC_STACK_OK, OCStop());
 709 }
 710
 711 TEST(StackResource, CreateResourceBadUri)
 712 {
 713     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 714     OIC_LOG(INFO, TAG, "Starting CreateResourceBadUri test");
 715     InitStack(OC_SERVER);
 716
 717     const char *uri257 = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVW";
 718
 719     OCResourceHandle handle;
 720
 721     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 722                                             "core.led",
 723                                             "core.rw",
 724                                             NULL, //"/a/led",
 725                                             0,
 726                                             0,
 727                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 728
 729     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 730                                             "core.led",
 731                                             "core.rw",
 732                                             "", //"/a/led",
 733                                             0,
 734                                             0,
 735                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 736
 737     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 738                                             "core.led",
 739                                             "core.rw",
 740                                             uri257, //"/a/led",
 741                                             0,
 742                                             0,
 743                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 744
 745     EXPECT_EQ(OC_STACK_OK, OCStop());
 746 }
 747
 748 TEST(StackResource, CreateResourceSuccess)
 749 {
 750     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 751     OIC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
 752     InitStack(OC_SERVER);
 753
 754     OCResourceHandle handle;
 755     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 756                                             "core.led",
 757                                             "core.rw",
 758                                             "/a/led",
 759                                             0,
 760                                             NULL,
 761                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 762     const char *url = OCGetResourceUri(handle);
 763     EXPECT_STREQ("/a/led", url);
 764
 765     EXPECT_EQ(OC_STACK_OK, OCStop());
 766 }
 767
 768 TEST(StackResource, CreateResourceSuccessWithResourcePolicyPropNone)
 769 {
 770     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 771     OIC_LOG(INFO, TAG, "Starting CreateResourceSuccessWithResourcePolicyPropNone test");
 772     InitStack(OC_SERVER);
 773
 774     OCResourceHandle handle;
 775     // the resource is non-discoverable & non-observable by the client.
 776     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 777                                             "core.led",
 778                                             "core.rw",
 779                                             "/a/led",
 780                                             0,
 781                                             NULL,
 782                                             OC_RES_PROP_NONE));// the resource is non-discoverable &
 783                                                 // non-observable by the client.
 784     const char* url = OCGetResourceUri(handle);
 785     EXPECT_STREQ("/a/led", url);
 786
 787     EXPECT_EQ(OC_STACK_OK, OCStop());
 788 }
 789
 790 TEST(StackResource, CreateResourceWithClientStackMode)
 791 {
 792     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 793     OIC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
 794     InitStack(OC_CLIENT);
 795
 796     OCResourceHandle handle;
 797     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 798                                             "core.led",
 799                                             "core.rw",
 800                                             "/a/led",
 801                                             0,
 802                                             NULL,
 803                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 804
 805     EXPECT_EQ(OC_STACK_OK, OCStop());
 806 }
 807
 808 TEST(StackResource, CreateResourceFailDuplicateUri)
 809 {
 810     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 811     OIC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
 812     InitStack(OC_SERVER);
 813
 814     OCResourceHandle handle;
 815     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 816                                             "core.led",
 817                                             "core.rw",
 818                                             "/a/led",
 819                                             0,
 820                                             NULL,
 821                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 822     const char *url = OCGetResourceUri(handle);
 823     EXPECT_STREQ("/a/led", url);
 824
 825     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 826                                             "core.led",
 827                                             "core.rw",
 828                                             "/a/led",
 829                                             0,
 830                                             NULL,
 831                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 832
 833     EXPECT_EQ(OC_STACK_OK, OCStop());
 834 }
 835
 836 TEST(StackResource, CreateResourceMultipleResources)
 837 {
 838     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 839     OIC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
 840     InitStack(OC_SERVER);
 841
 842     OCResourceHandle handle1;
 843     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 844                                             "core.led",
 845                                             "core.rw",
 846                                             "/a/led1",
 847                                             0,
 848                                             NULL,
 849                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 850
 851     OCResourceHandle handle2;
 852     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 853                                             "core.led",
 854                                             "core.rw",
 855                                             "/a/led2",
 856                                             0,
 857                                             NULL,
 858                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 859     OCResourceHandle handle3;
 860     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 861                                             "core.led",
 862                                             "core.rw",
 863                                             "/a/led3",
 864                                             0,
 865                                             NULL,
 866                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 867
 868     const char *url = OCGetResourceUri(handle1);
 869     EXPECT_STREQ("/a/led1", url);
 870
 871     url = OCGetResourceUri(handle2);
 872     EXPECT_STREQ("/a/led2", url);
 873
 874     url = OCGetResourceUri(handle3);
 875     EXPECT_STREQ("/a/led3", url);
 876
 877     EXPECT_EQ(OC_STACK_OK, OCStop());
 878 }
 879
 880 TEST(StackResource, CreateResourceBadResoureType)
 881 {
 882     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 883     OIC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
 884     InitStack(OC_SERVER);
 885
 886     OCResourceHandle handle;
 887     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 888                                             NULL, //"core.led",
 889                                             "core.rw",
 890                                             "/a/led",
 891                                             0,
 892                                             NULL,
 893                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 894
 895     OCResourceHandle handle2;
 896     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle2,
 897                                             "",
 898                                             "core.rw",
 899                                             "/a/led",
 900                                             0,
 901                                             NULL,
 902                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 903
 904     EXPECT_EQ(OC_STACK_OK, OCStop());
 905 }
 906
 907 TEST(StackResource, CreateResourceGoodResourceType)
 908 {
 909     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 910     OIC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
 911     InitStack(OC_SERVER);
 912
 913     OCResourceHandle handle;
 914     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 915                                             "core.led",
 916                                             "core.rw",
 917                                             "/a/led",
 918                                             0,
 919                                             NULL,
 920                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 921
 922     EXPECT_EQ(OC_STACK_OK, OCStop());
 923 }
 924
 925 TEST(StackResource, CreateResourceWithBadEndpointsFlags)
 926 {
 927     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 928
 929     OIC_LOG(INFO, TAG, "CreateResourceWithEndpointsFlags test");
 930
 931     InitStack(OC_SERVER);
 932
 933     OCResourceHandle handle;
 934     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResourceWithEp(&handle,
 935                                             "core.led",
 936                                             "core.rw",
 937                                             "/a/led",
 938                                             0,
 939                                             NULL,
 940                                             OC_DISCOVERABLE|OC_OBSERVABLE,
 941                                             (OCTpsSchemeFlags)INVALID_TPS_FLAGS));
 942
 943     EXPECT_EQ(OC_STACK_OK, OCStop());
 944 }
 945
 946 TEST(StackResource, CreateResourceWithGoodEndpointsFlags)
 947 {
 948     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 949
 950     OIC_LOG(INFO, TAG, "CreateResourceWithEndpointsFlags test");
 951
 952     InitStack(OC_SERVER);
 953
 954     OCResourceHandle handle;
 955     EXPECT_EQ(OC_STACK_OK, OCCreateResourceWithEp(&handle,
 956                                             "core.led",
 957                                             "core.rw",
 958                                             "/a/led",
 959                                             0,
 960                                             NULL,
 961                                             OC_DISCOVERABLE|OC_OBSERVABLE,
 962                                             OC_ALL));
 963     OCResourceHandle handle2;
 964     EXPECT_EQ(OC_STACK_OK, OCCreateResourceWithEp(&handle2,
 965                                             "core.led",
 966                                             "core.rw",
 967                                             "/a/led2",
 968                                             0,
 969                                             NULL,
 970                                             OC_DISCOVERABLE|OC_OBSERVABLE,
 971                                             OC_COAP));
 972 #ifdef TCP_ADAPTER
 973     OCResourceHandle handle3;
 974     EXPECT_EQ(OC_STACK_OK, OCCreateResourceWithEp(&handle3,
 975                                             "core.led",
 976                                             "core.rw",
 977                                             "/a/led3",
 978                                             0,
 979                                             NULL,
 980                                             OC_DISCOVERABLE|OC_OBSERVABLE,
 981                                             OC_COAP_TCP));
 982
 983     OCResourceHandle handle4;
 984     EXPECT_EQ(OC_STACK_OK, OCCreateResourceWithEp(&handle4,
 985                                             "core.led",
 986                                             "core.rw",
 987                                             "/a/led4",
 988                                             0,
 989                                             NULL,
 990                                             OC_DISCOVERABLE|OC_OBSERVABLE,
 991                                             (OCTpsSchemeFlags)(OC_COAP | OC_COAP_TCP)));
 992 #endif
 993
 994     EXPECT_EQ(OC_STACK_OK, OCStop());
 995 }
 996
 997 TEST(StackResource, ResourceTypeName)
 998 {
 999     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1000     OIC_LOG(INFO, TAG, "Starting ResourceTypeName test");
1001     InitStack(OC_SERVER);
1002
1003     OCResourceHandle handle;
1004     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1005                                             "core.led",
1006                                             "core.rw",
1007                                             "/a/led",
1008                                             0,
1009                                             NULL,
1010                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1011
1012     uint8_t numResourceTypes;
1013     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1014     EXPECT_EQ(1, numResourceTypes);
1015     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1016     EXPECT_STREQ("core.led", resourceTypeName);
1017
1018     // try getting resource type names with an invalid index
1019     resourceTypeName = OCGetResourceTypeName(handle, 1);
1020     EXPECT_STREQ(NULL, resourceTypeName);
1021     // try getting resource type names with an invalid index
1022     resourceTypeName = OCGetResourceTypeName(handle, 10);
1023     EXPECT_STREQ(NULL, resourceTypeName);
1024
1025     EXPECT_EQ(OC_STACK_OK, OCStop());
1026 }
1027
1028 TEST(StackResource, ResourceTypeAttrRepresentation)
1029 {
1030     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1031     OIC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
1032     InitStack(OC_SERVER);
1033
1034     OCResourceHandle handle;
1035     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1036                                             "core.led",
1037                                             "core.rw",
1038                                             "/a/led",
1039                                             0,
1040                                             NULL,
1041                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1042
1043     uint8_t numResourceTypes;
1044     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1045     EXPECT_EQ(1, numResourceTypes);
1046
1047     EXPECT_EQ(OC_STACK_OK, OCStop());
1048 }
1049
1050 TEST(StackResource, ResourceTypeInterface)
1051 {
1052     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1053     OIC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
1054     InitStack(OC_SERVER);
1055
1056     OCResourceHandle handle;
1057     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1058                                             "core.led",
1059                                             "core.rw",
1060                                             "/a/led",
1061                                             0,
1062                                             NULL,
1063                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1064
1065     uint8_t numResourceInterfaces;
1066     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1067     EXPECT_EQ(2, numResourceInterfaces);
1068     const char *resourceInterfaceName1 = OCGetResourceInterfaceName(handle, 0);
1069     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, resourceInterfaceName1);
1070     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1071     EXPECT_STREQ("core.rw", resourceInterfaceName);
1072
1073     // try getting resource interface names with an invalid index
1074     resourceInterfaceName = OCGetResourceInterfaceName(handle, 2);
1075     EXPECT_STREQ(NULL, resourceInterfaceName);
1076     // try getting resource interface names with an invalid index
1077     resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
1078     EXPECT_STREQ(NULL, resourceInterfaceName);
1079
1080     EXPECT_EQ(OC_STACK_OK, OCStop());
1081 }
1082
1083 TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
1084 {
1085     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1086
1087     OIC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
1088
1089     InitStack(OC_SERVER);
1090
1091     OCResourceHandle handle;
1092     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1093                                             "core.led",
1094                                             "core.rw",
1095                                             "/a/led",
1096                                             0,
1097                                             NULL,
1098                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1099     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1100                                         OC_RSRVD_INTERFACE_DEFAULT));
1101     uint8_t numResourceInterfaces;
1102     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1103     EXPECT_EQ(2, numResourceInterfaces);
1104
1105     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
1106     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
1107
1108     const char*interfaceName_2 = OCGetResourceInterfaceName(handle, 1);
1109     EXPECT_STREQ("core.rw", interfaceName_2);
1110
1111     EXPECT_EQ(OC_STACK_OK, OCStop());
1112 }
1113
1114 TEST(StackResource, ResourceDuplicateDefaultInterfaces)
1115 {
1116     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1117
1118     OIC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
1119
1120     InitStack(OC_SERVER);
1121
1122     OCResourceHandle handle;
1123     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1124                                             "core.led",
1125                                             "core.rw",
1126                                             "/a/led",
1127                                             0,
1128                                             NULL,
1129                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1130
1131     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1132                                         OC_RSRVD_INTERFACE_DEFAULT));
1133     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1134                                         OC_RSRVD_INTERFACE_DEFAULT));
1135
1136     uint8_t numResourceInterfaces;
1137     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1138     EXPECT_EQ(2, numResourceInterfaces);
1139
1140     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
1141     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
1142
1143     EXPECT_EQ(OC_STACK_OK, OCStop());
1144 }
1145
1146 TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
1147 {
1148     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1149
1150     OIC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
1151
1152     InitStack(OC_SERVER);
1153
1154     OCResourceHandle handle;
1155     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1156                                             "core.led",
1157                                             "core.rw",
1158                                             "/a/led",
1159                                             0,
1160                                             NULL,
1161                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1162
1163     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1164                                         "core.rw"));
1165     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1166                                         "core.rw"));
1167
1168     uint8_t numResourceInterfaces;
1169     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1170     EXPECT_EQ(2, numResourceInterfaces);
1171
1172     EXPECT_EQ(OC_STACK_OK, OCStop());
1173 }
1174
1175 TEST(StackResource, ResourceTypeInterfaceMethods)
1176 {
1177     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1178     OIC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
1179     InitStack(OC_SERVER);
1180
1181     OCResourceHandle handle;
1182     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1183                                             "core.led",
1184                                             "core.rw",
1185                                             "/a/led",
1186                                             0,
1187                                             NULL,
1188                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1189
1190     uint8_t numResourceInterfaces;
1191     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1192     EXPECT_EQ(2, numResourceInterfaces);
1193
1194     EXPECT_EQ(OC_STACK_OK, OCStop());
1195 }
1196
1197 TEST(StackResource, GetResourceProperties)
1198 {
1199     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1200     OIC_LOG(INFO, TAG, "Starting GetResourceProperties test");
1201     InitStack(OC_SERVER);
1202
1203     OCResourceHandle handle;
1204     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1205                                             "core.led",
1206                                             "core.rw",
1207                                             "/a/led",
1208                                             0,
1209                                             NULL,
1210                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1211
1212 #ifdef MQ_PUBLISHER
1213     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE|OC_MQ_PUBLISHER, OCGetResourceProperties(handle));
1214 #else
1215     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
1216 #endif
1217     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1218
1219     EXPECT_EQ(OC_STACK_OK, OCStop());
1220 }
1221
1222 TEST(StackResource, SetResourceProperties)
1223 {
1224     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1225     OIC_LOG(INFO, TAG, "Starting SetResourceProperties test");
1226     InitStack(OC_SERVER);
1227
1228     OCResourceHandle handle;
1229     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1230                                             "core.led",
1231                                             "core.rw",
1232                                             "/a/led",
1233                                             0,
1234                                             NULL,
1235                                             0));
1236
1237     EXPECT_EQ(OC_STACK_OK, OCSetResourceProperties(handle, OC_DISCOVERABLE|OC_OBSERVABLE));
1238 #ifdef MQ_PUBLISHER
1239     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE|OC_MQ_PUBLISHER, OCGetResourceProperties(handle));
1240 #else
1241     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
1242 #endif
1243
1244     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1245
1246     EXPECT_EQ(OC_STACK_OK, OCStop());
1247 }
1248
1249 TEST(StackResource, ClearResourceProperties)
1250 {
1251     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1252     OIC_LOG(INFO, TAG, "Starting ClearResourceProperties test");
1253     InitStack(OC_SERVER);
1254
1255     OCResourceHandle handle;
1256     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1257                                             "core.led",
1258                                             "core.rw",
1259                                             "/a/led",
1260                                             0,
1261                                             NULL,
1262                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1263
1264     EXPECT_EQ(OC_STACK_OK, OCClearResourceProperties(handle, OC_DISCOVERABLE|OC_OBSERVABLE));
1265 #ifdef MQ_PUBLISHER
1266     EXPECT_EQ(OC_ACTIVE|OC_MQ_PUBLISHER, OCGetResourceProperties(handle));
1267 #else
1268     EXPECT_EQ(OC_ACTIVE, OCGetResourceProperties(handle));
1269 #endif
1270
1271     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1272
1273     EXPECT_EQ(OC_STACK_OK, OCStop());
1274 }
1275
1276 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
1277 {
1278     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1279     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
1280     InitStack(OC_SERVER);
1281     uint8_t numResources = 0;
1282     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1283
1284     OCResourceHandle handle;
1285     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1286                                             "core.led",
1287                                             "core.rw",
1288                                             "/a1/led",
1289                                             0,
1290                                             NULL,
1291                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1292     const char *url = OCGetResourceUri(handle);
1293     EXPECT_STREQ("/a1/led", url);
1294
1295     //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
1296     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1297     uint8_t numExpectedResources = 0;
1298
1299     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1300     EXPECT_EQ(numExpectedResources, numResources);
1301
1302     EXPECT_EQ(OC_STACK_OK, OCStop());
1303 }
1304
1305 TEST(StackResource, StackTestResourceDiscoverOneResource)
1306 {
1307     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1308     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
1309     InitStack(OC_SERVER);
1310
1311     OCResourceHandle handle;
1312     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1313                                             "core.led",
1314                                             "core.rw",
1315                                             "/a/led",
1316                                             0,
1317                                             NULL,
1318                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1319     const char *url = OCGetResourceUri(handle);
1320     EXPECT_STREQ("/a/led", url);
1321
1322     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1323     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1324
1325     EXPECT_EQ(OC_STACK_OK, OCStop());
1326 }
1327
1328 TEST(StackResource, StackTestResourceDiscoverManyResources)
1329 {
1330     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1331     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
1332     InitStack(OC_SERVER);
1333
1334     OCResourceHandle handle1;
1335     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1336                                             "core.led",
1337                                             "core.rw",
1338                                             "/a/led1",
1339                                             0,
1340                                             NULL,
1341                                             OC_DISCOVERABLE));
1342     const char *url = OCGetResourceUri(handle1);
1343     EXPECT_STREQ("/a/led1", url);
1344
1345     OCResourceHandle handle2;
1346     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1347                                             "core.led",
1348                                             "core.rw",
1349                                             "/a/led2",
1350                                             0,
1351                                             NULL,
1352                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1353     url = OCGetResourceUri(handle2);
1354     EXPECT_STREQ("/a/led2", url);
1355
1356     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
1357     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
1358
1359     OCResourceHandle handle3;
1360     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1361                                             "core.led",
1362                                             "core.rw",
1363                                             "/a/led3",
1364                                             0,
1365                                             NULL,
1366                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1367     url = OCGetResourceUri(handle3);
1368     EXPECT_STREQ("/a/led3", url);
1369
1370     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
1371     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
1372
1373     OCResourceHandle handle4;
1374     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1375                                             "core.led",
1376                                             "core.rw",
1377                                             "/a/led4",
1378                                             0,
1379                                             NULL,
1380                                             OC_DISCOVERABLE));
1381     url = OCGetResourceUri(handle4);
1382     EXPECT_STREQ("/a/led4", url);
1383
1384     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
1385     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
1386     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
1387
1388     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1389
1390     EXPECT_EQ(OC_STACK_OK, OCStop());
1391 }
1392
1393 TEST_F(OCDevicePropertiesTests, DevicePropertiesToCBORPayloadllNULL)
1394 {
1395     EXPECT_EQ(OC_STACK_INVALID_PARAM, DevicePropertiesToCBORPayload(NULL, NULL, NULL));
1396 }
1397
1398 TEST_F(OCDevicePropertiesTests, DevicePropertiesToCBORPayloadNULLPayload)
1399 {
1400     OCDeviceProperties* deviceProps = getTestDeviceProps();
1401     ASSERT_TRUE(NULL != deviceProps);
1402     size_t size = 0;
1403
1404     EXPECT_EQ(OC_STACK_INVALID_PARAM, DevicePropertiesToCBORPayload(deviceProps, NULL, &size));
1405
1406     CleanUpDeviceProperties(&deviceProps);
1407 }
1408
1409 TEST_F(OCDevicePropertiesTests, DevicePropertiesToCBORPayloadNULLSize)
1410 {
1411     OCDeviceProperties* deviceProps = getTestDeviceProps();
1412     ASSERT_TRUE(NULL != deviceProps);
1413     uint8_t* payload = NULL;
1414
1415     EXPECT_EQ(OC_STACK_INVALID_PARAM, DevicePropertiesToCBORPayload(deviceProps, &payload, NULL));
1416
1417     CleanUpDeviceProperties(&deviceProps);
1418 }
1419
1420 TEST_F(OCDevicePropertiesTests, DevicePropertiesToCBORPayloadNULLDeviceProperties)
1421 {
1422     uint8_t* payload = NULL;
1423     size_t size = 0;
1424
1425     EXPECT_EQ(OC_STACK_INVALID_PARAM, DevicePropertiesToCBORPayload(NULL, &payload, &size));
1426 }
1427
1428 TEST_F(OCDevicePropertiesTests, DevicePropertiesToCBORPayloadVALID)
1429 {
1430     OCDeviceProperties* deviceProps = getTestDeviceProps();
1431     ASSERT_TRUE(NULL != deviceProps);
1432     uint8_t* payload = NULL;
1433     size_t size = 0;
1434
1435     EXPECT_EQ(OC_STACK_OK, DevicePropertiesToCBORPayload(deviceProps, &payload, &size));
1436     EXPECT_TRUE(payload != NULL);
1437
1438     CleanUpDeviceProperties(&deviceProps);
1439     OICFree(payload);
1440 }
1441
1442 TEST_F(OCDevicePropertiesTests, CBORPayloadToDevicePropertiesAllNULL)
1443 {
1444     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToDeviceProperties(NULL, 0, NULL));
1445 }
1446
1447 TEST_F(OCDevicePropertiesTests, CBORPayloadToDevicePropertiesNULLPayload)
1448 {
1449     OCDeviceProperties* deviceProps = NULL;
1450     size_t size = 10;
1451
1452     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToDeviceProperties(NULL, size, &deviceProps));
1453 }
1454
1455 TEST_F(OCDevicePropertiesTests, CBORPayloadToDevicePropertiesInvalidSize)
1456 {
1457     OCDeviceProperties* deviceProps = NULL;
1458     uint8_t* payload = (uint8_t*)OICCalloc(1, sizeof(uint8_t));
1459     ASSERT_TRUE(NULL != payload);
1460
1461     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToDeviceProperties(payload, 0, &deviceProps));
1462
1463     OICFree(payload);
1464 }
1465
1466 TEST_F(OCDevicePropertiesTests, CBORPayloadToDevicePropertiesNULLDeviceProperties)
1467 {
1468     uint8_t* payload = (uint8_t*)OICCalloc(1, sizeof(uint8_t));
1469     ASSERT_TRUE(NULL != payload);
1470     size_t size = 10;
1471
1472     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToDeviceProperties(payload, size, NULL));
1473
1474     OICFree(payload);
1475 }
1476
1477 TEST_F(OCDevicePropertiesTests, CBORPayloadToDevicePropertiesVALID)
1478 {
1479     OCDeviceProperties* controlDeviceProps = getTestDeviceProps();
1480     ASSERT_TRUE(NULL != controlDeviceProps);
1481     OCDeviceProperties* testDeviceProps = NULL;
1482     uint8_t* payload = NULL;
1483     size_t size = 0;
1484
1485     EXPECT_EQ(OC_STACK_OK, DevicePropertiesToCBORPayload(controlDeviceProps, &payload, &size));
1486     EXPECT_TRUE(payload != NULL);
1487
1488     EXPECT_EQ(OC_STACK_OK, CBORPayloadToDeviceProperties(payload, size, &testDeviceProps));
1489     ASSERT_TRUE(testDeviceProps != NULL);
1490     EXPECT_STREQ(gDevicePIID, testDeviceProps->protocolIndependentId);
1491
1492     CleanUpDeviceProperties(&controlDeviceProps);
1493     CleanUpDeviceProperties(&testDeviceProps);
1494     OICFree(payload);
1495 }
1496
1497 TEST_F(OCDevicePropertiesTests, PIIDAvailableAfterInit)
1498 {
1499     void *piid = NULL;
1500
1501     InitStack(OC_SERVER);
1502
1503     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_PROTOCOL_INDEPENDENT_ID, &piid));
1504     ASSERT_TRUE(piid != NULL);
1505
1506     OICFree(piid);
1507
1508     EXPECT_EQ(OC_STACK_OK, OCStop());
1509 }
1510
1511 TEST_F(OCDevicePropertiesTests, UpdatePIID)
1512 {
1513     void *originalPIID = NULL;
1514     void *newPIID = NULL;
1515
1516     InitStack(OC_SERVER);
1517
1518     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_PROTOCOL_INDEPENDENT_ID, &originalPIID));
1519     ASSERT_TRUE(originalPIID != NULL);
1520
1521     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_PROTOCOL_INDEPENDENT_ID, gDevicePIID));
1522
1523     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_PROTOCOL_INDEPENDENT_ID, &newPIID));
1524     ASSERT_TRUE(newPIID != NULL);
1525     EXPECT_STREQ(gDevicePIID, (char *)newPIID);
1526     EXPECT_STRNE((char *)originalPIID, (char *)newPIID);
1527
1528     OICFree(newPIID);
1529     OICFree(originalPIID);
1530
1531     EXPECT_EQ(OC_STACK_OK, OCStop());
1532 }
1533
1534 TEST(StackBind, BindResourceTypeNameBad)
1535 {
1536     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1537     OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
1538     InitStack(OC_SERVER);
1539
1540     OCResourceHandle handle;
1541     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1542                                             "core.led",
1543                                             "core.rw",
1544                                             "/a/led",
1545                                             0,
1546                                             NULL,
1547                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1548
1549     uint8_t numResourceTypes;
1550     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1551     EXPECT_EQ(1, numResourceTypes);
1552     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1553     EXPECT_STREQ("core.led", resourceTypeName);
1554
1555     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
1556     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, "core.nameBad"));
1557     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, "core.name bad"));
1558
1559     EXPECT_EQ(OC_STACK_OK, OCStop());
1560 }
1561
1562 TEST(StackBind, BindResourceTypeNameGood)
1563 {
1564     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1565     OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
1566     InitStack(OC_SERVER);
1567
1568     OCResourceHandle handle;
1569     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1570                                             "core.led",
1571                                             "core.rw",
1572                                             "/a/led",
1573                                             0,
1574                                             NULL,
1575                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1576
1577     uint8_t numResourceTypes;
1578     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1579     EXPECT_EQ(1, numResourceTypes);
1580     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1581     EXPECT_STREQ("core.led", resourceTypeName);
1582
1583     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1584     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1585     EXPECT_EQ(2, numResourceTypes);
1586     resourceTypeName = OCGetResourceTypeName(handle, 1);
1587     EXPECT_STREQ("core.brightled", resourceTypeName);
1588
1589     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1590     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1591     EXPECT_EQ(3, numResourceTypes);
1592     resourceTypeName = OCGetResourceTypeName(handle, 2);
1593     EXPECT_STREQ("core.reallybrightled", resourceTypeName);
1594
1595     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "x.ReallyReallyBrightLED"));
1596     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1597     EXPECT_EQ(4, numResourceTypes);
1598     resourceTypeName = OCGetResourceTypeName(handle, 3);
1599     EXPECT_STREQ("x.ReallyReallyBrightLED", resourceTypeName);
1600
1601     EXPECT_EQ(OC_STACK_OK, OCStop());
1602 }
1603
1604 TEST(StackBind, BindResourceTypeAttribRepGood)
1605 {
1606     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1607     OIC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
1608     InitStack(OC_SERVER);
1609
1610     OCResourceHandle handle;
1611     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1612                                             "core.led",
1613                                             "core.rw",
1614                                             "/a/led",
1615                                             0,
1616                                             NULL,
1617                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1618
1619     uint8_t numResourceTypes;
1620     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1621     EXPECT_EQ(1, numResourceTypes);
1622
1623     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1624     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1625     EXPECT_EQ(2, numResourceTypes);
1626
1627     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1628     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1629     EXPECT_EQ(3, numResourceTypes);
1630
1631     EXPECT_EQ(OC_STACK_OK, OCStop());
1632 }
1633
1634
1635 TEST(StackBind, BindResourceInterfaceNameBad)
1636 {
1637     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1638     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
1639     InitStack(OC_SERVER);
1640
1641     OCResourceHandle handle;
1642     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1643                                             "core.led",
1644                                             "core.rw",
1645                                             "/a/led",
1646                                             0,
1647                                             NULL,
1648                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1649
1650     uint8_t numResourceInterfaces;
1651     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1652     EXPECT_EQ(2, numResourceInterfaces);
1653     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1654     EXPECT_STREQ("core.rw", resourceInterfaceName);
1655
1656     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
1657
1658     EXPECT_EQ(OC_STACK_OK, OCStop());
1659 }
1660
1661 TEST(StackBind, BindResourceInterfaceNameGood)
1662 {
1663     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1664     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
1665     InitStack(OC_SERVER);
1666
1667     OCResourceHandle handle;
1668     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1669                                             "core.led",
1670                                             "core.rw",
1671                                             "/a/led",
1672                                             0,
1673                                             NULL,
1674                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1675
1676     uint8_t numResourceInterfaces;
1677     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1678     EXPECT_EQ(2, numResourceInterfaces);
1679     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1680     EXPECT_STREQ("core.rw", resourceInterfaceName);
1681
1682     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1683
1684     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1685     EXPECT_EQ(3, numResourceInterfaces);
1686     resourceInterfaceName = OCGetResourceInterfaceName(handle, 2);
1687     EXPECT_STREQ("core.r", resourceInterfaceName);
1688
1689     EXPECT_EQ(OC_STACK_OK, OCStop());
1690 }
1691
1692 TEST(StackBind, BindResourceInterfaceMethodsBad)
1693 {
1694     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1695     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
1696     InitStack(OC_SERVER);
1697
1698     OCResourceHandle handle;
1699     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1700                                             "core.led",
1701                                             "core.rw",
1702                                             "/a/led",
1703                                             0,
1704                                             NULL,
1705                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1706
1707     uint8_t numResourceInterfaces;
1708     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1709     EXPECT_EQ(2, numResourceInterfaces);
1710
1711     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
1712
1713     EXPECT_EQ(OC_STACK_OK, OCStop());
1714 }
1715
1716 TEST(StackBind, BindResourceInterfaceMethodsGood)
1717 {
1718     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1719     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
1720     InitStack(OC_SERVER);
1721
1722     OCResourceHandle handle;
1723     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1724                                             "core.led",
1725                                             "core.rw",
1726                                             "/a/led",
1727                                             0,
1728                                             NULL,
1729                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1730
1731     uint8_t numResourceInterfaces;
1732     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1733     EXPECT_EQ(2, numResourceInterfaces);
1734
1735     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1736
1737     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1738     EXPECT_EQ(3, numResourceInterfaces);
1739
1740     EXPECT_EQ(OC_STACK_OK, OCStop());
1741 }
1742
1743 TEST(StackBind, BindContainedResourceBad)
1744 {
1745     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1746     OIC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
1747     InitStack(OC_SERVER);
1748
1749     OCResourceHandle containerHandle;
1750     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1751                                             "core.led",
1752                                             "core.rw",
1753                                             "/a/kitchen",
1754                                             0,
1755                                             NULL,
1756                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1757
1758     OCResourceHandle handle0;
1759     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1760                                             "core.led",
1761                                             "core.rw",
1762                                             "/a/led",
1763                                             0,
1764                                             NULL,
1765                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1766
1767     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1768
1769     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1770
1771     EXPECT_EQ(OC_STACK_OK, OCStop());
1772 }
1773
1774 TEST(StackBind, BindContainedResourceGood)
1775 {
1776     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1777     OIC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1778     InitStack(OC_SERVER);
1779
1780     uint8_t numResources = 0;
1781     uint8_t numExpectedResources = 0;
1782
1783     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1784
1785     OCResourceHandle containerHandle;
1786     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1787                                             "core.led",
1788                                             "core.rw",
1789                                             "/a/kitchen",
1790                                             0,
1791                                             NULL,
1792                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1793     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1794     EXPECT_EQ(++numExpectedResources, numResources);
1795
1796     OCResourceHandle handle0;
1797     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1798                                             "core.led",
1799                                             "core.rw",
1800                                             "/a/led0",
1801                                             0,
1802                                             NULL,
1803                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1804     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1805     EXPECT_EQ(++numExpectedResources, numResources);
1806
1807     OCResourceHandle handle1;
1808     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1809                                             "core.led",
1810                                             "core.rw",
1811                                             "/a/led1",
1812                                             0,
1813                                             NULL,
1814                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1815     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1816     EXPECT_EQ(++numExpectedResources, numResources);
1817
1818     OCResourceHandle handle2;
1819     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1820                                             "core.led",
1821                                             "core.rw",
1822                                             "/a/led2",
1823                                             0,
1824                                             NULL,
1825                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1826     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1827     EXPECT_EQ(++numExpectedResources, numResources);
1828
1829     OCResourceHandle handle3;
1830     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1831                                             "core.led",
1832                                             "core.rw",
1833                                             "/a/led3",
1834                                             0,
1835                                             NULL,
1836                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1837     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1838     EXPECT_EQ(++numExpectedResources, numResources);
1839
1840     OCResourceHandle handle4;
1841     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1842                                             "core.led",
1843                                             "core.rw",
1844                                             "/a/led4",
1845                                             0,
1846                                             NULL,
1847                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1848     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1849     EXPECT_EQ(++numExpectedResources, numResources);
1850
1851     OCResourceHandle handle5;
1852     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1853                                             "core.led",
1854                                             "core.rw",
1855                                             "/a/led5",
1856                                             0,
1857                                             NULL,
1858                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1859     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1860     EXPECT_EQ(++numExpectedResources, numResources);
1861
1862
1863     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1864     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1865     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1866     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1867     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1868     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle5));
1869
1870     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1871     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1872     EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1873     EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1874     EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1875     EXPECT_EQ(handle5, OCGetResourceHandleFromCollection(containerHandle, 5));
1876
1877     EXPECT_EQ(OC_STACK_OK, OCStop());
1878 }
1879
1880
1881 TEST(StackBind, BindEntityHandlerBad)
1882 {
1883     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1884     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1885     InitStack(OC_SERVER);
1886
1887     OCResourceHandle handle;
1888     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1889                                             "core.led",
1890                                             "core.rw",
1891                                             "/a/led",
1892                                             0,
1893                                             NULL,
1894                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1895
1896     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
1897
1898     EXPECT_EQ(OC_STACK_OK, OCStop());
1899 }
1900
1901 TEST(StackBind, BindEntityHandlerGood)
1902 {
1903     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1904     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1905     InitStack(OC_SERVER);
1906
1907     OCResourceHandle handle;
1908     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1909                                             "core.led",
1910                                             "core.rw",
1911                                             "/a/led",
1912                                             0,
1913                                             NULL,
1914                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1915
1916     OCEntityHandler myHandler = entityHandler;
1917
1918     EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
1919
1920     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1921
1922     EXPECT_EQ(OC_STACK_OK, OCStop());
1923 }
1924
1925 TEST(StackResourceAccess, GetResourceByIndex)
1926 {
1927     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1928     OIC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1929     InitStack(OC_SERVER);
1930
1931     uint8_t numResources = 0;
1932     uint8_t numExpectedResources = 0;
1933     uint8_t resourceIndex = 0;
1934     uint8_t prevResources = 0;
1935     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1936     prevResources = numExpectedResources;
1937     OCResourceHandle containerHandle;
1938     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1939                                             "core.led",
1940                                             "core.rw",
1941                                             "/a/kitchen",
1942                                             0,
1943                                             NULL,
1944                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1945     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1946     EXPECT_EQ(++numExpectedResources, numResources);
1947
1948     OCResourceHandle handle0;
1949     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1950                                             "core.led",
1951                                             "core.rw",
1952                                             "/a/led0",
1953                                             0,
1954                                             NULL,
1955                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1956     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1957     EXPECT_EQ(++numExpectedResources, numResources);
1958
1959     OCResourceHandle handle1;
1960     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1961                                             "core.led",
1962                                             "core.rw",
1963                                             "/a/led1",
1964                                             0,
1965                                             NULL,
1966                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1967     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1968     EXPECT_EQ(++numExpectedResources, numResources);
1969
1970     OCResourceHandle handle2;
1971     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1972                                             "core.led",
1973                                             "core.rw",
1974                                             "/a/led2",
1975                                             0,
1976                                             NULL,
1977                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1978     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1979     EXPECT_EQ(++numExpectedResources, numResources);
1980
1981     OCResourceHandle handle3;
1982     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1983                                             "core.led",
1984                                             "core.rw",
1985                                             "/a/led3",
1986                                             0,
1987                                             NULL,
1988                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1989     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1990     EXPECT_EQ(++numExpectedResources, numResources);
1991
1992     OCResourceHandle handle4;
1993     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1994                                             "core.led",
1995                                             "core.rw",
1996                                             "/a/led4",
1997                                             0,
1998                                             NULL,
1999                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2000     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2001     EXPECT_EQ(++numExpectedResources, numResources);
2002
2003     OCResourceHandle handle5;
2004     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
2005                                             "core.led",
2006                                             "core.rw",
2007                                             "/a/led5",
2008                                             0,
2009                                             NULL,
2010                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2011     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2012     EXPECT_EQ(++numExpectedResources, numResources);
2013     resourceIndex += prevResources;
2014     EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
2015     EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
2016     EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
2017     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
2018     EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
2019     EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
2020     EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
2021
2022     EXPECT_EQ(OC_STACK_OK, OCStop());
2023 }
2024
2025 TEST(StackResourceAccess, DeleteHeadResource)
2026 {
2027     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2028     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
2029     InitStack(OC_SERVER);
2030
2031     uint8_t numResources = 0;
2032     uint8_t numExpectedResources = 0;
2033
2034     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
2035
2036     OCResourceHandle handle0;
2037     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
2038                                             "core.led",
2039                                             "core.rw",
2040                                             "/a/led0",
2041                                             0,
2042                                             NULL,
2043                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2044     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2045     EXPECT_EQ(++numExpectedResources, numResources);
2046
2047     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
2048     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2049     EXPECT_EQ(--numExpectedResources, numResources);
2050
2051     EXPECT_EQ(OC_STACK_OK, OCStop());
2052 }
2053
2054 TEST(StackResourceAccess, DeleteHeadResource2)
2055 {
2056     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2057     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
2058     InitStack(OC_SERVER);
2059
2060     uint8_t numResources = 0;
2061     uint8_t numExpectedResources = 0;
2062
2063     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
2064     OCResourceHandle handle0;
2065     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
2066                                             "core.led",
2067                                             "core.rw",
2068                                             "/a/led0",
2069                                             0,
2070                                             NULL,
2071                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2072     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2073     EXPECT_EQ(++numExpectedResources, numResources);
2074
2075     OCResourceHandle handle1;
2076     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
2077                                             "core.led",
2078                                             "core.rw",
2079                                             "/a/led1",
2080                                             0,
2081                                             NULL,
2082                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2083     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2084     EXPECT_EQ(++numExpectedResources, numResources);
2085
2086     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
2087     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2088     EXPECT_EQ(--numExpectedResources, numResources);
2089
2090     EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
2091
2092     EXPECT_EQ(OC_STACK_OK, OCStop());
2093 }
2094
2095
2096 TEST(StackResourceAccess, DeleteLastResource)
2097 {
2098     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2099     OIC_LOG(INFO, TAG, "Starting DeleteLastResource test");
2100     InitStack(OC_SERVER);
2101
2102     uint8_t numResources = 0;
2103     uint8_t numExpectedResources = 0;
2104
2105     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
2106
2107     OCResourceHandle handle0;
2108     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
2109                                             "core.led",
2110                                             "core.rw",
2111                                             "/a/led0",
2112                                             0,
2113                                             NULL,
2114                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2115     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2116     EXPECT_EQ(++numExpectedResources, numResources);
2117
2118     OCResourceHandle handle1;
2119     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
2120                                             "core.led",
2121                                             "core.rw",
2122                                             "/a/led1",
2123                                             0,
2124                                             NULL,
2125                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2126     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2127     EXPECT_EQ(++numExpectedResources, numResources);
2128
2129     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
2130     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2131     EXPECT_EQ(--numExpectedResources, numResources);
2132
2133     EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
2134
2135     OCResourceHandle handle2;
2136     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
2137                                             "core.led",
2138                                             "core.rw",
2139                                             "/a/led2",
2140                                             0,
2141                                             NULL,
2142                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2143     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2144     EXPECT_EQ(++numExpectedResources, numResources);
2145
2146     EXPECT_EQ(OC_STACK_OK, OCStop());
2147 }
2148
2149 TEST(StackResourceAccess, DeleteMiddleResource)
2150 {
2151     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2152     OIC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
2153     InitStack(OC_SERVER);
2154
2155     uint8_t numResources = 0;
2156     uint8_t numExpectedResources = 0;
2157     uint8_t resourceIndex = InitResourceIndex();
2158
2159     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
2160     resourceIndex = numExpectedResources;
2161     OCResourceHandle handle0;
2162     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
2163                                             "core.led",
2164                                             "core.rw",
2165                                             "/a/led0",
2166                                             0,
2167                                             NULL,
2168                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2169     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2170     EXPECT_EQ(++numExpectedResources, numResources);
2171
2172     OCResourceHandle handle1;
2173     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
2174                                             "core.led",
2175                                             "core.rw",
2176                                             "/a/led1",
2177                                             0,
2178                                             NULL,
2179                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2180     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2181     EXPECT_EQ(++numExpectedResources, numResources);
2182
2183     OCResourceHandle handle2;
2184     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
2185                                             "core.led",
2186                                             "core.rw",
2187                                             "/a/led2",
2188                                             0,
2189                                             NULL,
2190                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2191     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2192     EXPECT_EQ(++numExpectedResources, numResources);
2193
2194     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
2195     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2196     EXPECT_EQ(--numExpectedResources, numResources);
2197
2198     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
2199     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
2200
2201     // Make sure the resource elements are still correct
2202     uint8_t numResourceInterfaces;
2203     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
2204     EXPECT_EQ(2, numResourceInterfaces);
2205     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 1);
2206     EXPECT_STREQ("core.rw", resourceInterfaceName);
2207
2208     EXPECT_EQ(OC_STACK_OK, OCStop());
2209 }
2210
2211 // Visual Studio versions earlier than 2015 have bugs in is_pod and report the wrong answer.
2212 #if !defined(_MSC_VER) || (_MSC_VER >= 1900)
2213 TEST(PODTests, OCHeaderOption)
2214 {
2215     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
2216 }
2217
2218 TEST(PODTests, OCCallbackData)
2219 {
2220     EXPECT_TRUE(std::is_pod<OCCallbackData>::value);
2221 }
2222 #endif
2223
2224 TEST(OCDoDirectPairingTests, Nullpeer)
2225 {
2226     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, NULL, pmSel, &pinNumber, &resultCallback));
2227 }
2228
2229 TEST(OCDoDirectPairingTests, NullCallback)
2230 {
2231     EXPECT_EQ(OC_STACK_INVALID_CALLBACK,OCDoDirectPairing(NULL, &peer, pmSel, &pinNumber, NULL));
2232 }
2233
2234 TEST(OCDoDirectPairingTests, NullpinNumber)
2235 {
2236     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, &peer, pmSel, NULL, &resultCallback));
2237 }
2238
2239 TEST(StackResource, MultipleResourcesDiscovery)
2240 {
2241     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2242     OIC_LOG(INFO, TAG, "Starting MultipleResourcesDiscovery test");
2243     InitStack(OC_SERVER);
2244
2245     OCResourceHandle handle1;
2246     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
2247                                             "core.led",
2248                                             "core.rw",
2249                                             "/a/led1",
2250                                             0,
2251                                             NULL,
2252                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2253
2254     OCResourceHandle handle2;
2255     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
2256                                             "core.led",
2257                                             "core.rw",
2258                                             "/a/led2",
2259                                             0,
2260                                             NULL,
2261                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2262     OCResourceHandle handle3;
2263     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
2264                                             "core.led",
2265                                             "core.rw",
2266                                             "/a/led3",
2267                                             0,
2268                                             NULL,
2269                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2270     /* Start a discovery query*/
2271     char szQueryUri[MAX_QUERY_LENGTH] = "/oic/res?if=oic.if.ll";
2272     OCCallbackData cbData;
2273     cbData.cb = discoveryCallback;
2274     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
2275     cbData.cd = NULL;
2276
2277     OCDoHandle handle;
2278     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
2279                                         OC_REST_DISCOVER,
2280                                         szQueryUri,
2281                                         0,
2282                                         0,
2283                                         CT_ADAPTER_IP,
2284                                         OC_LOW_QOS,
2285                                         &cbData,
2286                                         NULL,
2287                                         0));
2288
2289     EXPECT_EQ(OC_STACK_OK, OCStop());
2290 }
2291
2292 TEST(StackPayload, CloneByteString)
2293 {
2294     uint8_t bytes[] = { 0, 1, 2, 3 };
2295     OCByteString byteString;
2296     byteString.bytes = bytes;
2297     byteString.len = sizeof(bytes);
2298
2299     OCRepPayload *original = OCRepPayloadCreate();
2300     ASSERT_TRUE(original != NULL);
2301     EXPECT_TRUE(OCRepPayloadSetPropByteString(original, "name", byteString));
2302
2303     OCRepPayload *clone = OCRepPayloadClone(original);
2304     ASSERT_TRUE(clone != NULL);
2305
2306     OCRepPayloadDestroy(original);
2307
2308     OCByteString cloneByteString;
2309     EXPECT_TRUE(OCRepPayloadGetPropByteString(clone, "name", &cloneByteString));
2310     ASSERT_TRUE(cloneByteString.bytes != NULL);
2311     EXPECT_EQ(sizeof(bytes), cloneByteString.len);
2312     EXPECT_TRUE(0 == memcmp(bytes, cloneByteString.bytes, sizeof(bytes)));
2313     OICFree(cloneByteString.bytes);
2314
2315     OCRepPayloadDestroy(clone);
2316 }
2317
2318 TEST(StackUri, Rfc6874_Noop_1)
2319 {
2320     char validIPv6Address[] = "FF01:0:0:0:0:0:0:FB";
2321     char bytes[100] = {0};
2322     strncpy(bytes, validIPv6Address, sizeof(bytes));
2323
2324     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2325
2326     // No % sign, should do nothing
2327     EXPECT_STREQ(bytes, validIPv6Address);
2328     EXPECT_EQ(OC_STACK_OK, result);
2329 }
2330
2331 TEST(StackUri, Rfc6874_Noop_2)
2332 {
2333     char validIPv6Address[] = "3812:a61::4:1";
2334     char bytes[100] = {0};
2335
2336     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2337
2338     // No % sign, should do nothing
2339     EXPECT_STREQ(bytes, validIPv6Address);
2340     EXPECT_EQ(OC_STACK_OK, result);
2341 }
2342
2343 TEST(StackUri, Rfc6874_WithEncoding)
2344 {
2345     char validIPv6Address[] =        "fe80::dafe:e3ff:fe00:ebfa%wlan0";
2346     char validIPv6AddressEncoded[] = "fe80::dafe:e3ff:fe00:ebfa%25wlan0";
2347     char bytes[100] = "";
2348     strncpy(bytes, validIPv6Address, sizeof(bytes));
2349
2350     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2351
2352     // Encoding should have occured
2353     EXPECT_STREQ(bytes, validIPv6AddressEncoded);
2354     EXPECT_EQ(OC_STACK_OK, result);
2355 }
2356
2357 TEST(StackUri, Rfc6874_WithEncoding_ExtraPercent)
2358 {
2359     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%%wlan0";
2360     char bytes[100] = {0};
2361
2362     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2363
2364     // Encoding should have failed due to extra '%' character
2365     EXPECT_STREQ(bytes, "");
2366     EXPECT_EQ(OC_STACK_ERROR, result);
2367 }
2368
2369 TEST(StackUri, Rfc6874_AlreadyEncoded)
2370 {
2371     char validIPv6AddressEncoded[] = "fe80::dafe:e3ff:fe00:ebfa%25wlan0";
2372     char bytes[100] = {0};
2373
2374     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6AddressEncoded);
2375
2376     // Encoding should have failed due to extra '%' character
2377     EXPECT_STREQ(bytes, "");
2378     EXPECT_EQ(OC_STACK_ERROR, result);
2379 }
2380
2381 TEST(StackUri, Rfc6874_NoOverflow)
2382 {
2383     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0";
2384     char addrBuffer[100];
2385     char bytes[100] = {0};
2386     memset(addrBuffer, sizeof(addrBuffer), '_');
2387
2388     // Just enough room to encode
2389     addrBuffer[sizeof(addrBuffer) - sizeof(validIPv6Address) - 3] = '\0';
2390     strcat(addrBuffer, validIPv6Address);
2391
2392     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), addrBuffer);
2393
2394     // Encoding should have succeeded
2395     EXPECT_EQ(OC_STACK_OK, result);
2396 }
2397
2398 TEST(StackUri, Rfc6874_NoOverflow_2)
2399 {
2400     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0";
2401     char addrBuffer[100];
2402     char bytes[100] = {0};
2403     memset(addrBuffer, sizeof(addrBuffer), '_');
2404
2405     // Not enough room to encode
2406     addrBuffer[sizeof(addrBuffer) - sizeof(validIPv6Address) - 1] = '\0';
2407     strcat(addrBuffer, validIPv6Address);
2408
2409     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), addrBuffer);
2410
2411     // Encoding should have failed due to output size limitations
2412     EXPECT_STREQ(bytes, "");
2413     EXPECT_EQ(OC_STACK_ERROR, result);
2414 }
2415
2416 TEST(StackHeaderOption, setHeaderOption)
2417 {
2418     uint8_t optionValue1[MAX_HEADER_OPTION_DATA_LENGTH] =
2419     { 1 };
2420     OCHeaderOption options[MAX_HEADER_OPTIONS] =
2421     {
2422     { OC_COAP_ID, 6, 8, optionValue1 }, };
2423     uint8_t optionData = 255;
2424     size_t optionDataSize = sizeof(optionData);
2425     size_t numOptions = 1;
2426     uint16_t optionID = 2048;
2427     EXPECT_EQ(OC_STACK_OK, OCSetHeaderOption(options,
2428                                              &numOptions,
2429                                              optionID,
2430                                              &optionData,
2431                                              optionDataSize));
2432     EXPECT_EQ(options[1].optionID, optionID);
2433     EXPECT_EQ(options[1].optionData[0], 255);
2434 }
2435
2436 TEST(StackHeaderOption, getHeaderOption)
2437 {
2438     uint8_t optionValue1[MAX_HEADER_OPTION_DATA_LENGTH] =
2439     { 1 };
2440     uint8_t optionValue2[MAX_HEADER_OPTION_DATA_LENGTH] =
2441     { 255 };
2442     OCHeaderOption options[MAX_HEADER_OPTIONS] =
2443     {
2444     { OC_COAP_ID, 6, 8, optionValue1 },
2445     { OC_COAP_ID, 2048, 16, optionValue2 }, };
2446     uint8_t optionData[MAX_HEADER_OPTION_DATA_LENGTH];
2447     size_t optionDataSize = sizeof(optionData);
2448     size_t numOptions = 2;
2449     uint16_t optionID = 6;
2450     uint16_t actualDataSize = 0;
2451     EXPECT_EQ(OC_STACK_OK, OCGetHeaderOption(options,
2452                                              numOptions,
2453                                              optionID,
2454                                              optionData,
2455                                              optionDataSize,
2456                                              &actualDataSize));
2457     EXPECT_EQ(optionData[0], 1);
2458     EXPECT_EQ(actualDataSize, 8);
2459 }
2460
2461 TEST(StackEndpoints, OCGetSupportedEndpointTpsFlags)
2462 {
2463     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2464
2465     OIC_LOG(INFO, TAG, "OCGetSupportedEndpointTpsFlags test");
2466
2467     InitStack(OC_SERVER);
2468
2469     EXPECT_LE(INVALID_TPS_FLAGS_ZERO, OCGetSupportedEndpointTpsFlags());
2470
2471     EXPECT_EQ(OC_STACK_OK, OCStop());
2472 }
2473
2474 static OCStackApplicationResult DiscoverBaselineResource(void *ctx, OCDoHandle handle,
2475     OCClientResponse *response)
2476 {
2477     OC_UNUSED(ctx);
2478     OC_UNUSED(handle);
2479     EXPECT_EQ(OC_STACK_OK, response->result);
2480     EXPECT_TRUE(NULL != response->payload);
2481     if (NULL != response->payload)
2482     {
2483         EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2484
2485         OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload;
2486         EXPECT_TRUE(NULL != payload->sid);
2487         EXPECT_STREQ("StackTest", payload->name);
2488         EXPECT_STREQ(OC_RSRVD_RESOURCE_TYPE_RES, payload->type->value);
2489         EXPECT_STREQ(OC_RSRVD_INTERFACE_LL, payload->iface->value);
2490         EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, payload->iface->next->value);
2491
2492         for (OCResourcePayload *resource = payload->resources; resource; resource = resource->next)
2493         {
2494             if (0 == strcmp("/a/light", resource->uri))
2495             {
2496                 EXPECT_STREQ("/a/light", resource->uri);
2497                 EXPECT_STREQ("core.light", resource->types->value);
2498                 EXPECT_EQ(NULL, resource->types->next);
2499                 EXPECT_STREQ("oic.if.baseline", resource->interfaces->value);
2500                 EXPECT_EQ(NULL, resource->interfaces->next);
2501                 EXPECT_TRUE(resource->bitmap & OC_DISCOVERABLE);
2502                 EXPECT_FALSE(resource->secure);
2503                 EXPECT_EQ(0, resource->port);
2504                 EXPECT_EQ(NULL, resource->next);
2505             }
2506         }
2507     }
2508
2509     return OC_STACK_DELETE_TRANSACTION;
2510 }
2511
2512 static OCStackApplicationResult DiscoverLinkedListResource(void *ctx, OCDoHandle handle,
2513     OCClientResponse *response)
2514 {
2515     OC_UNUSED(ctx);
2516     OC_UNUSED(handle);
2517     EXPECT_EQ(OC_STACK_OK, response->result);
2518     EXPECT_TRUE(NULL != response->payload);
2519     if (NULL != response->payload)
2520     {
2521         EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2522
2523         OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload;
2524         EXPECT_NE((char *)NULL, payload->sid);
2525         EXPECT_EQ(NULL, payload->name);
2526         EXPECT_EQ(NULL, payload->type);
2527         EXPECT_EQ(NULL, payload->iface);
2528
2529         for (OCResourcePayload *resource = payload->resources; resource; resource = resource->next)
2530         {
2531             if (0 == strcmp("/a/light", resource->uri))
2532             {
2533                 EXPECT_STREQ("/a/light", resource->uri);
2534                 EXPECT_STREQ("core.light", resource->types->value);
2535                 EXPECT_EQ(NULL, resource->types->next);
2536                 EXPECT_STREQ("oic.if.baseline", resource->interfaces->value);
2537                 EXPECT_EQ(NULL, resource->interfaces->next);
2538                 EXPECT_TRUE(resource->bitmap & OC_DISCOVERABLE);
2539                 EXPECT_FALSE(resource->secure);
2540                 EXPECT_EQ(0, resource->port);
2541                 EXPECT_EQ(NULL, resource->next);
2542             }
2543         }
2544     }
2545     return OC_STACK_DELETE_TRANSACTION;
2546 }
2547
2548
2549 static OCStackApplicationResult DiscoverResourceTypeResponse(void *ctx, OCDoHandle handle,
2550     OCClientResponse *response)
2551 {
2552     OC_UNUSED(ctx);
2553     OC_UNUSED(handle);
2554     EXPECT_EQ(OC_STACK_OK, response->result);
2555     EXPECT_TRUE(NULL != response->payload);
2556     if (NULL != response->payload)
2557     {
2558         EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2559
2560         OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload;
2561         EXPECT_NE((char *)NULL, payload->sid);
2562         EXPECT_EQ(NULL, payload->name);
2563         EXPECT_EQ(NULL, payload->type);
2564         EXPECT_EQ(NULL, payload->iface);
2565         EXPECT_TRUE(NULL != payload->resources);
2566
2567         OCResourcePayload *resource = payload->resources;
2568
2569         if (0 == strcmp("/a/light", resource->uri))
2570         {
2571             EXPECT_STREQ("/a/light", resource->uri);
2572             EXPECT_STREQ("core.light", resource->types->value);
2573             EXPECT_EQ(NULL, resource->types->next);
2574             EXPECT_STREQ("oic.if.baseline", resource->interfaces->value);
2575             EXPECT_EQ(NULL, resource->interfaces->next);
2576             EXPECT_TRUE(resource->bitmap & OC_DISCOVERABLE);
2577             EXPECT_FALSE(resource->secure);
2578             EXPECT_EQ(0, resource->port);
2579             EXPECT_EQ(NULL, resource->next);
2580         }
2581     }
2582
2583     return OC_STACK_DELETE_TRANSACTION;
2584 }
2585
2586 static OCStackApplicationResult DiscoverUnicastErrorResponse(void *ctx, OCDoHandle handle,
2587     OCClientResponse *response)
2588 {
2589     OC_UNUSED(ctx);
2590     OC_UNUSED(handle);
2591     EXPECT_NE(OC_STACK_OK, response->result);
2592     EXPECT_TRUE(NULL == response->payload);
2593
2594     return OC_STACK_DELETE_TRANSACTION;
2595 }
2596
2597 // Disabled to unblock other developers untill IOT-1807 is done.
2598 TEST_F(OCDiscoverTests, DISABLED_DiscoverResourceWithValidQueries)
2599 {
2600     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2601
2602     OCResourceHandle handles;
2603     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2604         entityHandler, NULL, OC_DISCOVERABLE));
2605     OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, "StackTest");
2606
2607     itst::Callback discoverBaselineCB(&DiscoverBaselineResource);
2608     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=oic.if.baseline", NULL,
2609         0, CT_DEFAULT, OC_HIGH_QOS, discoverBaselineCB, NULL, 0));
2610     EXPECT_EQ(OC_STACK_OK, discoverBaselineCB.Wait(100));
2611
2612     // Disabled temporarily on Windows to unblock other developers. Will be enabled in IOT-1806.
2613 #ifndef _MSC_VER
2614     itst::Callback discoverDefaultCB(&DiscoverLinkedListResource);
2615     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res", NULL, 0, CT_DEFAULT,
2616         OC_HIGH_QOS, discoverDefaultCB, NULL, 0));
2617     EXPECT_EQ(OC_STACK_OK, discoverDefaultCB.Wait(100));
2618 #endif
2619
2620     itst::Callback discoverLinkedListCB(&DiscoverLinkedListResource);
2621     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=oic.if.ll", NULL, 0,
2622         CT_DEFAULT, OC_HIGH_QOS, discoverLinkedListCB, NULL, 0));
2623     EXPECT_EQ(OC_STACK_OK, discoverLinkedListCB.Wait(100));
2624
2625     itst::Callback discoverRTCB(&DiscoverResourceTypeResponse);
2626     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?rt=core.light", NULL, 0,
2627         CT_DEFAULT, OC_HIGH_QOS, discoverRTCB, NULL, 0));
2628     EXPECT_EQ(OC_STACK_OK, discoverRTCB.Wait(100));
2629 }
2630
2631 // Disabled to unblock other developers untill IOT-1807 is done.
2632 TEST_F(OCDiscoverTests, DISABLED_DiscoverResourceWithInvalidQueries)
2633 {
2634     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2635
2636     OCResourceHandle handles;
2637     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2638         entityHandler, NULL, OC_DISCOVERABLE));
2639     OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest");
2640
2641     itst::Callback discoverRTInvalidCB(&DiscoverUnicastErrorResponse);
2642     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?rt=invalid", NULL, 0,
2643     CT_DEFAULT, OC_HIGH_QOS, discoverRTInvalidCB, NULL, 0));
2644     EXPECT_EQ(OC_STACK_OK, discoverRTInvalidCB.Wait(10));
2645
2646     itst::Callback discoverRTEmptyCB(&DiscoverUnicastErrorResponse);
2647     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?rt=", NULL, 0, CT_DEFAULT,
2648     OC_HIGH_QOS, discoverRTEmptyCB, NULL, 0));
2649     EXPECT_EQ(OC_STACK_OK, discoverRTEmptyCB.Wait(10));
2650
2651     itst::Callback discoverIfInvalidCB(&DiscoverUnicastErrorResponse);
2652     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=invalid", NULL, 0,
2653         CT_DEFAULT, OC_HIGH_QOS, discoverIfInvalidCB, NULL, 0));
2654     EXPECT_EQ(OC_STACK_OK, discoverIfInvalidCB.Wait(10));
2655
2656     itst::Callback discoverIfEmptyCB(&DiscoverUnicastErrorResponse);
2657     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=", NULL, 0, CT_DEFAULT,
2658     OC_HIGH_QOS, discoverIfEmptyCB, NULL, 0));
2659     EXPECT_EQ(OC_STACK_OK, discoverIfEmptyCB.Wait(10));
2660
2661     // Unicast
2662     char targetUri[MAX_URI_LENGTH * 2] ={ 0, };
2663
2664     itst::Callback discoverUnicastIfInvalidCB(&DiscoverUnicastErrorResponse);
2665     snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?if=invalid");
2666     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0,
2667     CT_DEFAULT, OC_HIGH_QOS, discoverUnicastIfInvalidCB, NULL, 0));
2668     EXPECT_EQ(OC_STACK_OK, discoverUnicastIfInvalidCB.Wait(10));
2669
2670     itst::Callback discoverUnicastIfEmptyCB(&DiscoverUnicastErrorResponse);
2671     snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?if=");
2672     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0, CT_DEFAULT,
2673     OC_HIGH_QOS, discoverUnicastIfEmptyCB, NULL, 0));
2674     EXPECT_EQ(OC_STACK_OK, discoverUnicastIfEmptyCB.Wait(10));
2675
2676     itst::Callback discoverUnicastRTInvalidCB(&DiscoverUnicastErrorResponse);
2677     snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?rt=invalid");
2678     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0,
2679     CT_DEFAULT, OC_HIGH_QOS, discoverUnicastRTInvalidCB, NULL, 0));
2680     EXPECT_EQ(OC_STACK_OK, discoverUnicastRTInvalidCB.Wait(10));
2681
2682     itst::Callback discoverUnicastRTEmptyCB(&DiscoverUnicastErrorResponse);
2683     snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?rt=");
2684     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0, CT_DEFAULT,
2685     OC_HIGH_QOS, discoverUnicastRTEmptyCB, NULL, 0));
2686     EXPECT_EQ(OC_STACK_OK, discoverUnicastRTEmptyCB.Wait(10));
2687 }
2688
2689 TEST(StackZoneId, getZoneId)
2690 {
2691     size_t tempSize = 0;
2692     CAEndpoint_t *tempInfo = NULL;
2693     CAGetNetworkInformation(&tempInfo, &tempSize);
2694
2695     for (size_t i = 0; i < tempSize; i++)
2696     {
2697         char *zoneId = NULL;
2698         EXPECT_EQ(OC_STACK_OK, OCGetLinkLocalZoneId(tempInfo[i].ifindex, &zoneId));
2699         OICFree(zoneId);
2700         zoneId = NULL;
2701     }
2702
2703     OICFree(tempInfo);
2704 }
2705
2706 TEST(StackZoneId, getZoneIdWithInvalidParams)
2707 {
2708     char *zoneId = NULL;
2709     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCGetLinkLocalZoneId(0, NULL));
2710     EXPECT_EQ(OC_STACK_ERROR, OCGetLinkLocalZoneId(9999, &zoneId));
2711     EXPECT_EQ(OC_STACK_ERROR, OCGetLinkLocalZoneId(-1, &zoneId));
2712 }