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     #include "occollection.h"
  33     #include "mbedtls/ssl_ciphersuites.h"
  34     #include "octypes.h"
  35 #if defined (WITH_POSIX) && (defined (__WITH_DTLS__) || defined(__WITH_TLS__))
  36     #include "ca_adapter_net_ssl.h"
  37 #endif
  38 }
  39
  40 #include <gtest/gtest.h>
  41 #include <sys/types.h>
  42 #include <sys/stat.h>
  43 #include <errno.h>
  44 #include <fcntl.h>
  45 #ifdef HAVE_UNISTD_H
  46 #include <unistd.h>
  47 #endif
  48 #include <stdlib.h>
  49
  50 //-----------------------------------------------------------------------------
  51 // Includes
  52 //-----------------------------------------------------------------------------
  53 #include <stdio.h>
  54 #include <string.h>
  55
  56 #include <iostream>
  57 #include <stdint.h>
  58
  59 #include "gtest_helper.h"
  60
  61 using namespace std;
  62
  63 namespace itst = iotivity::test;
  64
  65 #define DEFAULT_CONTEXT_VALUE 0x99
  66 #define INVALID_TPS_FLAGS (250)
  67 #define INVALID_TPS_FLAGS_ZERO (0)
  68
  69 //-----------------------------------------------------------------------------
  70 // Private variables
  71 //-----------------------------------------------------------------------------
  72 #define TAG "TestHarness"
  73
  74 char gDeviceUUID[] = "fe3f9a68-4931-4cb0-9ea4-81702b43116c";
  75 char gDevicePIID[] = "32684bf3-4c44-47b0-99fe-6a9a59b73a8d";
  76 char gManufacturerName[] = "myName";
  77 static OCPrm_t pmSel;
  78 static char pinNumber;
  79 static OCDPDev_t peer;
  80
  81 std::chrono::seconds const SHORT_TEST_TIMEOUT = std::chrono::seconds(5);
  82 std::chrono::seconds const LONG_TEST_TIMEOUT = std::chrono::seconds(450);
  83
  84 //-----------------------------------------------------------------------------
  85 // Callback functions
  86 //-----------------------------------------------------------------------------
  87 extern "C"  OCStackApplicationResult asyncDoResourcesCallback(void* ctx,
  88         OCDoHandle /*handle*/, OCClientResponse * clientResponse)
  89 {
  90     OIC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
  91
  92     EXPECT_EQ(OC_STACK_OK, clientResponse->result);
  93
  94     if(ctx == (void*)DEFAULT_CONTEXT_VALUE) {
  95         OIC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
  96     }
  97     OIC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
  98
  99     return OC_STACK_KEEP_TRANSACTION;
 100 }
 101
 102 extern "C" OCStackApplicationResult discoveryCallback(void* ctx,
 103         OCDoHandle /*handle*/, OCClientResponse * clientResponse)
 104 {
 105     OIC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
 106
 107     EXPECT_EQ(OC_STACK_OK, clientResponse->result);
 108
 109     if(ctx == (void*)DEFAULT_CONTEXT_VALUE)
 110     {
 111         OIC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
 112     }
 113
 114     OIC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
 115
 116     OCDiscoveryPayload *discoveryPayload = ((OCDiscoveryPayload *) clientResponse->payload);
 117     EXPECT_TRUE(discoveryPayload != NULL);
 118     OCResourcePayload *res = discoveryPayload->resources;
 119     int count = 0;
 120     for (OCResourcePayload *res1 = discoveryPayload->resources; res1; res1 = res1->next)
 121     {
 122         count++;
 123     }
 124     EXPECT_EQ(3, count);
 125     EXPECT_EQ("/a/led1", res->uri);
 126     res = res->next;
 127     EXPECT_EQ("/a/led2", res->uri);
 128     res = res->next;
 129     EXPECT_EQ("/a/led3", res->uri);
 130     res = res->next;
 131     EXPECT_TRUE(res == NULL);
 132
 133     return OC_STACK_KEEP_TRANSACTION;
 134 }
 135
 136 //-----------------------------------------------------------------------------
 137 // Entity handler
 138 //-----------------------------------------------------------------------------
 139 OCEntityHandlerResult entityHandler(OCEntityHandlerFlag /*flag*/,
 140         OCEntityHandlerRequest * /*entityHandlerRequest*/,
 141         void* /*callbackParam*/)
 142 {
 143     OIC_LOG(INFO, TAG, "Entering entityHandler");
 144
 145     return OC_EH_OK;
 146 }
 147
 148 //-----------------------------------------------------------------------------
 149 //  Local functions
 150 //-----------------------------------------------------------------------------
 151 void InitStack(OCMode mode)
 152 {
 153     OIC_LOG(INFO, TAG, "Entering InitStack");
 154
 155     EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, mode));
 156     OIC_LOG(INFO, TAG, "Leaving InitStack");
 157 }
 158
 159 uint8_t InitNumExpectedResources()
 160 {
 161 #ifdef WITH_PRESENCE
 162     // When presence is enabled, it is a resource and so is (currently) included
 163     // in the returned resource count returned by the OCGetNumberOfResources API.
 164     return 1;
 165 #else
 166     return 0;
 167 #endif
 168 }
 169
 170 uint8_t InitResourceIndex()
 171 {
 172 #ifdef WITH_PRESENCE
 173     // When presence is enabled, it is a resource and so is (currently) included
 174     // in the returned resource count returned by the OCGetNumberOfResources API.
 175     // The index of the presence resource is 0, so the first user app resource index
 176     // is 1.
 177     return 1;
 178 #else
 179     return 0;
 180 #endif
 181 }
 182
 183 extern "C" uint32_t g_ocStackStartCount;
 184
 185 OCDeviceProperties* getTestDeviceProps()
 186 {
 187     OCDeviceProperties* deviceProps = (OCDeviceProperties*)OICCalloc(1, sizeof(OCDeviceProperties));
 188     if (NULL != deviceProps)
 189     {
 190         OICStrcpy(deviceProps->protocolIndependentId, UUID_STRING_SIZE, gDevicePIID);
 191     }
 192
 193     return deviceProps;
 194 }
 195
 196 class OCDiscoverTests : public testing::Test
 197 {
 198     protected:
 199         virtual void SetUp()
 200         {
 201             EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
 202         }
 203
 204         virtual void TearDown()
 205         {
 206             OCStop();
 207         }
 208 };
 209
 210 class OCDevicePropertiesTests : public testing::Test
 211 {
 212 protected:
 213     virtual void SetUp()
 214     {
 215         itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 216     }
 217 };
 218 //-----------------------------------------------------------------------------
 219 //  Tests
 220 //-----------------------------------------------------------------------------
 221
 222 TEST(StackInit, StackInitNullAddr)
 223 {
 224     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 225     EXPECT_EQ(OC_STACK_OK, OCInit(0, 5683, OC_SERVER));
 226     EXPECT_EQ(1u, g_ocStackStartCount);
 227     EXPECT_EQ(OC_STACK_OK, OCStop());
 228     EXPECT_EQ(0u, g_ocStackStartCount);
 229 }
 230
 231 TEST(StackInit, StackInitNullPort)
 232 {
 233     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 234     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 0, OC_SERVER));
 235     EXPECT_EQ(OC_STACK_OK, OCStop());
 236 }
 237
 238 TEST(StackInit, StackInitNullAddrAndPort)
 239 {
 240     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 241     EXPECT_EQ(OC_STACK_OK, OCInit(0, 0, OC_SERVER));
 242     EXPECT_EQ(OC_STACK_OK, OCStop());
 243 }
 244
 245 TEST(StackInit, StackInitInvalidMode)
 246 {
 247     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 248     EXPECT_EQ(OC_STACK_ERROR, OCInit(0, 0, (OCMode)10));
 249     EXPECT_EQ(0u, g_ocStackStartCount);
 250 }
 251
 252 TEST(StackStart, StackStartSuccessClient)
 253 {
 254     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 255     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 256     EXPECT_EQ(OC_STACK_OK, OCStop());
 257 }
 258
 259 TEST(StackStart, StackStartSuccessServer)
 260 {
 261     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 262     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 263     EXPECT_EQ(OC_STACK_OK, OCStop());
 264 }
 265
 266 TEST(StackStart, StackStartSuccessClientServer)
 267 {
 268     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 269     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
 270     EXPECT_EQ(OC_STACK_OK, OCStop());
 271 }
 272
 273 TEST(StackStart, StackStartSuccessServerThenClient)
 274 {
 275     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 276     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 277     EXPECT_EQ(OC_STACK_OK, OCStop());
 278     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 279     EXPECT_EQ(OC_STACK_OK, OCStop());
 280 }
 281
 282 TEST(StackStart, StackStartSuccessClientThenServer)
 283 {
 284     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 285     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 286     EXPECT_EQ(OC_STACK_OK, OCStop());
 287     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 288     EXPECT_EQ(OC_STACK_OK, OCStop());
 289 }
 290
 291 TEST(StackStart, StackStartSuccessiveInits)
 292 {
 293     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 294     EXPECT_EQ(0u, g_ocStackStartCount);
 295     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 296     EXPECT_EQ(1u, g_ocStackStartCount);
 297     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.2", 5683, OC_SERVER));
 298     EXPECT_EQ(2u, g_ocStackStartCount);
 299     EXPECT_EQ(OC_STACK_OK, OCStop());
 300     EXPECT_EQ(1u, g_ocStackStartCount);
 301     EXPECT_EQ(OC_STACK_OK, OCStop());
 302     EXPECT_EQ(0u, g_ocStackStartCount);
 303 }
 304
 305 TEST(StackStart, SetPlatformInfoValid)
 306 {
 307     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 308     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 309
 310     OCPlatformInfo info =
 311     {
 312         gDeviceUUID,
 313         gManufacturerName,
 314         0, 0, 0, 0, 0, 0, 0, 0, 0
 315     };
 316     EXPECT_EQ(OC_STACK_OK, OCSetPlatformInfo(info));
 317     EXPECT_EQ(OC_STACK_OK, OCStop());
 318 }
 319
 320 TEST(StackStart, SetPlatformInfoWithClientMode)
 321 {
 322     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 323     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 324
 325     OCPlatformInfo info =
 326     {
 327         gDeviceUUID,
 328         gManufacturerName,
 329         0, 0, 0, 0, 0, 0, 0, 0, 0
 330     };
 331     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 332     EXPECT_EQ(OC_STACK_OK, OCStop());
 333 }
 334
 335 TEST(StackStart, SetPlatformInfoWithNoPlatformID)
 336 {
 337     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 338     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 339
 340     OCPlatformInfo info =
 341      {
 342          0,
 343          gDeviceUUID,
 344          0, 0, 0, 0, 0, 0, 0, 0, 0
 345      };
 346
 347     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 348     EXPECT_EQ(OC_STACK_OK, OCStop());
 349 }
 350
 351 TEST(StackStart, SetPlatformInfoWithBadPlatformID)
 352 {
 353     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 354     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 355
 356     char invalidId[] = "myDeviceUUID";
 357     OCPlatformInfo info =
 358      {
 359         invalidId,
 360         gManufacturerName,
 361         0, 0, 0, 0, 0, 0, 0, 0, 0
 362      };
 363
 364     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 365     EXPECT_EQ(OC_STACK_OK, OCStop());
 366 }
 367
 368 TEST(StackStart, SetPlatformInfoWithNoManufacturerName)
 369 {
 370     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 371     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 372
 373     OCPlatformInfo info =
 374     {
 375         gDeviceUUID,
 376         0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 377     };
 378
 379     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 380     EXPECT_EQ(OC_STACK_OK, OCStop());
 381 }
 382
 383 TEST(StackStart, SetPlatformInfoWithZeroLengthManufacturerName)
 384 {
 385     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 386     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 387
 388     OCPlatformInfo info =
 389     {
 390         gDeviceUUID,
 391         0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 392     };
 393     info.manufacturerName = (char *) "";
 394
 395     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 396     EXPECT_EQ(OC_STACK_OK, OCStop());
 397 }
 398
 399 TEST(StackStart, SetPlatformInfoWithTooLongManufacName)
 400 {
 401     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 402     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 403     char gTooLongManufacturerName[MAX_PLATFORM_NAME_LENGTH+2];
 404     for (int i = 0; i <= MAX_PLATFORM_NAME_LENGTH; i++ )
 405     {
 406         gTooLongManufacturerName[i] = 'a';
 407     }
 408     gTooLongManufacturerName[MAX_PLATFORM_NAME_LENGTH+1] = '\0';
 409     OCPlatformInfo info =
 410     {
 411         gDeviceUUID,
 412         gTooLongManufacturerName,
 413         0, 0, 0, 0, 0, 0, 0, 0, 0
 414     };
 415
 416     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 417     EXPECT_EQ(OC_STACK_OK, OCStop());
 418 }
 419
 420 TEST(StackStart, SetPlatformInfoWithTooLongManufacURL)
 421 {
 422     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 423     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 424     char gManufacturerUrl[MAX_PLATFORM_URL_LENGTH+2];
 425     for (int i = 0; i <= MAX_PLATFORM_URL_LENGTH; i++ )
 426     {
 427         gManufacturerUrl[i] = 'a';
 428     }
 429     gManufacturerUrl[MAX_PLATFORM_URL_LENGTH+1] = '\0';
 430     OCPlatformInfo info =
 431     {
 432         gDeviceUUID,
 433         gManufacturerName,
 434         gManufacturerUrl,
 435         0, 0, 0, 0, 0, 0, 0, 0
 436     };
 437
 438     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 439     EXPECT_EQ(OC_STACK_OK, OCStop());
 440 }
 441
 442 TEST(StackStart, SetPlatformInfoWithOCSetPropertyValueAPI)
 443 {
 444     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 445     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 446     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, gDeviceUUID));
 447     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, gManufacturerName));
 448     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, "http://www.iotivity.org"));
 449     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, "S777"));
 450     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, "15 Nov, 2016"));
 451     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, "1.1"));
 452     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, "14"));
 453     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, "0.1"));
 454     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, "0.1"));
 455     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, "http://www.iotivity.org"));
 456     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, ""));
 457     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", "value"));
 458     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, NULL, ""));
 459     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL));
 460     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL));
 461     EXPECT_EQ(OC_STACK_OK, OCStop());
 462 }
 463
 464 TEST(StackStart, GetPlatformInfoWithOCGetPropertyValueAPI)
 465 {
 466     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 467     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 468     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, gDeviceUUID));
 469     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, gManufacturerName));
 470     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, "http://www.iotivity.org"));
 471     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, "S777"));
 472     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, "15 Nov, 2016"));
 473     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, "1.1"));
 474     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, "14"));
 475     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, "0.1"));
 476     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, "0.1"));
 477     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, "http://www.iotivity.org"));
 478     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, ""));
 479     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", "value"));
 480
 481     void *value = NULL;
 482     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, &value));
 483     ASSERT_TRUE(value != NULL);
 484     EXPECT_STREQ(gDeviceUUID, (char *)value);
 485     OICFree(value);
 486     value = NULL;
 487
 488     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, &value));
 489     ASSERT_TRUE(value != NULL);
 490     EXPECT_STREQ(gManufacturerName, (char *)value);
 491     OICFree(value);
 492     value = NULL;
 493
 494     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, &value));
 495     ASSERT_TRUE(value != NULL);
 496     EXPECT_STREQ("http://www.iotivity.org", (char *)value);
 497     OICFree(value);
 498     value = NULL;
 499
 500     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, &value));
 501     ASSERT_TRUE(value != NULL);
 502     EXPECT_STREQ("S777", (char *)value);
 503     OICFree(value);
 504     value = NULL;
 505
 506     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, &value));
 507     ASSERT_TRUE(value != NULL);
 508     EXPECT_STREQ("15 Nov, 2016", (char *)value);
 509     OICFree(value);
 510     value = NULL;
 511
 512     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, &value));
 513     ASSERT_TRUE(value != NULL);
 514     EXPECT_STREQ("1.1", (char *)value);
 515     OICFree(value);
 516     value = NULL;
 517
 518     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, &value));
 519     ASSERT_TRUE(value != NULL);
 520     EXPECT_STREQ("14", (char *)value);
 521     OICFree(value);
 522     value = NULL;
 523
 524     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, &value));
 525     ASSERT_TRUE(value != NULL);
 526     EXPECT_STREQ("0.1", (char *)value);
 527     OICFree(value);
 528     value = NULL;
 529
 530     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, &value));
 531     ASSERT_TRUE(value != NULL);
 532     EXPECT_STREQ("0.1", (char *)value);
 533     OICFree(value);
 534     value = NULL;
 535
 536     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, &value));
 537     ASSERT_TRUE(value != NULL);
 538     EXPECT_STREQ("http://www.iotivity.org", (char *)value);
 539     OICFree(value);
 540     value = NULL;
 541
 542     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, &value));
 543     ASSERT_TRUE(value != NULL);
 544     EXPECT_STREQ("", (char *)value);
 545     OICFree(value);
 546     value = NULL;
 547
 548     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", &value));
 549     ASSERT_TRUE(value != NULL);
 550     EXPECT_STREQ("value", (char *)value);
 551     OICFree(value);
 552
 553     EXPECT_EQ(OC_STACK_OK, OCStop());
 554 }
 555
 556 TEST(StackStart, SetDeviceInfoAPI)
 557 {
 558     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 559     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 560     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, "Sample"));
 561     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, "specVersion"));
 562     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", "value"));
 563     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION,
 564         "Data Model Version"));
 565     OCResourceHandle handle = OCGetResourceHandleAtUri(OC_RSRVD_DEVICE_URI);
 566     EXPECT_TRUE(handle != NULL);
 567     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "oic.wk.tv"));
 568     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL));
 569     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, "", NULL));
 570     EXPECT_EQ(OC_STACK_OK, OCStop());
 571 }
 572
 573 TEST(StackStart, GetDeviceInfoAPI)
 574 {
 575     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 576     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 577     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, "Sample"));
 578     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, "specVersion"));
 579     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", "value"));
 580     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION,
 581         "Data Model Version"));
 582     OCResourceHandle handle = OCGetResourceHandleAtUri(OC_RSRVD_DEVICE_URI);
 583     EXPECT_TRUE(handle != NULL);
 584     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "oic.wk.tv"));
 585
 586     void *value = NULL;
 587     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, &value));
 588     ASSERT_TRUE(value != NULL);
 589     EXPECT_STREQ("Sample", (char *)value);
 590     OICFree(value);
 591     value = NULL;
 592
 593     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, &value));
 594     ASSERT_TRUE(value != NULL);
 595     EXPECT_STREQ("specVersion", (char *)value);
 596     OICFree(value);
 597     value = NULL;
 598
 599     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", &value));
 600     ASSERT_TRUE(value != NULL);
 601     EXPECT_STREQ("value", (char *)value);
 602     OICFree(value);
 603     value = NULL;
 604
 605     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION, &value));
 606     ASSERT_TRUE(value != NULL);
 607     ASSERT_TRUE(((OCStringLL *)value)->value != NULL);
 608     EXPECT_STREQ("Data Model Version", ((OCStringLL *)value)->value);
 609     OCFreeOCStringLL((OCStringLL *) value);
 610     value = NULL;
 611
 612     EXPECT_STREQ("oic.wk.d", OCGetResourceTypeName(handle, 0));
 613     EXPECT_STREQ("oic.wk.tv", OCGetResourceTypeName(handle, 1));
 614
 615     EXPECT_EQ(OC_STACK_OK, OCStop());
 616 }
 617
 618 TEST(StackStart, SetGetDevicePropertyValues)
 619 {
 620     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 621     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 622     OCResourceHandle handle = OCGetResourceHandleAtUri(OC_RSRVD_DEVICE_URI);
 623     EXPECT_TRUE(handle != NULL);
 624     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "oic.wk.tv"));
 625     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "oic.if.tv"));
 626
 627     void *value = NULL;
 628     OCStringLL *x, *y;
 629
 630     OCStringLL *rts = NULL;
 631     OCResourcePayloadAddStringLL(&rts, "oic.wk.d");
 632     OCResourcePayloadAddStringLL(&rts, "oic.wk.tv");
 633     EXPECT_NE(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_RESOURCE_TYPE, &value));
 634     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_RESOURCE_TYPE, &value));
 635     for (x = rts, y = (OCStringLL *) value; x && y; x = x->next, y = y->next)
 636     {
 637         EXPECT_STREQ(x->value, y->value);
 638     }
 639     EXPECT_TRUE(!x && !y);
 640     OCFreeOCStringLL((OCStringLL *) value);
 641     value = NULL;
 642     OCFreeOCStringLL(rts);
 643
 644     OCStringLL *itfs = NULL;
 645     OCResourcePayloadAddStringLL(&itfs, "oic.if.baseline");
 646     OCResourcePayloadAddStringLL(&itfs, "oic.if.r");
 647     OCResourcePayloadAddStringLL(&itfs, "oic.if.tv");
 648     EXPECT_NE(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_INTERFACE, &value));
 649     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_INTERFACE, &value));
 650     for (x = itfs, y = (OCStringLL *) value; x && y; x = x->next, y = y->next)
 651     {
 652         EXPECT_STREQ(x->value, y->value);
 653     }
 654     EXPECT_TRUE(!x && !y);
 655     OCFreeOCStringLL((OCStringLL *) value);
 656     value = NULL;
 657     OCFreeOCStringLL(itfs);
 658
 659     const char *n = "name";
 660     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, n));
 661     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, &value));
 662     EXPECT_STREQ(n, (char *) value);
 663     OICFree(value);
 664     value = NULL;
 665
 666     const char *id = "instance-identifier";
 667     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_INSTANCE_ID, id));
 668     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_INSTANCE_ID, &value));
 669     EXPECT_STREQ(id, (char *) value);
 670     OICFree(value);
 671     value = NULL;
 672
 673     EXPECT_NE(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_ID, &value));
 674     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_ID, &value));
 675     EXPECT_STREQ(OCGetServerInstanceIDString(), (char *) value);
 676     OICFree(value);
 677     value = NULL;
 678
 679     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, OC_SPEC_VERSION));
 680     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, &value));
 681     EXPECT_STREQ(OC_SPEC_VERSION, (char *) value);
 682     OICFree(value);
 683     value = NULL;
 684
 685     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION, OC_DATA_MODEL_VERSION));
 686     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION, &value));
 687     char *dmv = OCCreateString((OCStringLL *) value);
 688     EXPECT_STREQ(OC_DATA_MODEL_VERSION, dmv);
 689     OICFree(dmv);
 690     OCFreeOCStringLL((OCStringLL *) value);
 691     value = NULL;
 692
 693     OCStringLL *ld = NULL;
 694     OCResourcePayloadAddStringLL(&ld, "en");
 695     OCResourcePayloadAddStringLL(&ld, "Description");
 696     OCResourcePayloadAddStringLL(&ld, "de");
 697     OCResourcePayloadAddStringLL(&ld, "Beschriebung");
 698     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_DESCRIPTION, ld));
 699     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_DESCRIPTION, &value));
 700     for (x = ld, y = (OCStringLL *) value; x && y; x = x->next, y = y->next)
 701     {
 702         EXPECT_STREQ(x->value, y->value);
 703     }
 704     EXPECT_TRUE(!x && !y);
 705     OCFreeOCStringLL((OCStringLL *) value);
 706     value = NULL;
 707     OCFreeOCStringLL(ld);
 708
 709     const char *sv = "software-version";
 710     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SOFTWARE_VERSION, sv));
 711     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SOFTWARE_VERSION, &value));
 712     EXPECT_STREQ(sv, (char *) value);
 713     OICFree(value);
 714     value = NULL;
 715
 716     OCStringLL *dmn = NULL;
 717     OCResourcePayloadAddStringLL(&dmn, "en");
 718     OCResourcePayloadAddStringLL(&dmn, "Manufacturer");
 719     OCResourcePayloadAddStringLL(&dmn, "de");
 720     OCResourcePayloadAddStringLL(&dmn, "Hersteller");
 721     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_MFG_NAME, dmn));
 722     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_MFG_NAME, &value));
 723     for (x = dmn, y = (OCStringLL *) value; x && y; x = x->next, y = y->next)
 724     {
 725         EXPECT_STREQ(x->value, y->value);
 726     }
 727     EXPECT_TRUE(!x && !y);
 728     OCFreeOCStringLL((OCStringLL *) value);
 729     value = NULL;
 730     OCFreeOCStringLL(dmn);
 731
 732     const char *dmno = "device-model-number";
 733     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_MODEL_NUM, dmno));
 734     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_MODEL_NUM, &value));
 735     EXPECT_STREQ(dmno, (char *) value);
 736     OICFree(value);
 737     value = NULL;
 738
 739     const char *piid = "protocol-independent-identifier";
 740     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_PROTOCOL_INDEPENDENT_ID, piid));
 741     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_PROTOCOL_INDEPENDENT_ID, &value));
 742     EXPECT_STREQ(piid, (char *) value);
 743     OICFree(value);
 744     value = NULL;
 745
 746     EXPECT_EQ(OC_STACK_OK, OCStop());
 747 }
 748
 749 TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery)
 750 {
 751     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 752     OCCallbackData cbData;
 753     OCDoHandle handle;
 754
 755     OIC_LOG(INFO, TAG, "Starting DoResourceDeviceDiscovery test ");
 756     InitStack(OC_CLIENT);
 757
 758     /* Start a discovery query*/
 759     char szQueryUri[MAX_QUERY_LENGTH] = { 0 };
 760     strcpy(szQueryUri, OC_RSRVD_WELL_KNOWN_URI);
 761     cbData.cb = asyncDoResourcesCallback;
 762     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 763     cbData.cd = NULL;
 764     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
 765                                         OC_REST_GET,
 766                                         szQueryUri,
 767                                         0,
 768                                         0,
 769                                         CT_ADAPTER_IP,
 770                                         OC_LOW_QOS,
 771                                         &cbData,
 772                                         NULL,
 773                                         0));
 774     EXPECT_EQ(OC_STACK_OK, OCStop());
 775 }
 776
 777 TEST(StackResource, DISABLED_UpdateResourceNullURI)
 778 {
 779     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 780     OCCallbackData cbData;
 781     OCDoHandle handle;
 782
 783     OIC_LOG(INFO, TAG, "Starting UpdateResourceNullURI test");
 784     InitStack(OC_CLIENT);
 785
 786     /* Start a discovery query*/
 787     char szQueryUri[MAX_QUERY_LENGTH] = { 0 };
 788     strcpy(szQueryUri, OC_RSRVD_WELL_KNOWN_URI);
 789     cbData.cb = asyncDoResourcesCallback;
 790     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 791     cbData.cd = NULL;
 792     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
 793                                         OC_REST_GET,
 794                                         szQueryUri,
 795                                         0,
 796                                         0,
 797                                         CT_ADAPTER_IP,
 798                                         OC_LOW_QOS,
 799                                         &cbData,
 800                                         NULL,
 801                                         0));
 802     EXPECT_EQ(OC_STACK_OK, OCStop());
 803 }
 804
 805 TEST(StackResource, CreateResourceBadParams)
 806 {
 807     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 808     OIC_LOG(INFO, TAG, "Starting CreateResourceBadParams test");
 809     InitStack(OC_SERVER);
 810
 811     OCResourceHandle handle;
 812
 813     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(NULL, //&handle,
 814                                             "core.led",
 815                                             "core.rw",
 816                                             "/a/led",
 817                                             0,
 818                                             NULL,
 819                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 820
 821     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 822                                             NULL, //"core.led",
 823                                             "core.rw",
 824                                             "/a/led",
 825                                             0,
 826                                             NULL,
 827                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 828
 829     // Property bitmask out of range
 830     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 831                                             "core.led",
 832                                             "core.rw",
 833                                             "/a/led",
 834                                             0,
 835                                             NULL,
 836                                             255));// invalid bitmask for OCResourceProperty
 837
 838     EXPECT_EQ(OC_STACK_OK, OCStop());
 839 }
 840
 841 TEST(StackResource, CreateResourceBadUri)
 842 {
 843     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 844     OIC_LOG(INFO, TAG, "Starting CreateResourceBadUri test");
 845     InitStack(OC_SERVER);
 846
 847     const char *uri257 = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVW";
 848
 849     OCResourceHandle handle;
 850
 851     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 852                                             "core.led",
 853                                             "core.rw",
 854                                             NULL, //"/a/led",
 855                                             0,
 856                                             0,
 857                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 858
 859     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 860                                             "core.led",
 861                                             "core.rw",
 862                                             "", //"/a/led",
 863                                             0,
 864                                             0,
 865                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 866
 867     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 868                                             "core.led",
 869                                             "core.rw",
 870                                             uri257, //"/a/led",
 871                                             0,
 872                                             0,
 873                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 874
 875     EXPECT_EQ(OC_STACK_OK, OCStop());
 876 }
 877
 878 TEST(StackResource, CreateResourceSuccess)
 879 {
 880     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 881     OIC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
 882     InitStack(OC_SERVER);
 883
 884     OCResourceHandle handle;
 885     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 886                                             "core.led",
 887                                             "core.rw",
 888                                             "/a/led",
 889                                             0,
 890                                             NULL,
 891                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 892     const char *url = OCGetResourceUri(handle);
 893     EXPECT_STREQ("/a/led", url);
 894
 895     EXPECT_EQ(OC_STACK_OK, OCStop());
 896 }
 897
 898 TEST(StackResource, CreateResourceSuccessWithResourcePolicyPropNone)
 899 {
 900     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 901     OIC_LOG(INFO, TAG, "Starting CreateResourceSuccessWithResourcePolicyPropNone test");
 902     InitStack(OC_SERVER);
 903
 904     OCResourceHandle handle;
 905     // the resource is non-discoverable & non-observable by the client.
 906     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 907                                             "core.led",
 908                                             "core.rw",
 909                                             "/a/led",
 910                                             0,
 911                                             NULL,
 912                                             OC_RES_PROP_NONE));// the resource is non-discoverable &
 913                                                 // non-observable by the client.
 914     const char* url = OCGetResourceUri(handle);
 915     EXPECT_STREQ("/a/led", url);
 916
 917     EXPECT_EQ(OC_STACK_OK, OCStop());
 918 }
 919
 920 TEST(StackResource, CreateResourceWithClientStackMode)
 921 {
 922     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 923     OIC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
 924     InitStack(OC_CLIENT);
 925
 926     OCResourceHandle handle;
 927     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 928                                             "core.led",
 929                                             "core.rw",
 930                                             "/a/led",
 931                                             0,
 932                                             NULL,
 933                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 934
 935     EXPECT_EQ(OC_STACK_OK, OCStop());
 936 }
 937
 938 TEST(StackResource, CreateResourceFailDuplicateUri)
 939 {
 940     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 941     OIC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
 942     InitStack(OC_SERVER);
 943
 944     OCResourceHandle handle;
 945     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 946                                             "core.led",
 947                                             "core.rw",
 948                                             "/a/led",
 949                                             0,
 950                                             NULL,
 951                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 952     const char *url = OCGetResourceUri(handle);
 953     EXPECT_STREQ("/a/led", url);
 954
 955     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 956                                             "core.led",
 957                                             "core.rw",
 958                                             "/a/led",
 959                                             0,
 960                                             NULL,
 961                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 962
 963     EXPECT_EQ(OC_STACK_OK, OCStop());
 964 }
 965
 966 TEST(StackResource, CreateResourceMultipleResources)
 967 {
 968     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 969     OIC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
 970     InitStack(OC_SERVER);
 971
 972     OCResourceHandle handle1;
 973     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 974                                             "core.led",
 975                                             "core.rw",
 976                                             "/a/led1",
 977                                             0,
 978                                             NULL,
 979                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 980
 981     OCResourceHandle handle2;
 982     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 983                                             "core.led",
 984                                             "core.rw",
 985                                             "/a/led2",
 986                                             0,
 987                                             NULL,
 988                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 989     OCResourceHandle handle3;
 990     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 991                                             "core.led",
 992                                             "core.rw",
 993                                             "/a/led3",
 994                                             0,
 995                                             NULL,
 996                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 997
 998     const char *url = OCGetResourceUri(handle1);
 999     EXPECT_STREQ("/a/led1", url);
1000
1001     url = OCGetResourceUri(handle2);
1002     EXPECT_STREQ("/a/led2", url);
1003
1004     url = OCGetResourceUri(handle3);
1005     EXPECT_STREQ("/a/led3", url);
1006
1007     EXPECT_EQ(OC_STACK_OK, OCStop());
1008 }
1009
1010 TEST(StackResource, CreateResourceBadResoureType)
1011 {
1012     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1013     OIC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
1014     InitStack(OC_SERVER);
1015
1016     OCResourceHandle handle;
1017     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
1018                                             NULL, //"core.led",
1019                                             "core.rw",
1020                                             "/a/led",
1021                                             0,
1022                                             NULL,
1023                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1024
1025     OCResourceHandle handle2;
1026     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle2,
1027                                             "",
1028                                             "core.rw",
1029                                             "/a/led",
1030                                             0,
1031                                             NULL,
1032                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1033
1034     EXPECT_EQ(OC_STACK_OK, OCStop());
1035 }
1036
1037 TEST(StackResource, CreateResourceGoodResourceType)
1038 {
1039     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1040     OIC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
1041     InitStack(OC_SERVER);
1042
1043     OCResourceHandle handle;
1044     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1045                                             "core.led",
1046                                             "core.rw",
1047                                             "/a/led",
1048                                             0,
1049                                             NULL,
1050                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1051
1052     EXPECT_EQ(OC_STACK_OK, OCStop());
1053 }
1054
1055 TEST(StackResource, CreateResourceWithBadEndpointsFlags)
1056 {
1057     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1058
1059     OIC_LOG(INFO, TAG, "CreateResourceWithEndpointsFlags test");
1060
1061     InitStack(OC_SERVER);
1062
1063     OCResourceHandle handle;
1064     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResourceWithEp(&handle,
1065                                             "core.led",
1066                                             "core.rw",
1067                                             "/a/led",
1068                                             0,
1069                                             NULL,
1070                                             OC_DISCOVERABLE|OC_OBSERVABLE,
1071                                             (OCTpsSchemeFlags)INVALID_TPS_FLAGS));
1072
1073     EXPECT_EQ(OC_STACK_OK, OCStop());
1074 }
1075
1076 TEST(StackResource, CreateResourceWithGoodEndpointsFlags)
1077 {
1078     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1079
1080     OIC_LOG(INFO, TAG, "CreateResourceWithEndpointsFlags test");
1081
1082     InitStack(OC_SERVER);
1083
1084     OCResourceHandle handle;
1085     EXPECT_EQ(OC_STACK_OK, OCCreateResourceWithEp(&handle,
1086                                             "core.led",
1087                                             "core.rw",
1088                                             "/a/led",
1089                                             0,
1090                                             NULL,
1091                                             OC_DISCOVERABLE|OC_OBSERVABLE,
1092                                             OC_ALL));
1093     OCResourceHandle handle2;
1094     EXPECT_EQ(OC_STACK_OK, OCCreateResourceWithEp(&handle2,
1095                                             "core.led",
1096                                             "core.rw",
1097                                             "/a/led2",
1098                                             0,
1099                                             NULL,
1100                                             OC_DISCOVERABLE|OC_OBSERVABLE,
1101                                             OC_COAP));
1102 #ifdef TCP_ADAPTER
1103     OCResourceHandle handle3;
1104     EXPECT_EQ(OC_STACK_OK, OCCreateResourceWithEp(&handle3,
1105                                             "core.led",
1106                                             "core.rw",
1107                                             "/a/led3",
1108                                             0,
1109                                             NULL,
1110                                             OC_DISCOVERABLE|OC_OBSERVABLE,
1111                                             OC_COAP_TCP));
1112
1113     OCResourceHandle handle4;
1114     EXPECT_EQ(OC_STACK_OK, OCCreateResourceWithEp(&handle4,
1115                                             "core.led",
1116                                             "core.rw",
1117                                             "/a/led4",
1118                                             0,
1119                                             NULL,
1120                                             OC_DISCOVERABLE|OC_OBSERVABLE,
1121                                             (OCTpsSchemeFlags)(OC_COAP | OC_COAP_TCP)));
1122 #endif
1123
1124     EXPECT_EQ(OC_STACK_OK, OCStop());
1125 }
1126
1127 TEST(StackResource, ResourceTypeName)
1128 {
1129     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1130     OIC_LOG(INFO, TAG, "Starting ResourceTypeName test");
1131     InitStack(OC_SERVER);
1132
1133     OCResourceHandle handle;
1134     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1135                                             "core.led",
1136                                             "core.rw",
1137                                             "/a/led",
1138                                             0,
1139                                             NULL,
1140                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1141
1142     uint8_t numResourceTypes;
1143     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1144     EXPECT_EQ(1, numResourceTypes);
1145     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1146     EXPECT_STREQ("core.led", resourceTypeName);
1147
1148     // try getting resource type names with an invalid index
1149     resourceTypeName = OCGetResourceTypeName(handle, 1);
1150     EXPECT_STREQ(NULL, resourceTypeName);
1151     // try getting resource type names with an invalid index
1152     resourceTypeName = OCGetResourceTypeName(handle, 10);
1153     EXPECT_STREQ(NULL, resourceTypeName);
1154
1155     EXPECT_EQ(OC_STACK_OK, OCStop());
1156 }
1157
1158 TEST(StackResource, ResourceTypeAttrRepresentation)
1159 {
1160     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1161     OIC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
1162     InitStack(OC_SERVER);
1163
1164     OCResourceHandle handle;
1165     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1166                                             "core.led",
1167                                             "core.rw",
1168                                             "/a/led",
1169                                             0,
1170                                             NULL,
1171                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1172
1173     uint8_t numResourceTypes;
1174     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1175     EXPECT_EQ(1, numResourceTypes);
1176
1177     EXPECT_EQ(OC_STACK_OK, OCStop());
1178 }
1179
1180 TEST(StackResource, ResourceTypeInterface)
1181 {
1182     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1183     OIC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
1184     InitStack(OC_SERVER);
1185
1186     OCResourceHandle handle;
1187     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1188                                             "core.led",
1189                                             "core.rw",
1190                                             "/a/led",
1191                                             0,
1192                                             NULL,
1193                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1194
1195     uint8_t numResourceInterfaces;
1196     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1197     EXPECT_EQ(2, numResourceInterfaces);
1198     const char *resourceInterfaceName1 = OCGetResourceInterfaceName(handle, 0);
1199     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, resourceInterfaceName1);
1200     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1201     EXPECT_STREQ("core.rw", resourceInterfaceName);
1202
1203     // try getting resource interface names with an invalid index
1204     resourceInterfaceName = OCGetResourceInterfaceName(handle, 2);
1205     EXPECT_STREQ(NULL, resourceInterfaceName);
1206     // try getting resource interface names with an invalid index
1207     resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
1208     EXPECT_STREQ(NULL, resourceInterfaceName);
1209
1210     EXPECT_EQ(OC_STACK_OK, OCStop());
1211 }
1212
1213 TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
1214 {
1215     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1216
1217     OIC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
1218
1219     InitStack(OC_SERVER);
1220
1221     OCResourceHandle handle;
1222     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1223                                             "core.led",
1224                                             "core.rw",
1225                                             "/a/led",
1226                                             0,
1227                                             NULL,
1228                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1229     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1230                                         OC_RSRVD_INTERFACE_DEFAULT));
1231     uint8_t numResourceInterfaces;
1232     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1233     EXPECT_EQ(2, numResourceInterfaces);
1234
1235     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
1236     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
1237
1238     const char*interfaceName_2 = OCGetResourceInterfaceName(handle, 1);
1239     EXPECT_STREQ("core.rw", interfaceName_2);
1240
1241     EXPECT_EQ(OC_STACK_OK, OCStop());
1242 }
1243
1244 TEST(StackResource, ResourceDuplicateDefaultInterfaces)
1245 {
1246     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1247
1248     OIC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
1249
1250     InitStack(OC_SERVER);
1251
1252     OCResourceHandle handle;
1253     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1254                                             "core.led",
1255                                             "core.rw",
1256                                             "/a/led",
1257                                             0,
1258                                             NULL,
1259                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1260
1261     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1262                                         OC_RSRVD_INTERFACE_DEFAULT));
1263     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1264                                         OC_RSRVD_INTERFACE_DEFAULT));
1265
1266     uint8_t numResourceInterfaces;
1267     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1268     EXPECT_EQ(2, numResourceInterfaces);
1269
1270     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
1271     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
1272
1273     EXPECT_EQ(OC_STACK_OK, OCStop());
1274 }
1275
1276 TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
1277 {
1278     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1279
1280     OIC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
1281
1282     InitStack(OC_SERVER);
1283
1284     OCResourceHandle handle;
1285     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1286                                             "core.led",
1287                                             "core.rw",
1288                                             "/a/led",
1289                                             0,
1290                                             NULL,
1291                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1292
1293     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1294                                         "core.rw"));
1295     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1296                                         "core.rw"));
1297
1298     uint8_t numResourceInterfaces;
1299     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1300     EXPECT_EQ(2, numResourceInterfaces);
1301
1302     EXPECT_EQ(OC_STACK_OK, OCStop());
1303 }
1304
1305 TEST(StackResource, ResourceTypeInterfaceMethods)
1306 {
1307     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1308     OIC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods 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
1320     uint8_t numResourceInterfaces;
1321     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1322     EXPECT_EQ(2, numResourceInterfaces);
1323
1324     EXPECT_EQ(OC_STACK_OK, OCStop());
1325 }
1326
1327 TEST(StackResource, GetResourceProperties)
1328 {
1329     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1330     OIC_LOG(INFO, TAG, "Starting GetResourceProperties test");
1331     InitStack(OC_SERVER);
1332
1333     uint8_t props = OC_DISCOVERABLE|OC_OBSERVABLE;
1334     OCResourceHandle handle;
1335     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1336                                             "core.led",
1337                                             "core.rw",
1338                                             "/a/led",
1339                                             0,
1340                                             NULL,
1341                                             props));
1342
1343     EXPECT_EQ(props, OCGetResourceProperties(handle) & props);
1344     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1345
1346     EXPECT_EQ(OC_STACK_OK, OCStop());
1347 }
1348
1349 TEST(StackResource, SetResourceProperties)
1350 {
1351     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1352     OIC_LOG(INFO, TAG, "Starting SetResourceProperties test");
1353     InitStack(OC_SERVER);
1354
1355     OCResourceHandle handle;
1356     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1357                                             "core.led",
1358                                             "core.rw",
1359                                             "/a/led",
1360                                             0,
1361                                             NULL,
1362                                             0));
1363
1364     uint8_t props = OC_DISCOVERABLE|OC_OBSERVABLE;
1365     EXPECT_EQ(OC_STACK_OK, OCSetResourceProperties(handle, props));
1366     EXPECT_EQ(props, OCGetResourceProperties(handle) & props);
1367
1368     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1369
1370     EXPECT_EQ(OC_STACK_OK, OCStop());
1371 }
1372
1373 TEST(StackResource, ClearResourceProperties)
1374 {
1375     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1376     OIC_LOG(INFO, TAG, "Starting ClearResourceProperties test");
1377     InitStack(OC_SERVER);
1378
1379     uint8_t props = OC_DISCOVERABLE|OC_OBSERVABLE;
1380     OCResourceHandle handle;
1381     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1382                                             "core.led",
1383                                             "core.rw",
1384                                             "/a/led",
1385                                             0,
1386                                             NULL,
1387                                             props));
1388
1389     EXPECT_EQ(OC_STACK_OK, OCClearResourceProperties(handle, props));
1390     EXPECT_EQ(0, OCGetResourceProperties(handle) & props);
1391
1392     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1393
1394     EXPECT_EQ(OC_STACK_OK, OCStop());
1395 }
1396
1397 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
1398 {
1399     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1400     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
1401     InitStack(OC_SERVER);
1402     uint8_t numResources = 0;
1403     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1404
1405     OCResourceHandle handle;
1406     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1407                                             "core.led",
1408                                             "core.rw",
1409                                             "/a1/led",
1410                                             0,
1411                                             NULL,
1412                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1413     const char *url = OCGetResourceUri(handle);
1414     EXPECT_STREQ("/a1/led", url);
1415
1416     //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
1417     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1418     uint8_t numExpectedResources = 0;
1419
1420     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1421     EXPECT_EQ(numExpectedResources, numResources);
1422
1423     EXPECT_EQ(OC_STACK_OK, OCStop());
1424 }
1425
1426 TEST(StackResource, StackTestResourceDiscoverOneResource)
1427 {
1428     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1429     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
1430     InitStack(OC_SERVER);
1431
1432     OCResourceHandle handle;
1433     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1434                                             "core.led",
1435                                             "core.rw",
1436                                             "/a/led",
1437                                             0,
1438                                             NULL,
1439                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1440     const char *url = OCGetResourceUri(handle);
1441     EXPECT_STREQ("/a/led", url);
1442
1443     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1444     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1445
1446     EXPECT_EQ(OC_STACK_OK, OCStop());
1447 }
1448
1449 TEST(StackResource, StackTestResourceDiscoverManyResources)
1450 {
1451     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1452     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
1453     InitStack(OC_SERVER);
1454
1455     OCResourceHandle handle1;
1456     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1457                                             "core.led",
1458                                             "core.rw",
1459                                             "/a/led1",
1460                                             0,
1461                                             NULL,
1462                                             OC_DISCOVERABLE));
1463     const char *url = OCGetResourceUri(handle1);
1464     EXPECT_STREQ("/a/led1", url);
1465
1466     OCResourceHandle handle2;
1467     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1468                                             "core.led",
1469                                             "core.rw",
1470                                             "/a/led2",
1471                                             0,
1472                                             NULL,
1473                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1474     url = OCGetResourceUri(handle2);
1475     EXPECT_STREQ("/a/led2", url);
1476
1477     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
1478     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
1479
1480     OCResourceHandle handle3;
1481     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1482                                             "core.led",
1483                                             "core.rw",
1484                                             "/a/led3",
1485                                             0,
1486                                             NULL,
1487                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1488     url = OCGetResourceUri(handle3);
1489     EXPECT_STREQ("/a/led3", url);
1490
1491     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
1492     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
1493
1494     OCResourceHandle handle4;
1495     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1496                                             "core.led",
1497                                             "core.rw",
1498                                             "/a/led4",
1499                                             0,
1500                                             NULL,
1501                                             OC_DISCOVERABLE));
1502     url = OCGetResourceUri(handle4);
1503     EXPECT_STREQ("/a/led4", url);
1504
1505     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
1506     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
1507     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
1508
1509     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1510
1511     EXPECT_EQ(OC_STACK_OK, OCStop());
1512 }
1513
1514 TEST_F(OCDevicePropertiesTests, DevicePropertiesToCBORPayloadllNULL)
1515 {
1516     EXPECT_EQ(OC_STACK_INVALID_PARAM, DevicePropertiesToCBORPayload(NULL, NULL, NULL));
1517 }
1518
1519 TEST_F(OCDevicePropertiesTests, DevicePropertiesToCBORPayloadNULLPayload)
1520 {
1521     OCDeviceProperties* deviceProps = getTestDeviceProps();
1522     ASSERT_TRUE(NULL != deviceProps);
1523     size_t size = 0;
1524
1525     EXPECT_EQ(OC_STACK_INVALID_PARAM, DevicePropertiesToCBORPayload(deviceProps, NULL, &size));
1526
1527     CleanUpDeviceProperties(&deviceProps);
1528 }
1529
1530 TEST_F(OCDevicePropertiesTests, DevicePropertiesToCBORPayloadNULLSize)
1531 {
1532     OCDeviceProperties* deviceProps = getTestDeviceProps();
1533     ASSERT_TRUE(NULL != deviceProps);
1534     uint8_t* payload = NULL;
1535
1536     EXPECT_EQ(OC_STACK_INVALID_PARAM, DevicePropertiesToCBORPayload(deviceProps, &payload, NULL));
1537
1538     CleanUpDeviceProperties(&deviceProps);
1539 }
1540
1541 TEST_F(OCDevicePropertiesTests, DevicePropertiesToCBORPayloadNULLDeviceProperties)
1542 {
1543     uint8_t* payload = NULL;
1544     size_t size = 0;
1545
1546     EXPECT_EQ(OC_STACK_INVALID_PARAM, DevicePropertiesToCBORPayload(NULL, &payload, &size));
1547 }
1548
1549 TEST_F(OCDevicePropertiesTests, DevicePropertiesToCBORPayloadVALID)
1550 {
1551     OCDeviceProperties* deviceProps = getTestDeviceProps();
1552     ASSERT_TRUE(NULL != deviceProps);
1553     uint8_t* payload = NULL;
1554     size_t size = 0;
1555
1556     EXPECT_EQ(OC_STACK_OK, DevicePropertiesToCBORPayload(deviceProps, &payload, &size));
1557     EXPECT_TRUE(payload != NULL);
1558
1559     CleanUpDeviceProperties(&deviceProps);
1560     OICFree(payload);
1561 }
1562
1563 TEST_F(OCDevicePropertiesTests, CBORPayloadToDevicePropertiesAllNULL)
1564 {
1565     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToDeviceProperties(NULL, 0, NULL));
1566 }
1567
1568 TEST_F(OCDevicePropertiesTests, CBORPayloadToDevicePropertiesNULLPayload)
1569 {
1570     OCDeviceProperties* deviceProps = NULL;
1571     size_t size = 10;
1572
1573     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToDeviceProperties(NULL, size, &deviceProps));
1574 }
1575
1576 TEST_F(OCDevicePropertiesTests, CBORPayloadToDevicePropertiesInvalidSize)
1577 {
1578     OCDeviceProperties* deviceProps = NULL;
1579     uint8_t* payload = (uint8_t*)OICCalloc(1, sizeof(uint8_t));
1580     ASSERT_TRUE(NULL != payload);
1581
1582     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToDeviceProperties(payload, 0, &deviceProps));
1583
1584     OICFree(payload);
1585 }
1586
1587 TEST_F(OCDevicePropertiesTests, CBORPayloadToDevicePropertiesNULLDeviceProperties)
1588 {
1589     uint8_t* payload = (uint8_t*)OICCalloc(1, sizeof(uint8_t));
1590     ASSERT_TRUE(NULL != payload);
1591     size_t size = 10;
1592
1593     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToDeviceProperties(payload, size, NULL));
1594
1595     OICFree(payload);
1596 }
1597
1598 TEST_F(OCDevicePropertiesTests, CBORPayloadToDevicePropertiesVALID)
1599 {
1600     OCDeviceProperties* controlDeviceProps = getTestDeviceProps();
1601     ASSERT_TRUE(NULL != controlDeviceProps);
1602     OCDeviceProperties* testDeviceProps = NULL;
1603     uint8_t* payload = NULL;
1604     size_t size = 0;
1605
1606     EXPECT_EQ(OC_STACK_OK, DevicePropertiesToCBORPayload(controlDeviceProps, &payload, &size));
1607     EXPECT_TRUE(payload != NULL);
1608
1609     EXPECT_EQ(OC_STACK_OK, CBORPayloadToDeviceProperties(payload, size, &testDeviceProps));
1610     ASSERT_TRUE(testDeviceProps != NULL);
1611     EXPECT_STREQ(gDevicePIID, testDeviceProps->protocolIndependentId);
1612
1613     CleanUpDeviceProperties(&controlDeviceProps);
1614     CleanUpDeviceProperties(&testDeviceProps);
1615     OICFree(payload);
1616 }
1617
1618 TEST_F(OCDevicePropertiesTests, PIIDAvailableAfterInit)
1619 {
1620     void *piid = NULL;
1621
1622     InitStack(OC_SERVER);
1623
1624     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_PROTOCOL_INDEPENDENT_ID, &piid));
1625     ASSERT_TRUE(piid != NULL);
1626
1627     OICFree(piid);
1628
1629     EXPECT_EQ(OC_STACK_OK, OCStop());
1630 }
1631
1632 TEST_F(OCDevicePropertiesTests, UpdatePIID)
1633 {
1634     void *originalPIID = NULL;
1635     void *newPIID = NULL;
1636
1637     InitStack(OC_SERVER);
1638
1639     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_PROTOCOL_INDEPENDENT_ID, &originalPIID));
1640     ASSERT_TRUE(originalPIID != NULL);
1641
1642     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_PROTOCOL_INDEPENDENT_ID, gDevicePIID));
1643
1644     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_PROTOCOL_INDEPENDENT_ID, &newPIID));
1645     ASSERT_TRUE(newPIID != NULL);
1646     EXPECT_STREQ(gDevicePIID, (char *)newPIID);
1647     EXPECT_STRNE((char *)originalPIID, (char *)newPIID);
1648
1649     OICFree(newPIID);
1650     OICFree(originalPIID);
1651
1652     EXPECT_EQ(OC_STACK_OK, OCStop());
1653 }
1654
1655 TEST(StackBind, BindResourceTypeNameBad)
1656 {
1657     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1658     OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
1659     InitStack(OC_SERVER);
1660
1661     OCResourceHandle handle;
1662     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1663                                             "core.led",
1664                                             "core.rw",
1665                                             "/a/led",
1666                                             0,
1667                                             NULL,
1668                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1669
1670     uint8_t numResourceTypes;
1671     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1672     EXPECT_EQ(1, numResourceTypes);
1673     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1674     EXPECT_STREQ("core.led", resourceTypeName);
1675
1676     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
1677     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, "core.nameBad"));
1678     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, "core.name bad"));
1679
1680     EXPECT_EQ(OC_STACK_OK, OCStop());
1681 }
1682
1683 TEST(StackBind, BindResourceTypeNameGood)
1684 {
1685     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1686     OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
1687     InitStack(OC_SERVER);
1688
1689     OCResourceHandle handle;
1690     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1691                                             "core.led",
1692                                             "core.rw",
1693                                             "/a/led",
1694                                             0,
1695                                             NULL,
1696                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1697
1698     uint8_t numResourceTypes;
1699     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1700     EXPECT_EQ(1, numResourceTypes);
1701     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1702     EXPECT_STREQ("core.led", resourceTypeName);
1703
1704     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1705     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1706     EXPECT_EQ(2, numResourceTypes);
1707     resourceTypeName = OCGetResourceTypeName(handle, 1);
1708     EXPECT_STREQ("core.brightled", resourceTypeName);
1709
1710     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1711     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1712     EXPECT_EQ(3, numResourceTypes);
1713     resourceTypeName = OCGetResourceTypeName(handle, 2);
1714     EXPECT_STREQ("core.reallybrightled", resourceTypeName);
1715
1716     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "x.ReallyReallyBrightLED"));
1717     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1718     EXPECT_EQ(4, numResourceTypes);
1719     resourceTypeName = OCGetResourceTypeName(handle, 3);
1720     EXPECT_STREQ("x.ReallyReallyBrightLED", resourceTypeName);
1721
1722     EXPECT_EQ(OC_STACK_OK, OCStop());
1723 }
1724
1725 TEST(StackBind, BindResourceTypeAttribRepGood)
1726 {
1727     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1728     OIC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
1729     InitStack(OC_SERVER);
1730
1731     OCResourceHandle handle;
1732     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1733                                             "core.led",
1734                                             "core.rw",
1735                                             "/a/led",
1736                                             0,
1737                                             NULL,
1738                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1739
1740     uint8_t numResourceTypes;
1741     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1742     EXPECT_EQ(1, numResourceTypes);
1743
1744     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1745     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1746     EXPECT_EQ(2, numResourceTypes);
1747
1748     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1749     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1750     EXPECT_EQ(3, numResourceTypes);
1751
1752     EXPECT_EQ(OC_STACK_OK, OCStop());
1753 }
1754
1755
1756 TEST(StackBind, BindResourceInterfaceNameBad)
1757 {
1758     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1759     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
1760     InitStack(OC_SERVER);
1761
1762     OCResourceHandle handle;
1763     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1764                                             "core.led",
1765                                             "core.rw",
1766                                             "/a/led",
1767                                             0,
1768                                             NULL,
1769                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1770
1771     uint8_t numResourceInterfaces;
1772     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1773     EXPECT_EQ(2, numResourceInterfaces);
1774     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1775     EXPECT_STREQ("core.rw", resourceInterfaceName);
1776
1777     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
1778
1779     EXPECT_EQ(OC_STACK_OK, OCStop());
1780 }
1781
1782 TEST(StackBind, BindResourceInterfaceNameGood)
1783 {
1784     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1785     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
1786     InitStack(OC_SERVER);
1787
1788     OCResourceHandle handle;
1789     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1790                                             "core.led",
1791                                             "core.rw",
1792                                             "/a/led",
1793                                             0,
1794                                             NULL,
1795                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1796
1797     uint8_t numResourceInterfaces;
1798     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1799     EXPECT_EQ(2, numResourceInterfaces);
1800     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1801     EXPECT_STREQ("core.rw", resourceInterfaceName);
1802
1803     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1804
1805     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1806     EXPECT_EQ(3, numResourceInterfaces);
1807     resourceInterfaceName = OCGetResourceInterfaceName(handle, 2);
1808     EXPECT_STREQ("core.r", resourceInterfaceName);
1809
1810     EXPECT_EQ(OC_STACK_OK, OCStop());
1811 }
1812
1813 TEST(StackBind, BindResourceInterfaceMethodsBad)
1814 {
1815     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1816     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
1817     InitStack(OC_SERVER);
1818
1819     OCResourceHandle handle;
1820     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1821                                             "core.led",
1822                                             "core.rw",
1823                                             "/a/led",
1824                                             0,
1825                                             NULL,
1826                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1827
1828     uint8_t numResourceInterfaces;
1829     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1830     EXPECT_EQ(2, numResourceInterfaces);
1831
1832     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
1833
1834     EXPECT_EQ(OC_STACK_OK, OCStop());
1835 }
1836
1837 TEST(StackBind, BindResourceInterfaceMethodsGood)
1838 {
1839     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1840     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
1841     InitStack(OC_SERVER);
1842
1843     OCResourceHandle handle;
1844     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1845                                             "core.led",
1846                                             "core.rw",
1847                                             "/a/led",
1848                                             0,
1849                                             NULL,
1850                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1851
1852     uint8_t numResourceInterfaces;
1853     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1854     EXPECT_EQ(2, numResourceInterfaces);
1855
1856     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1857
1858     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1859     EXPECT_EQ(3, numResourceInterfaces);
1860
1861     EXPECT_EQ(OC_STACK_OK, OCStop());
1862 }
1863
1864 TEST(StackBind, BindContainedResourceBad)
1865 {
1866     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1867     OIC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
1868     InitStack(OC_SERVER);
1869
1870     OCResourceHandle containerHandle;
1871     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1872                                             "core.led",
1873                                             "core.rw",
1874                                             "/a/kitchen",
1875                                             0,
1876                                             NULL,
1877                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1878
1879     OCResourceHandle handle0;
1880     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1881                                             "core.led",
1882                                             "core.rw",
1883                                             "/a/led",
1884                                             0,
1885                                             NULL,
1886                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1887
1888     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1889
1890     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1891
1892     EXPECT_EQ(OC_STACK_OK, OCStop());
1893 }
1894
1895 TEST(StackBind, BindContainedResourceGood)
1896 {
1897     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1898     OIC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1899     InitStack(OC_SERVER);
1900
1901     uint8_t numResources = 0;
1902     uint8_t numExpectedResources = 0;
1903
1904     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1905
1906     OCResourceHandle containerHandle;
1907     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1908                                             "core.led",
1909                                             "core.rw",
1910                                             "/a/kitchen",
1911                                             0,
1912                                             NULL,
1913                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1914     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1915     EXPECT_EQ(++numExpectedResources, numResources);
1916
1917     OCResourceHandle handle0;
1918     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1919                                             "core.led",
1920                                             "core.rw",
1921                                             "/a/led0",
1922                                             0,
1923                                             NULL,
1924                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1925     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1926     EXPECT_EQ(++numExpectedResources, numResources);
1927
1928     OCResourceHandle handle1;
1929     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1930                                             "core.led",
1931                                             "core.rw",
1932                                             "/a/led1",
1933                                             0,
1934                                             NULL,
1935                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1936     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1937     EXPECT_EQ(++numExpectedResources, numResources);
1938
1939     OCResourceHandle handle2;
1940     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1941                                             "core.led",
1942                                             "core.rw",
1943                                             "/a/led2",
1944                                             0,
1945                                             NULL,
1946                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1947     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1948     EXPECT_EQ(++numExpectedResources, numResources);
1949
1950     OCResourceHandle handle3;
1951     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1952                                             "core.led",
1953                                             "core.rw",
1954                                             "/a/led3",
1955                                             0,
1956                                             NULL,
1957                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1958     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1959     EXPECT_EQ(++numExpectedResources, numResources);
1960
1961     OCResourceHandle handle4;
1962     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1963                                             "core.led",
1964                                             "core.rw",
1965                                             "/a/led4",
1966                                             0,
1967                                             NULL,
1968                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1969     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1970     EXPECT_EQ(++numExpectedResources, numResources);
1971
1972     OCResourceHandle handle5;
1973     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1974                                             "core.led",
1975                                             "core.rw",
1976                                             "/a/led5",
1977                                             0,
1978                                             NULL,
1979                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1980     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1981     EXPECT_EQ(++numExpectedResources, numResources);
1982
1983
1984     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1985     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1986     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1987     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1988     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1989     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle5));
1990
1991     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1992     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1993     EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1994     EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1995     EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1996     EXPECT_EQ(handle5, OCGetResourceHandleFromCollection(containerHandle, 5));
1997
1998     EXPECT_EQ(OC_STACK_OK, OCStop());
1999 }
2000
2001
2002 TEST(StackBind, BindEntityHandlerBad)
2003 {
2004     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2005     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
2006     InitStack(OC_SERVER);
2007
2008     OCResourceHandle handle;
2009     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
2010                                             "core.led",
2011                                             "core.rw",
2012                                             "/a/led",
2013                                             0,
2014                                             NULL,
2015                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2016
2017     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
2018
2019     EXPECT_EQ(OC_STACK_OK, OCStop());
2020 }
2021
2022 TEST(StackBind, BindEntityHandlerGood)
2023 {
2024     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2025     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
2026     InitStack(OC_SERVER);
2027
2028     OCResourceHandle handle;
2029     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
2030                                             "core.led",
2031                                             "core.rw",
2032                                             "/a/led",
2033                                             0,
2034                                             NULL,
2035                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2036
2037     OCEntityHandler myHandler = entityHandler;
2038
2039     EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
2040
2041     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
2042
2043     EXPECT_EQ(OC_STACK_OK, OCStop());
2044 }
2045
2046 TEST(StackResourceAccess, GetResourceByIndex)
2047 {
2048     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2049     OIC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
2050     InitStack(OC_SERVER);
2051
2052     uint8_t numResources = 0;
2053     uint8_t numExpectedResources = 0;
2054     uint8_t resourceIndex = 0;
2055     uint8_t prevResources = 0;
2056     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
2057     prevResources = numExpectedResources;
2058     OCResourceHandle containerHandle;
2059     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
2060                                             "core.led",
2061                                             "core.rw",
2062                                             "/a/kitchen",
2063                                             0,
2064                                             NULL,
2065                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2066     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2067     EXPECT_EQ(++numExpectedResources, numResources);
2068
2069     OCResourceHandle handle0;
2070     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
2071                                             "core.led",
2072                                             "core.rw",
2073                                             "/a/led0",
2074                                             0,
2075                                             NULL,
2076                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2077     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2078     EXPECT_EQ(++numExpectedResources, numResources);
2079
2080     OCResourceHandle handle1;
2081     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
2082                                             "core.led",
2083                                             "core.rw",
2084                                             "/a/led1",
2085                                             0,
2086                                             NULL,
2087                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2088     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2089     EXPECT_EQ(++numExpectedResources, numResources);
2090
2091     OCResourceHandle handle2;
2092     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
2093                                             "core.led",
2094                                             "core.rw",
2095                                             "/a/led2",
2096                                             0,
2097                                             NULL,
2098                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2099     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2100     EXPECT_EQ(++numExpectedResources, numResources);
2101
2102     OCResourceHandle handle3;
2103     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
2104                                             "core.led",
2105                                             "core.rw",
2106                                             "/a/led3",
2107                                             0,
2108                                             NULL,
2109                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2110     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2111     EXPECT_EQ(++numExpectedResources, numResources);
2112
2113     OCResourceHandle handle4;
2114     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
2115                                             "core.led",
2116                                             "core.rw",
2117                                             "/a/led4",
2118                                             0,
2119                                             NULL,
2120                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2121     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2122     EXPECT_EQ(++numExpectedResources, numResources);
2123
2124     OCResourceHandle handle5;
2125     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
2126                                             "core.led",
2127                                             "core.rw",
2128                                             "/a/led5",
2129                                             0,
2130                                             NULL,
2131                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2132     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2133     EXPECT_EQ(++numExpectedResources, numResources);
2134     resourceIndex += prevResources;
2135     EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
2136     EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
2137     EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
2138     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
2139     EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
2140     EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
2141     EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
2142
2143     EXPECT_EQ(OC_STACK_OK, OCStop());
2144 }
2145
2146 TEST(StackResourceAccess, DeleteHeadResource)
2147 {
2148     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2149     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
2150     InitStack(OC_SERVER);
2151
2152     uint8_t numResources = 0;
2153     uint8_t numExpectedResources = 0;
2154
2155     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
2156
2157     OCResourceHandle handle0;
2158     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
2159                                             "core.led",
2160                                             "core.rw",
2161                                             "/a/led0",
2162                                             0,
2163                                             NULL,
2164                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2165     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2166     EXPECT_EQ(++numExpectedResources, numResources);
2167
2168     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
2169     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2170     EXPECT_EQ(--numExpectedResources, numResources);
2171
2172     EXPECT_EQ(OC_STACK_OK, OCStop());
2173 }
2174
2175 TEST(StackResourceAccess, DeleteHeadResource2)
2176 {
2177     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2178     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
2179     InitStack(OC_SERVER);
2180
2181     uint8_t numResources = 0;
2182     uint8_t numExpectedResources = 0;
2183
2184     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
2185     OCResourceHandle handle0;
2186     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
2187                                             "core.led",
2188                                             "core.rw",
2189                                             "/a/led0",
2190                                             0,
2191                                             NULL,
2192                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2193     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2194     EXPECT_EQ(++numExpectedResources, numResources);
2195
2196     OCResourceHandle handle1;
2197     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
2198                                             "core.led",
2199                                             "core.rw",
2200                                             "/a/led1",
2201                                             0,
2202                                             NULL,
2203                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2204     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2205     EXPECT_EQ(++numExpectedResources, numResources);
2206
2207     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
2208     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2209     EXPECT_EQ(--numExpectedResources, numResources);
2210
2211     EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
2212
2213     EXPECT_EQ(OC_STACK_OK, OCStop());
2214 }
2215
2216
2217 TEST(StackResourceAccess, DeleteLastResource)
2218 {
2219     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2220     OIC_LOG(INFO, TAG, "Starting DeleteLastResource test");
2221     InitStack(OC_SERVER);
2222
2223     uint8_t numResources = 0;
2224     uint8_t numExpectedResources = 0;
2225
2226     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
2227
2228     OCResourceHandle handle0;
2229     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
2230                                             "core.led",
2231                                             "core.rw",
2232                                             "/a/led0",
2233                                             0,
2234                                             NULL,
2235                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2236     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2237     EXPECT_EQ(++numExpectedResources, numResources);
2238
2239     OCResourceHandle handle1;
2240     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
2241                                             "core.led",
2242                                             "core.rw",
2243                                             "/a/led1",
2244                                             0,
2245                                             NULL,
2246                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2247     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2248     EXPECT_EQ(++numExpectedResources, numResources);
2249
2250     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
2251     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2252     EXPECT_EQ(--numExpectedResources, numResources);
2253
2254     EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
2255
2256     OCResourceHandle handle2;
2257     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
2258                                             "core.led",
2259                                             "core.rw",
2260                                             "/a/led2",
2261                                             0,
2262                                             NULL,
2263                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2264     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2265     EXPECT_EQ(++numExpectedResources, numResources);
2266
2267     EXPECT_EQ(OC_STACK_OK, OCStop());
2268 }
2269
2270 TEST(StackResourceAccess, DeleteMiddleResource)
2271 {
2272     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2273     OIC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
2274     InitStack(OC_SERVER);
2275
2276     uint8_t numResources = 0;
2277     uint8_t numExpectedResources = 0;
2278     uint8_t resourceIndex = InitResourceIndex();
2279
2280     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
2281     resourceIndex = numExpectedResources;
2282     OCResourceHandle handle0;
2283     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
2284                                             "core.led",
2285                                             "core.rw",
2286                                             "/a/led0",
2287                                             0,
2288                                             NULL,
2289                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2290     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2291     EXPECT_EQ(++numExpectedResources, numResources);
2292
2293     OCResourceHandle handle1;
2294     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
2295                                             "core.led",
2296                                             "core.rw",
2297                                             "/a/led1",
2298                                             0,
2299                                             NULL,
2300                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2301     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2302     EXPECT_EQ(++numExpectedResources, numResources);
2303
2304     OCResourceHandle handle2;
2305     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
2306                                             "core.led",
2307                                             "core.rw",
2308                                             "/a/led2",
2309                                             0,
2310                                             NULL,
2311                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2312     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2313     EXPECT_EQ(++numExpectedResources, numResources);
2314
2315     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
2316     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
2317     EXPECT_EQ(--numExpectedResources, numResources);
2318
2319     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
2320     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
2321
2322     // Make sure the resource elements are still correct
2323     uint8_t numResourceInterfaces;
2324     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
2325     EXPECT_EQ(2, numResourceInterfaces);
2326     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 1);
2327     EXPECT_STREQ("core.rw", resourceInterfaceName);
2328
2329     EXPECT_EQ(OC_STACK_OK, OCStop());
2330 }
2331
2332 // Visual Studio versions earlier than 2015 have bugs in is_pod and report the wrong answer.
2333 #if !defined(_MSC_VER) || (_MSC_VER >= 1900)
2334 TEST(PODTests, OCHeaderOption)
2335 {
2336     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
2337 }
2338
2339 TEST(PODTests, OCCallbackData)
2340 {
2341     EXPECT_TRUE(std::is_pod<OCCallbackData>::value);
2342 }
2343 #endif
2344
2345 TEST(StackResource, MultipleResourcesDiscovery)
2346 {
2347     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2348     OIC_LOG(INFO, TAG, "Starting MultipleResourcesDiscovery test");
2349     InitStack(OC_SERVER);
2350
2351     OCResourceHandle handle1;
2352     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
2353                                             "core.led",
2354                                             "core.rw",
2355                                             "/a/led1",
2356                                             0,
2357                                             NULL,
2358                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2359
2360     OCResourceHandle handle2;
2361     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
2362                                             "core.led",
2363                                             "core.rw",
2364                                             "/a/led2",
2365                                             0,
2366                                             NULL,
2367                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2368     OCResourceHandle handle3;
2369     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
2370                                             "core.led",
2371                                             "core.rw",
2372                                             "/a/led3",
2373                                             0,
2374                                             NULL,
2375                                             OC_DISCOVERABLE|OC_OBSERVABLE));
2376     /* Start a discovery query*/
2377     char szQueryUri[MAX_QUERY_LENGTH] = "/oic/res?if=oic.if.ll";
2378     OCCallbackData cbData;
2379     cbData.cb = discoveryCallback;
2380     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
2381     cbData.cd = NULL;
2382
2383     OCDoHandle handle;
2384     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
2385                                         OC_REST_DISCOVER,
2386                                         szQueryUri,
2387                                         0,
2388                                         0,
2389                                         CT_ADAPTER_IP,
2390                                         OC_LOW_QOS,
2391                                         &cbData,
2392                                         NULL,
2393                                         0));
2394
2395     EXPECT_EQ(OC_STACK_OK, OCStop());
2396 }
2397
2398 TEST(StackPayload, CloneByteString)
2399 {
2400     uint8_t bytes[] = { 0, 1, 2, 3 };
2401     OCByteString byteString;
2402     byteString.bytes = bytes;
2403     byteString.len = sizeof(bytes);
2404
2405     OCRepPayload *original = OCRepPayloadCreate();
2406     ASSERT_TRUE(original != NULL);
2407     EXPECT_TRUE(OCRepPayloadSetPropByteString(original, "name", byteString));
2408
2409     OCRepPayload *clone = OCRepPayloadClone(original);
2410     ASSERT_TRUE(clone != NULL);
2411
2412     OCRepPayloadDestroy(original);
2413
2414     OCByteString cloneByteString;
2415     EXPECT_TRUE(OCRepPayloadGetPropByteString(clone, "name", &cloneByteString));
2416     ASSERT_TRUE(cloneByteString.bytes != NULL);
2417     EXPECT_EQ(sizeof(bytes), cloneByteString.len);
2418     EXPECT_TRUE(0 == memcmp(bytes, cloneByteString.bytes, sizeof(bytes)));
2419     OICFree(cloneByteString.bytes);
2420
2421     OCRepPayloadDestroy(clone);
2422 }
2423
2424 TEST(StackPayload, EmptyByteString)
2425 {
2426     OCByteString value = { NULL, 0 };
2427
2428     OCByteString dest = { NULL, 0 };
2429     EXPECT_TRUE(OCByteStringCopy(&dest, &value));
2430     EXPECT_EQ(0, memcmp(&dest, &value, sizeof(OCByteString)));
2431
2432     OCRepPayload *payload = OCRepPayloadCreate();
2433     ASSERT_TRUE(payload != NULL);
2434
2435     EXPECT_TRUE(OCRepPayloadSetPropByteString(payload, "value", value));
2436     EXPECT_TRUE(OCRepPayloadGetPropByteString(payload, "value", &dest));
2437     EXPECT_EQ(0, memcmp(&dest, &value, sizeof(OCByteString)));
2438
2439     OCByteString array[] = {
2440         { NULL, 0 },
2441         { NULL, 0 }
2442     };
2443     size_t dim[MAX_REP_ARRAY_DEPTH] = { 2, 0, 0 };
2444     EXPECT_TRUE(OCRepPayloadSetByteStringArray(payload, "array", array, dim));
2445     OCByteString *destArray = NULL;
2446     size_t destDim[MAX_REP_ARRAY_DEPTH] = { 0 };
2447     EXPECT_TRUE(OCRepPayloadGetByteStringArray(payload, "array", &destArray, destDim));
2448     EXPECT_EQ(0, memcmp(destDim, dim, sizeof(destDim)));
2449     size_t dimTotal = calcDimTotal(dim);
2450     for (size_t i = 0; i < dimTotal; ++i)
2451     {
2452         EXPECT_EQ(0, memcmp(&destArray[i], &array[i], sizeof(OCByteString)));
2453     }
2454
2455     for(size_t i = 0; i < dimTotal; i++)
2456     {
2457         OICFree(destArray[i].bytes);
2458     }
2459     OICFree(destArray);
2460     OCRepPayloadDestroy(payload);
2461 }
2462
2463 TEST(StackUri, Rfc6874_Noop_1)
2464 {
2465     char validIPv6Address[] = "FF01:0:0:0:0:0:0:FB";
2466     char bytes[100] = {0};
2467     strncpy(bytes, validIPv6Address, sizeof(bytes));
2468
2469     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2470
2471     // No % sign, should do nothing
2472     EXPECT_STREQ(bytes, validIPv6Address);
2473     EXPECT_EQ(OC_STACK_OK, result);
2474 }
2475
2476 TEST(StackUri, Rfc6874_Noop_2)
2477 {
2478     char validIPv6Address[] = "3812:a61::4:1";
2479     char bytes[100] = {0};
2480
2481     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2482
2483     // No % sign, should do nothing
2484     EXPECT_STREQ(bytes, validIPv6Address);
2485     EXPECT_EQ(OC_STACK_OK, result);
2486 }
2487
2488 TEST(StackUri, Rfc6874_WithEncoding)
2489 {
2490     char validIPv6Address[] =        "fe80::dafe:e3ff:fe00:ebfa%wlan0";
2491     char validIPv6AddressEncoded[] = "fe80::dafe:e3ff:fe00:ebfa%25wlan0";
2492     char bytes[100] = "";
2493     strncpy(bytes, validIPv6Address, sizeof(bytes));
2494
2495     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2496
2497     // Encoding should have occured
2498     EXPECT_STREQ(bytes, validIPv6AddressEncoded);
2499     EXPECT_EQ(OC_STACK_OK, result);
2500 }
2501
2502 TEST(StackUri, Rfc6874_WithEncoding_ExtraPercent)
2503 {
2504     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%%wlan0";
2505     char bytes[100] = {0};
2506
2507     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2508
2509     // Encoding should have failed due to extra '%' character
2510     EXPECT_STREQ(bytes, "");
2511     EXPECT_EQ(OC_STACK_ERROR, result);
2512 }
2513
2514 TEST(StackUri, Rfc6874_AlreadyEncoded)
2515 {
2516     char validIPv6AddressEncoded[] = "fe80::dafe:e3ff:fe00:ebfa%25wlan0";
2517     char bytes[100] = {0};
2518
2519     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6AddressEncoded);
2520
2521     // Encoding should have failed due to extra '%' character
2522     EXPECT_STREQ(bytes, "");
2523     EXPECT_EQ(OC_STACK_ERROR, result);
2524 }
2525
2526 TEST(StackUri, Rfc6874_NoOverflow)
2527 {
2528     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0";
2529     char addrBuffer[100];
2530     char bytes[100] = {0};
2531     memset(addrBuffer, sizeof(addrBuffer), '_');
2532
2533     // Just enough room to encode
2534     addrBuffer[sizeof(addrBuffer) - sizeof(validIPv6Address) - 3] = '\0';
2535     strcat(addrBuffer, validIPv6Address);
2536
2537     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), addrBuffer);
2538
2539     // Encoding should have succeeded
2540     EXPECT_EQ(OC_STACK_OK, result);
2541 }
2542
2543 TEST(StackUri, Rfc6874_NoOverflow_2)
2544 {
2545     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0";
2546     char addrBuffer[100];
2547     char bytes[100] = {0};
2548     memset(addrBuffer, sizeof(addrBuffer), '_');
2549
2550     // Not enough room to encode
2551     addrBuffer[sizeof(addrBuffer) - sizeof(validIPv6Address) - 1] = '\0';
2552     strcat(addrBuffer, validIPv6Address);
2553
2554     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), addrBuffer);
2555
2556     // Encoding should have failed due to output size limitations
2557     EXPECT_STREQ(bytes, "");
2558     EXPECT_EQ(OC_STACK_ERROR, result);
2559 }
2560
2561 TEST(StackHeaderOption, setHeaderOption)
2562 {
2563     uint8_t optionValue1[MAX_HEADER_OPTION_DATA_LENGTH] =
2564     { 1 };
2565     OCHeaderOption options[MAX_HEADER_OPTIONS] =
2566     {
2567     { OC_COAP_ID, 6, 8, optionValue1 }, };
2568     uint8_t optionData = 255;
2569     size_t optionDataSize = sizeof(optionData);
2570     size_t numOptions = 1;
2571     uint16_t optionID = 2048;
2572     EXPECT_EQ(OC_STACK_OK, OCSetHeaderOption(options,
2573                                              &numOptions,
2574                                              optionID,
2575                                              &optionData,
2576                                              optionDataSize));
2577     EXPECT_EQ(options[1].optionID, optionID);
2578     EXPECT_EQ(options[1].optionData[0], 255);
2579 }
2580
2581 TEST(StackHeaderOption, getHeaderOption)
2582 {
2583     uint8_t optionValue1[MAX_HEADER_OPTION_DATA_LENGTH] =
2584     { 1 };
2585     uint8_t optionValue2[MAX_HEADER_OPTION_DATA_LENGTH] =
2586     { 255 };
2587     OCHeaderOption options[MAX_HEADER_OPTIONS] =
2588     {
2589     { OC_COAP_ID, 6, 8, optionValue1 },
2590     { OC_COAP_ID, 2048, 16, optionValue2 }, };
2591     uint8_t optionData[MAX_HEADER_OPTION_DATA_LENGTH];
2592     size_t optionDataSize = sizeof(optionData);
2593     size_t numOptions = 2;
2594     uint16_t optionID = 6;
2595     uint16_t actualDataSize = 0;
2596     EXPECT_EQ(OC_STACK_OK, OCGetHeaderOption(options,
2597                                              numOptions,
2598                                              optionID,
2599                                              optionData,
2600                                              optionDataSize,
2601                                              &actualDataSize));
2602     EXPECT_EQ(1, optionData[0]);
2603     EXPECT_EQ(8, actualDataSize);
2604 }
2605
2606 TEST(StackEndpoints, OCGetSupportedEndpointTpsFlags)
2607 {
2608     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2609
2610     OIC_LOG(INFO, TAG, "OCGetSupportedEndpointTpsFlags test");
2611
2612     InitStack(OC_SERVER);
2613
2614     EXPECT_LE(INVALID_TPS_FLAGS_ZERO, OCGetSupportedEndpointTpsFlags());
2615
2616     EXPECT_EQ(OC_STACK_OK, OCStop());
2617 }
2618
2619 static OCStackApplicationResult DiscoverBaselineResource(void *ctx, OCDoHandle handle,
2620     OCClientResponse *response)
2621 {
2622     OC_UNUSED(ctx);
2623     OC_UNUSED(handle);
2624     EXPECT_EQ(OC_STACK_OK, response->result);
2625     EXPECT_TRUE(NULL != response->payload);
2626     if (NULL != response->payload)
2627     {
2628         EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2629
2630         OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload;
2631         EXPECT_TRUE(NULL != payload->sid);
2632         EXPECT_STREQ("StackTest", payload->name);
2633         EXPECT_STREQ(OC_RSRVD_RESOURCE_TYPE_RES, payload->type->value);
2634         EXPECT_STREQ(OC_RSRVD_INTERFACE_LL, payload->iface->value);
2635         EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, payload->iface->next->value);
2636
2637         for (OCResourcePayload *resource = payload->resources; resource; resource = resource->next)
2638         {
2639             if (0 == strcmp("/a/light", resource->uri))
2640             {
2641                 EXPECT_STREQ("/a/light", resource->uri);
2642                 EXPECT_STREQ("core.light", resource->types->value);
2643                 EXPECT_EQ(NULL, resource->types->next);
2644                 EXPECT_STREQ("oic.if.baseline", resource->interfaces->value);
2645                 EXPECT_EQ(NULL, resource->interfaces->next);
2646                 EXPECT_TRUE(resource->bitmap & OC_DISCOVERABLE);
2647                 EXPECT_FALSE(resource->secure);
2648                 EXPECT_EQ(0, resource->port);
2649                 EXPECT_EQ(NULL, resource->next);
2650             }
2651         }
2652     }
2653
2654     return OC_STACK_DELETE_TRANSACTION;
2655 }
2656
2657 static OCStackApplicationResult DiscoverLinkedListResource(void *ctx, OCDoHandle handle,
2658     OCClientResponse *response)
2659 {
2660     OC_UNUSED(ctx);
2661     OC_UNUSED(handle);
2662     EXPECT_EQ(OC_STACK_OK, response->result);
2663     EXPECT_TRUE(NULL != response->payload);
2664     if (NULL != response->payload)
2665     {
2666         EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2667
2668         OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload;
2669         EXPECT_NE((char *)NULL, payload->sid);
2670         EXPECT_EQ(NULL, payload->name);
2671         EXPECT_EQ(NULL, payload->type);
2672         EXPECT_EQ(NULL, payload->iface);
2673
2674         for (OCResourcePayload *resource = payload->resources; resource; resource = resource->next)
2675         {
2676             if (0 == strcmp("/a/light", resource->uri))
2677             {
2678                 EXPECT_STREQ("/a/light", resource->uri);
2679                 EXPECT_STREQ("core.light", resource->types->value);
2680                 EXPECT_EQ(NULL, resource->types->next);
2681                 EXPECT_STREQ("oic.if.baseline", resource->interfaces->value);
2682                 EXPECT_EQ(NULL, resource->interfaces->next);
2683                 EXPECT_TRUE(resource->bitmap & OC_DISCOVERABLE);
2684                 EXPECT_FALSE(resource->secure);
2685                 EXPECT_EQ(0, resource->port);
2686                 EXPECT_EQ(NULL, resource->next);
2687             }
2688         }
2689     }
2690     return OC_STACK_DELETE_TRANSACTION;
2691 }
2692
2693
2694 static OCStackApplicationResult DiscoverResourceTypeResponse(void *ctx, OCDoHandle handle,
2695     OCClientResponse *response)
2696 {
2697     OC_UNUSED(ctx);
2698     OC_UNUSED(handle);
2699     EXPECT_EQ(OC_STACK_OK, response->result);
2700     EXPECT_TRUE(NULL != response->payload);
2701     if (NULL != response->payload)
2702     {
2703         EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2704
2705         OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload;
2706         EXPECT_NE((char *)NULL, payload->sid);
2707         EXPECT_EQ(NULL, payload->name);
2708         EXPECT_EQ(NULL, payload->type);
2709         EXPECT_EQ(NULL, payload->iface);
2710         EXPECT_TRUE(NULL != payload->resources);
2711
2712         OCResourcePayload *resource = payload->resources;
2713
2714         if (0 == strcmp("/a/light", resource->uri))
2715         {
2716             EXPECT_STREQ("/a/light", resource->uri);
2717             EXPECT_STREQ("core.light", resource->types->value);
2718             EXPECT_EQ(NULL, resource->types->next);
2719             EXPECT_STREQ("oic.if.baseline", resource->interfaces->value);
2720             EXPECT_EQ(NULL, resource->interfaces->next);
2721             EXPECT_TRUE(resource->bitmap & OC_DISCOVERABLE);
2722             EXPECT_FALSE(resource->secure);
2723             EXPECT_EQ(0, resource->port);
2724             EXPECT_EQ(NULL, resource->next);
2725         }
2726     }
2727
2728     return OC_STACK_DELETE_TRANSACTION;
2729 }
2730
2731 static OCStackApplicationResult DiscoverUnicastErrorResponse(void *ctx, OCDoHandle handle,
2732     OCClientResponse *response)
2733 {
2734     OC_UNUSED(ctx);
2735     OC_UNUSED(handle);
2736     EXPECT_NE(OC_STACK_OK, response->result);
2737     EXPECT_TRUE(NULL == response->payload);
2738
2739     return OC_STACK_DELETE_TRANSACTION;
2740 }
2741
2742 // Disabled to unblock other developers untill IOT-1807 is done.
2743 TEST_F(OCDiscoverTests, DISABLED_DiscoverResourceWithValidQueries)
2744 {
2745     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2746
2747     OCResourceHandle handles;
2748     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2749         entityHandler, NULL, OC_DISCOVERABLE));
2750     OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, "StackTest");
2751
2752     itst::Callback discoverBaselineCB(&DiscoverBaselineResource);
2753     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=oic.if.baseline", NULL,
2754         0, CT_DEFAULT, OC_HIGH_QOS, discoverBaselineCB, NULL, 0));
2755     EXPECT_EQ(OC_STACK_OK, discoverBaselineCB.Wait(100));
2756
2757     // Disabled temporarily on Windows to unblock other developers. Will be enabled in IOT-1806.
2758 #ifndef _MSC_VER
2759     itst::Callback discoverDefaultCB(&DiscoverLinkedListResource);
2760     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res", NULL, 0, CT_DEFAULT,
2761         OC_HIGH_QOS, discoverDefaultCB, NULL, 0));
2762     EXPECT_EQ(OC_STACK_OK, discoverDefaultCB.Wait(100));
2763 #endif
2764
2765     itst::Callback discoverLinkedListCB(&DiscoverLinkedListResource);
2766     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=oic.if.ll", NULL, 0,
2767         CT_DEFAULT, OC_HIGH_QOS, discoverLinkedListCB, NULL, 0));
2768     EXPECT_EQ(OC_STACK_OK, discoverLinkedListCB.Wait(100));
2769
2770     itst::Callback discoverRTCB(&DiscoverResourceTypeResponse);
2771     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?rt=core.light", NULL, 0,
2772         CT_DEFAULT, OC_HIGH_QOS, discoverRTCB, NULL, 0));
2773     EXPECT_EQ(OC_STACK_OK, discoverRTCB.Wait(100));
2774 }
2775
2776 // Disabled to unblock other developers untill IOT-1807 is done.
2777 TEST_F(OCDiscoverTests, DISABLED_DiscoverResourceWithInvalidQueries)
2778 {
2779     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2780
2781     OCResourceHandle handles;
2782     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handles, "core.light", "oic.if.baseline", "/a/light",
2783         entityHandler, NULL, OC_DISCOVERABLE));
2784     OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "deviceName", "StackTest");
2785
2786     itst::Callback discoverRTInvalidCB(&DiscoverUnicastErrorResponse);
2787     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?rt=invalid", NULL, 0,
2788     CT_DEFAULT, OC_HIGH_QOS, discoverRTInvalidCB, NULL, 0));
2789     EXPECT_EQ(OC_STACK_OK, discoverRTInvalidCB.Wait(10));
2790
2791     itst::Callback discoverRTEmptyCB(&DiscoverUnicastErrorResponse);
2792     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?rt=", NULL, 0, CT_DEFAULT,
2793     OC_HIGH_QOS, discoverRTEmptyCB, NULL, 0));
2794     EXPECT_EQ(OC_STACK_OK, discoverRTEmptyCB.Wait(10));
2795
2796     itst::Callback discoverIfInvalidCB(&DiscoverUnicastErrorResponse);
2797     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=invalid", NULL, 0,
2798         CT_DEFAULT, OC_HIGH_QOS, discoverIfInvalidCB, NULL, 0));
2799     EXPECT_EQ(OC_STACK_OK, discoverIfInvalidCB.Wait(10));
2800
2801     itst::Callback discoverIfEmptyCB(&DiscoverUnicastErrorResponse);
2802     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res?if=", NULL, 0, CT_DEFAULT,
2803     OC_HIGH_QOS, discoverIfEmptyCB, NULL, 0));
2804     EXPECT_EQ(OC_STACK_OK, discoverIfEmptyCB.Wait(10));
2805
2806     // Unicast
2807     char targetUri[MAX_URI_LENGTH * 2] ={ 0, };
2808
2809     itst::Callback discoverUnicastIfInvalidCB(&DiscoverUnicastErrorResponse);
2810     snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?if=invalid");
2811     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0,
2812     CT_DEFAULT, OC_HIGH_QOS, discoverUnicastIfInvalidCB, NULL, 0));
2813     EXPECT_EQ(OC_STACK_OK, discoverUnicastIfInvalidCB.Wait(10));
2814
2815     itst::Callback discoverUnicastIfEmptyCB(&DiscoverUnicastErrorResponse);
2816     snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?if=");
2817     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0, CT_DEFAULT,
2818     OC_HIGH_QOS, discoverUnicastIfEmptyCB, NULL, 0));
2819     EXPECT_EQ(OC_STACK_OK, discoverUnicastIfEmptyCB.Wait(10));
2820
2821     itst::Callback discoverUnicastRTInvalidCB(&DiscoverUnicastErrorResponse);
2822     snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?rt=invalid");
2823     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0,
2824     CT_DEFAULT, OC_HIGH_QOS, discoverUnicastRTInvalidCB, NULL, 0));
2825     EXPECT_EQ(OC_STACK_OK, discoverUnicastRTInvalidCB.Wait(10));
2826
2827     itst::Callback discoverUnicastRTEmptyCB(&DiscoverUnicastErrorResponse);
2828     snprintf(targetUri, MAX_URI_LENGTH * 2, "127.0.0.1/oic/res?rt=");
2829     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, targetUri, NULL, 0, CT_DEFAULT,
2830     OC_HIGH_QOS, discoverUnicastRTEmptyCB, NULL, 0));
2831     EXPECT_EQ(OC_STACK_OK, discoverUnicastRTEmptyCB.Wait(10));
2832 }
2833
2834 class OCEndpointTests : public testing::Test
2835 {
2836     protected:
2837         virtual void SetUp()
2838         {
2839             OCPersistentStorage ps = { fopen, fread, fwrite, fclose, unlink };
2840             EXPECT_EQ(OC_STACK_OK, OCRegisterPersistentStorageHandler(&ps));
2841             EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, OC_CLIENT_SERVER));
2842         }
2843
2844         virtual void TearDown()
2845         {
2846             OCStop();
2847         }
2848 };
2849
2850 static OCStackApplicationResult SecureAndNonsecureEndpoints(void *ctx, OCDoHandle handle,
2851     OCClientResponse *response)
2852 {
2853     OC_UNUSED(ctx);
2854     OC_UNUSED(handle);
2855     EXPECT_EQ(OC_STACK_OK, response->result);
2856     EXPECT_TRUE(NULL != response->payload);
2857     if (NULL != response->payload)
2858     {
2859         EXPECT_EQ(PAYLOAD_TYPE_DISCOVERY, response->payload->type);
2860         OCDiscoveryPayload *payload = (OCDiscoveryPayload *)response->payload;
2861         EXPECT_TRUE(NULL != payload->sid);
2862         for (OCResourcePayload *resource = payload->resources; resource; resource = resource->next)
2863         {
2864             if (!strcmp("/a/default", resource->uri))
2865             {
2866                 for (OCEndpointPayload *ep = resource->eps; ep; ep = ep->next)
2867                 {
2868                     EXPECT_EQ(0, OC_FLAG_SECURE & ep->family);
2869                 }
2870             }
2871             else if (!strcmp("/a/secure", resource->uri))
2872             {
2873                 for (OCEndpointPayload *ep = resource->eps; ep; ep = ep->next)
2874                 {
2875 #ifdef __WITH_DTLS__
2876                     EXPECT_EQ(OC_FLAG_SECURE, OC_FLAG_SECURE & ep->family);
2877 #else
2878                     EXPECT_EQ(0, OC_FLAG_SECURE & ep->family);
2879 #endif
2880                 }
2881             }
2882             else if (!strcmp("/a/nonsecure", resource->uri))
2883             {
2884                 for (OCEndpointPayload *ep = resource->eps; ep; ep = ep->next)
2885                 {
2886                     EXPECT_EQ(0, OC_FLAG_SECURE & ep->family);
2887                 }
2888             }
2889             else if (!strcmp("/a/both", resource->uri))
2890             {
2891                 bool hasSecure = false;
2892                 bool hasNonsecure = false;
2893                 for (OCEndpointPayload *ep = resource->eps; ep; ep = ep->next)
2894                 {
2895                     if (OC_FLAG_SECURE & ep->family)
2896                     {
2897                         hasSecure = true;
2898                     }
2899                     else
2900                     {
2901                         hasNonsecure = true;
2902                     }
2903                 }
2904 #ifdef __WITH_DTLS__
2905                 EXPECT_TRUE(hasSecure);
2906 #else
2907                 EXPECT_FALSE(hasSecure);
2908 #endif
2909                 EXPECT_TRUE(hasNonsecure);
2910             }
2911         }
2912     }
2913     return OC_STACK_DELETE_TRANSACTION;
2914 }
2915
2916 // Disabled until unit tests can run with SECURED=1 builds
2917 TEST_F(OCEndpointTests, DISABLED_SecureAndNonsecureEndpoints)
2918 {
2919     itst::DeadmanTimer killSwitch(LONG_TEST_TIMEOUT);
2920
2921     OCResourceHandle handle;
2922     handle = OCGetResourceHandleAtUri(OC_RSRVD_WELL_KNOWN_URI);
2923     EXPECT_EQ(OC_STACK_OK, OCSetResourceProperties(handle, OC_DISCOVERABLE | OC_OBSERVABLE));
2924     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle, "core.light", "oic.if.baseline", "/a/default",
2925             entityHandler, NULL, OC_DISCOVERABLE));
2926     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle, "core.light", "oic.if.baseline", "/a/secure",
2927             entityHandler, NULL, OC_DISCOVERABLE | OC_SECURE));
2928     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle, "core.light", "oic.if.baseline", "/a/nonsecure",
2929             entityHandler, NULL, OC_DISCOVERABLE | OC_NONSECURE));
2930     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle, "core.light", "oic.if.baseline", "/a/both",
2931             entityHandler, NULL, OC_DISCOVERABLE | OC_SECURE | OC_NONSECURE));
2932
2933     itst::Callback secureAndNonSecureEndpointsCB(&SecureAndNonsecureEndpoints);
2934     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_DISCOVER, "/oic/res", NULL,
2935             0, CT_DEFAULT, OC_HIGH_QOS, secureAndNonSecureEndpointsCB, NULL, 0));
2936     EXPECT_EQ(OC_STACK_OK, secureAndNonSecureEndpointsCB.Wait(100));
2937 }
2938
2939 #ifdef IP_ADAPTER
2940 TEST(StackZoneId, getZoneId)
2941 {
2942     size_t tempSize = 0;
2943     CAEndpoint_t *tempInfo = NULL;
2944     CAGetNetworkInformation(&tempInfo, &tempSize);
2945
2946     for (size_t i = 0; i < tempSize; i++)
2947     {
2948         char *zoneId = NULL;
2949         EXPECT_EQ(OC_STACK_OK, OCGetLinkLocalZoneId(tempInfo[i].ifindex, &zoneId));
2950         OICFree(zoneId);
2951         zoneId = NULL;
2952     }
2953
2954     OICFree(tempInfo);
2955 }
2956
2957 TEST(StackZoneId, getZoneIdWithInvalidParams)
2958 {
2959     char *zoneId = NULL;
2960     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCGetLinkLocalZoneId(0, NULL));
2961     EXPECT_EQ(OC_STACK_ERROR, OCGetLinkLocalZoneId(9999, &zoneId));
2962     EXPECT_EQ(OC_STACK_ERROR, OCGetLinkLocalZoneId(UINT32_MAX, &zoneId));
2963 }
2964 #endif
2965
2966 TEST(LinksPayloadArray, BuildCollectionLinksPayloadArray)
2967 {
2968     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
2969     OIC_LOG(INFO, TAG, "Starting createLinksPayloadValue test");
2970     InitStack(OC_SERVER);
2971
2972     size_t numResources = 0;
2973     uint8_t parentBitmap = (OC_DISCOVERABLE | OC_OBSERVABLE) | OC_SECURE;
2974     uint8_t inBitmap[2] = {( OC_DISCOVERABLE | OC_OBSERVABLE) | OC_SECURE,
2975                             OC_DISCOVERABLE | OC_SECURE };
2976     int64_t outBitmap[2] = { 0 };
2977
2978     OCResourceHandle containerHandle;
2979     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
2980         "core.led",
2981         "core.col",
2982         "/a/kitchen",
2983         0,
2984         NULL,
2985         parentBitmap));
2986
2987     OCResourceHandle handle0;
2988     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
2989         "core.led",
2990         "core.rw",
2991         "/a/led0",
2992         0,
2993         NULL,
2994         inBitmap[0]));
2995     ++numResources;
2996
2997     OCResourceHandle handle1;
2998     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
2999         "core.led",
3000         "core.r",
3001         "/a/led1",
3002         0,
3003         NULL,
3004         inBitmap[1]));
3005     ++numResources;
3006
3007     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
3008     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
3009
3010     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
3011     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
3012
3013     OCRepPayload** linksRepPayloadArray = NULL;
3014     OCRepPayload* collectionPayload = NULL;
3015     OCRepPayload* policyMap = NULL;
3016     OCRepPayload** linksMap = NULL;
3017
3018     OCDevAddr* devAddr = (OCDevAddr*)OICCalloc(1, sizeof(OCDevAddr));
3019     devAddr->adapter = OC_ADAPTER_IP;
3020     CAEndpoint_t *info = NULL;
3021     size_t size = 0;
3022     CAGetNetworkInformation(&info, &size);
3023     devAddr->ifindex = info->ifindex;
3024
3025     //check for OIC1.1 logic
3026     size_t arraySize = 0;
3027     linksRepPayloadArray = BuildCollectionLinksPayloadArray("/a/kitchen", false,
3028                                                             devAddr, &arraySize);
3029     ASSERT_TRUE(NULL != linksRepPayloadArray);
3030
3031     collectionPayload = OCRepPayloadCreate();
3032     ASSERT_TRUE(NULL != collectionPayload);
3033
3034     size_t dim[MAX_REP_ARRAY_DEPTH] = { numResources, 0, 0 };
3035     EXPECT_EQ(numResources, arraySize);
3036
3037     ASSERT_TRUE(OCRepPayloadSetPropObjectArrayAsOwner(collectionPayload, OC_RSRVD_LINKS,
3038                                                       linksRepPayloadArray, dim));
3039
3040     ASSERT_TRUE(OCRepPayloadGetPropObjectArray(collectionPayload, OC_RSRVD_LINKS, &linksMap, dim));
3041
3042     for (size_t i = 0; i < numResources; i++)
3043     {
3044         ASSERT_TRUE(OCRepPayloadGetPropObject(linksMap[i], OC_RSRVD_POLICY, &policyMap));
3045         ASSERT_TRUE(OCRepPayloadGetPropInt(policyMap, OC_RSRVD_BITMAP, &outBitmap[i]));
3046         // check bitmap excluding secure bit
3047         EXPECT_EQ(inBitmap[i] & ~OC_MASK_RESOURCE_SECURE, outBitmap[i]);
3048
3049         if (devAddr)
3050         {
3051 #ifdef TCP_ADAPTER
3052 #ifdef __WITH_TLS__
3053             bool isSecure = false;
3054             ASSERT_TRUE(OCRepPayloadGetPropBool(policyMap, OC_RSRVD_SECURE, &isSecure));
3055             if (isSecure)
3056             {
3057                 // tls
3058                 int64_t outTlsPort = 0;
3059                 ASSERT_TRUE(OCRepPayloadGetPropInt(policyMap, OC_RSRVD_TLS_PORT, &outTlsPort));
3060
3061                 uint16_t tlsPort = 0;
3062                 GetTCPPortInfo(devAddr, &tlsPort, true);
3063                 EXPECT_EQ(tlsPort, outTlsPort);
3064             }
3065             else
3066             {
3067                 // tcp
3068                 int64_t outTcpPort = 0;
3069                 ASSERT_TRUE(OCRepPayloadGetPropInt(policyMap, OC_RSRVD_TCP_PORT, &outTcpPort));
3070
3071                 uint16_t tcpPort = 0;
3072                 GetTCPPortInfo(devAddr, &tcpPort, false);
3073
3074                 EXPECT_EQ(tcpPort, outTcpPort);
3075             }
3076 #else
3077             // tcp
3078             int64_t outTcpPort = 0;
3079             ASSERT_TRUE(OCRepPayloadGetPropInt(policyMap, OC_RSRVD_TCP_PORT, &outTcpPort));
3080
3081             uint16_t tcpPort = 0;
3082             GetTCPPortInfo(devAddr, &tcpPort, false);
3083
3084             EXPECT_EQ(tcpPort, outTcpPort);
3085 #endif
3086 #endif
3087         }
3088         OCRepPayloadDestroy(linksMap[i]);
3089     }
3090
3091     OICFree(linksMap);
3092     OCRepPayloadDestroy(policyMap);
3093     OCRepPayloadDestroy(collectionPayload);
3094
3095     //check for OCF1.0 logic
3096     linksRepPayloadArray = BuildCollectionLinksPayloadArray("/a/kitchen", true, devAddr, &arraySize);
3097     ASSERT_TRUE(NULL != linksRepPayloadArray);
3098
3099     collectionPayload = OCRepPayloadCreate();
3100     ASSERT_TRUE(NULL != collectionPayload);
3101
3102     EXPECT_EQ(numResources, arraySize);
3103
3104     ASSERT_TRUE(OCRepPayloadSetPropObjectArrayAsOwner(collectionPayload, OC_RSRVD_LINKS,
3105                                                       linksRepPayloadArray, dim));
3106
3107     ASSERT_TRUE(OCRepPayloadGetPropObjectArray(collectionPayload, OC_RSRVD_LINKS, &linksMap, dim));
3108
3109     for (size_t i = 0; i < numResources; i++)
3110     {
3111         ASSERT_TRUE(OCRepPayloadGetPropObject(linksMap[i], OC_RSRVD_POLICY, &policyMap));
3112         ASSERT_TRUE(OCRepPayloadGetPropInt(policyMap, OC_RSRVD_BITMAP, &outBitmap[i]));
3113         // check bitmap excluding secure bit
3114         EXPECT_EQ(inBitmap[i] & ~OC_MASK_RESOURCE_SECURE, outBitmap[i]);
3115
3116         size_t epsDim[MAX_REP_ARRAY_DEPTH] = { 0 };
3117         OCRepPayload **epsMap = NULL;
3118         ASSERT_TRUE(OCRepPayloadGetPropObjectArray(linksMap[i], OC_RSRVD_ENDPOINTS, &epsMap, epsDim));
3119
3120         size_t count = calcDimTotal(epsDim);
3121         size_t coap_scheme_cnt[4] = { 0, 0, 0, 0 };
3122         const char* coap_scheme[4] = { "coap", "coaps://", "coap+tcp://", "coaps+tcp://" };
3123         char* outUri;
3124         for (size_t k = 0; k < count; k++)
3125         {
3126             ASSERT_TRUE(OCRepPayloadGetPropString(epsMap[k], OC_RSRVD_ENDPOINT, &outUri));
3127
3128             if (!strncmp(outUri, coap_scheme[3], strlen(coap_scheme[3])))
3129                 coap_scheme_cnt[3]++;
3130             else if (!strncmp(outUri, coap_scheme[2], strlen(coap_scheme[2])))
3131                 coap_scheme_cnt[2]++;
3132             else if (!strncmp(outUri, coap_scheme[1], strlen(coap_scheme[1])))
3133                 coap_scheme_cnt[1]++;
3134             else if (!strncmp(outUri, coap_scheme[0], strlen(coap_scheme[0])))
3135                 coap_scheme_cnt[0]++;
3136             else
3137             {
3138                 ASSERT_TRUE(false);
3139                 OIC_LOG_V(ERROR, TAG, "ep uri = %s \n", outUri);
3140             }
3141
3142             OCRepPayloadDestroy(epsMap[k]);
3143         }
3144
3145 #ifdef __WITH_DTLS__
3146         ASSERT_GE(coap_scheme_cnt[1], (size_t) 1);
3147 #ifdef TCP_ADAPTER
3148         ASSERT_GE(coap_scheme_cnt[3], (size_t) 1);
3149 #endif
3150 #else
3151         ASSERT_GE(coap_scheme_cnt[0], (size_t) 1);
3152 #ifdef TCP_ADAPTER
3153         ASSERT_GE(coap_scheme_cnt[2], (size_t) 1);
3154 #endif
3155 #endif
3156
3157         OCRepPayloadDestroy(linksMap[i]);
3158         OICFree(epsMap);
3159     }
3160
3161     OICFree(linksMap);
3162     OCRepPayloadDestroy(policyMap);
3163     OCRepPayloadDestroy(collectionPayload);
3164
3165     EXPECT_EQ(OC_STACK_OK, OCStop());
3166 }
3167
3168 TEST(DiagnosticPayload, CreateDestroy)
3169 {
3170     OCDiagnosticPayload *payload;
3171
3172     payload = NULL;
3173     OCDiagnosticPayloadDestroy(payload);
3174
3175     payload = OCDiagnosticPayloadCreate(NULL);
3176     ASSERT_TRUE(payload == NULL);
3177
3178     payload = OCDiagnosticPayloadCreate("message");
3179     ASSERT_TRUE(payload != NULL);
3180     ASSERT_STREQ("message", payload->message);
3181     OCDiagnosticPayloadDestroy(payload);
3182 }
3183
3184 static OCEntityHandlerResult DiagnosticPayloadRequest(OCEntityHandlerFlag flag,
3185         OCEntityHandlerRequest *request, void *ctx)
3186 {
3187     OC_UNUSED(flag);
3188     OC_UNUSED(ctx);
3189     OCEntityHandlerResponse response;
3190     memset(&response, 0, sizeof(response));
3191     response.requestHandle = request->requestHandle;
3192     response.resourceHandle = request->resource;
3193     response.ehResult = OC_EH_BAD_REQ;
3194     response.payload = (OCPayload*) OCDiagnosticPayloadCreate("message");
3195     EXPECT_TRUE(response.payload != NULL);
3196     EXPECT_EQ(OC_STACK_OK, OCDoResponse(&response));
3197     return OC_EH_OK;
3198 }
3199
3200 static OCStackApplicationResult DiagnosticPayloadResponse(void *ctx, OCDoHandle handle,
3201         OCClientResponse *response)
3202 {
3203     OC_UNUSED(ctx);
3204     OC_UNUSED(handle);
3205     EXPECT_EQ(OC_STACK_INVALID_QUERY, response->result);
3206     EXPECT_EQ(PAYLOAD_TYPE_DIAGNOSTIC, response->payload->type);
3207     OCDiagnosticPayload *payload = (OCDiagnosticPayload*) response->payload;
3208     EXPECT_STREQ("message", payload->message);
3209     return OC_STACK_DELETE_TRANSACTION;
3210 }
3211
3212 TEST(DiagnosticPayload, DISABLED_EndToEnd)
3213 {
3214     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
3215     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
3216
3217     OCResourceHandle handle;
3218     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle, "core.light", "oic.if.baseline", "/a/light",
3219             DiagnosticPayloadRequest, NULL, OC_DISCOVERABLE));
3220
3221     itst::Callback diagnosticPayloadCB(&DiagnosticPayloadResponse);
3222     EXPECT_EQ(OC_STACK_OK, OCDoResource(NULL, OC_REST_GET, "127.0.0.1:5683/a/light", NULL,
3223             0, CT_DEFAULT, OC_HIGH_QOS, diagnosticPayloadCB, NULL, 0));
3224     EXPECT_EQ(OC_STACK_OK, diagnosticPayloadCB.Wait(100));
3225
3226     OCStop();
3227 }
3228
3229 // Mostly copy-paste from ca_api_unittest.cpp
3230 TEST(OCIpv6ScopeLevel, getMulticastScope)
3231 {
3232     const char interfaceLocalStart[] = "ff01::";
3233     const char linkLocalStart[]      = "ff02::";
3234     const char realmLocalStart[]     = "ff03::";
3235     const char adminLocalStart[]     = "ff04::";
3236     const char siteLocalStart[]      = "ff05::";
3237     const char orgLocalStart[]       = "ff08::";
3238     const char globalStart[]         = "ff0e::";
3239
3240     const char interfaceLocalMid[] = "ff81:0000:0000:f000:0000:0000:0000:0000";
3241     const char linkLocalMid[]      = "ff82:0000:0000:f000:0000:0000:0000:0000";
3242     const char realmLocalMid[]     = "ff83:0000:0000:f000:0000:0000:0000:0000";
3243     const char adminLocalMid[]     = "ff84:0000:0000:f000:0000:0000:0000:0000";
3244     const char siteLocalMid[]      = "ff85:0000:0000:f000:0000:0000:0000:0000";
3245     const char orgLocalMid[]       = "ff88:0000:0000:f000:0000:0000:0000:0000";
3246     const char globalMid[]         = "ff8e:0000:0000:f000:0000:0000:0000:0000";
3247
3248     const char interfaceLocalEnd[] = "fff1:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
3249     const char linkLocalEnd[]      = "fff2:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
3250     const char realmLocalEnd[]     = "fff3:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
3251     const char adminLocalEnd[]     = "fff4:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
3252     const char siteLocalEnd[]      = "fff5:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
3253     const char orgLocalEnd[]       = "fff8:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
3254     const char globalEnd[]         = "fffe:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
3255
3256     // range start
3257     OCTransportFlags scopeLevel = OC_DEFAULT_FLAGS;
3258     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(interfaceLocalStart, &scopeLevel));
3259     EXPECT_EQ(OC_SCOPE_INTERFACE, scopeLevel);
3260     scopeLevel = OC_DEFAULT_FLAGS;
3261
3262     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(linkLocalStart, &scopeLevel));
3263     EXPECT_EQ(OC_SCOPE_LINK, scopeLevel);
3264     scopeLevel = OC_DEFAULT_FLAGS;
3265
3266     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(realmLocalStart, &scopeLevel));
3267     EXPECT_EQ(OC_SCOPE_REALM, scopeLevel);
3268     scopeLevel = OC_DEFAULT_FLAGS;
3269
3270     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(adminLocalStart, &scopeLevel));
3271     EXPECT_EQ(OC_SCOPE_ADMIN, scopeLevel);
3272     scopeLevel = OC_DEFAULT_FLAGS;
3273
3274     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(siteLocalStart, &scopeLevel));
3275     EXPECT_EQ(OC_SCOPE_SITE, scopeLevel);
3276     scopeLevel = OC_DEFAULT_FLAGS;
3277
3278     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(orgLocalStart, &scopeLevel));
3279     EXPECT_EQ(OC_SCOPE_ORG, scopeLevel);
3280     scopeLevel = OC_DEFAULT_FLAGS;
3281
3282     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(globalStart, &scopeLevel));
3283     EXPECT_EQ(OC_SCOPE_GLOBAL, scopeLevel);
3284     scopeLevel = OC_DEFAULT_FLAGS;
3285
3286     // range mid
3287     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(interfaceLocalMid, &scopeLevel));
3288     EXPECT_EQ(OC_SCOPE_INTERFACE, scopeLevel);
3289     scopeLevel = OC_DEFAULT_FLAGS;
3290
3291     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(linkLocalMid, &scopeLevel));
3292     EXPECT_EQ(OC_SCOPE_LINK, scopeLevel);
3293     scopeLevel = OC_DEFAULT_FLAGS;
3294
3295     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(realmLocalMid, &scopeLevel));
3296     EXPECT_EQ(OC_SCOPE_REALM, scopeLevel);
3297     scopeLevel = OC_DEFAULT_FLAGS;
3298
3299     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(adminLocalMid, &scopeLevel));
3300     EXPECT_EQ(OC_SCOPE_ADMIN, scopeLevel);
3301     scopeLevel = OC_DEFAULT_FLAGS;
3302
3303     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(siteLocalMid, &scopeLevel));
3304     EXPECT_EQ(OC_SCOPE_SITE, scopeLevel);
3305     scopeLevel = OC_DEFAULT_FLAGS;
3306
3307     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(orgLocalMid, &scopeLevel));
3308     EXPECT_EQ(OC_SCOPE_ORG, scopeLevel);
3309     scopeLevel = OC_DEFAULT_FLAGS;
3310
3311     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(globalMid, &scopeLevel));
3312     EXPECT_EQ(OC_SCOPE_GLOBAL, scopeLevel);
3313     scopeLevel = OC_DEFAULT_FLAGS;
3314
3315     // range end
3316     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(interfaceLocalEnd, &scopeLevel));
3317     EXPECT_EQ(OC_SCOPE_INTERFACE, scopeLevel);
3318     scopeLevel = OC_DEFAULT_FLAGS;
3319
3320     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(linkLocalEnd, &scopeLevel));
3321     EXPECT_EQ(OC_SCOPE_LINK, scopeLevel);
3322     scopeLevel = OC_DEFAULT_FLAGS;
3323
3324     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(realmLocalEnd, &scopeLevel));
3325     EXPECT_EQ(OC_SCOPE_REALM, scopeLevel);
3326     scopeLevel = OC_DEFAULT_FLAGS;
3327
3328     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(adminLocalEnd, &scopeLevel));
3329     EXPECT_EQ(OC_SCOPE_ADMIN, scopeLevel);
3330     scopeLevel = OC_DEFAULT_FLAGS;
3331
3332     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(siteLocalEnd, &scopeLevel));
3333     EXPECT_EQ(OC_SCOPE_SITE, scopeLevel);
3334     scopeLevel = OC_DEFAULT_FLAGS;
3335
3336     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(orgLocalEnd, &scopeLevel));
3337     EXPECT_EQ(OC_SCOPE_ORG, scopeLevel);
3338     scopeLevel = OC_DEFAULT_FLAGS;
3339
3340     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(globalEnd, &scopeLevel));
3341     EXPECT_EQ(OC_SCOPE_GLOBAL, scopeLevel);
3342     scopeLevel = OC_DEFAULT_FLAGS;
3343 }
3344
3345 // Mostly copy-paste from ca_api_unittest.cpp
3346 TEST(OCIpv6ScopeLevel, getUnicastScope)
3347 {
3348     const char linkLocalLoopBack[]  = "::1";
3349
3350     const char linkLocalStart[]     = "fe80::";
3351     const char linkLocalMid[]       = "fe80:0000:0000:0000:0f00:0000:0000:0000";
3352     const char linkLocalEnd[]       = "febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
3353
3354     const char siteLocalStart[]     = "fec0::";
3355     const char siteLocalMid[]       = "fec0:0000:0000:0000:0f00:0000:0000:0000";
3356     const char siteLocalEnd[]       = "feff:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
3357
3358     const char globalStart[]   = "2000:0000:0000:0000:0000:0000:0000:0000";
3359     const char globalMid[]     = "2000:0000:0000:0f00:0000:0000:0000:0000";
3360     const char globalEnd[]     = "3fff:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
3361
3362     // loopback
3363     OCTransportFlags scopeLevel = OC_DEFAULT_FLAGS;
3364     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(linkLocalLoopBack, &scopeLevel));
3365     EXPECT_EQ(OC_SCOPE_LINK, scopeLevel);
3366     scopeLevel = OC_DEFAULT_FLAGS;
3367
3368     // linklocal
3369     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(linkLocalStart, &scopeLevel));
3370     EXPECT_EQ(OC_SCOPE_LINK, scopeLevel);
3371     scopeLevel = OC_DEFAULT_FLAGS;
3372
3373     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(linkLocalMid, &scopeLevel));
3374     EXPECT_EQ(OC_SCOPE_LINK, scopeLevel);
3375     scopeLevel = OC_DEFAULT_FLAGS;
3376
3377     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(linkLocalEnd, &scopeLevel));
3378     EXPECT_EQ(OC_SCOPE_LINK, scopeLevel);
3379     scopeLevel = OC_DEFAULT_FLAGS;
3380
3381     // sitelocal
3382     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(siteLocalStart, &scopeLevel));
3383     EXPECT_EQ(OC_SCOPE_SITE, scopeLevel);
3384     scopeLevel = OC_DEFAULT_FLAGS;
3385
3386     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(siteLocalMid, &scopeLevel));
3387     EXPECT_EQ(OC_SCOPE_SITE, scopeLevel);
3388     scopeLevel = OC_DEFAULT_FLAGS;
3389
3390     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(siteLocalEnd, &scopeLevel));
3391     EXPECT_EQ(OC_SCOPE_SITE, scopeLevel);
3392     scopeLevel = OC_DEFAULT_FLAGS;
3393
3394     // global
3395     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(globalStart, &scopeLevel));
3396     EXPECT_EQ(OC_SCOPE_GLOBAL, scopeLevel);
3397     scopeLevel = OC_DEFAULT_FLAGS;
3398
3399     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(globalMid, &scopeLevel));
3400     EXPECT_EQ(OC_SCOPE_GLOBAL, scopeLevel);
3401     scopeLevel = OC_DEFAULT_FLAGS;
3402
3403     EXPECT_EQ(OC_STACK_OK, OCGetIpv6AddrScope(globalEnd, &scopeLevel));
3404     EXPECT_EQ(OC_SCOPE_GLOBAL, scopeLevel);
3405     scopeLevel = OC_DEFAULT_FLAGS;
3406 }
3407
3408 // Mostly copy-paste from ca_api_unittest.cpp
3409 TEST(OCIpv6ScopeLevel, invalidAddressTest)
3410 {
3411     const char invalidAddr1[]    = "qqqq";
3412     const char invalidAddr2[]    = "ffx7:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff";
3413     const char invalidAddr3[]    = "ffx7::::::::::dsds";
3414     const char invalidAddr4[]    = "ffx7:ffff:ffff:ff@f:ffff:ffff:ffff:ffff";
3415
3416     OCTransportFlags scopeLevel = OC_DEFAULT_FLAGS;
3417     EXPECT_EQ(OC_STACK_ERROR, OCGetIpv6AddrScope(invalidAddr1, &scopeLevel));
3418     EXPECT_EQ(OC_STACK_ERROR, OCGetIpv6AddrScope(invalidAddr2, &scopeLevel));
3419     EXPECT_EQ(OC_STACK_ERROR, OCGetIpv6AddrScope(invalidAddr3, &scopeLevel));
3420     EXPECT_EQ(OC_STACK_ERROR, OCGetIpv6AddrScope(invalidAddr4, &scopeLevel));
3421 }
3422
3423 #if defined (WITH_POSIX) && (defined (__WITH_DTLS__) || defined(__WITH_TLS__))
3424 TEST(SelectCipherSuite,SelectPositiveAdapter)
3425 {
3426
3427     CAinitSslAdapter();
3428
3429     uint16_t cipher = 0xC0AE;
3430     EXPECT_EQ(OC_STACK_OK,OCSelectCipherSuite(cipher, OC_ADAPTER_IP));
3431     EXPECT_EQ(OC_STACK_OK,OCSelectCipherSuite(cipher, OC_ADAPTER_GATT_BTLE));
3432     EXPECT_EQ(OC_STACK_OK,OCSelectCipherSuite(cipher, OC_ADAPTER_RFCOMM_BTEDR));
3433     EXPECT_EQ(OC_STACK_OK,OCSelectCipherSuite(cipher, OC_ADAPTER_TCP));
3434     EXPECT_EQ(OC_STACK_OK,OCSelectCipherSuite(cipher, OC_ADAPTER_NFC));
3435
3436     #ifdef RA_ADAPTER
3437         EXPECT_EQ(OC_STACK_OK,OCSelectCipherSuite(cipher, OC_ADAPTER_REMOTE_ACCESS));
3438     #endif
3439
3440 }
3441 #endif