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 }
  31
  32 #include "gtest/gtest.h"
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35 #include <errno.h>
  36 #include <fcntl.h>
  37 #ifdef HAVE_UNISTD_H
  38 #include <unistd.h>
  39 #endif
  40 #include <stdlib.h>
  41
  42 //-----------------------------------------------------------------------------
  43 // Includes
  44 //-----------------------------------------------------------------------------
  45 #include <stdio.h>
  46 #include <string.h>
  47
  48 #include <iostream>
  49 #include <stdint.h>
  50
  51 #include "gtest_helper.h"
  52
  53 using namespace std;
  54
  55 namespace itst = iotivity::test;
  56
  57 #define DEFAULT_CONTEXT_VALUE 0x99
  58
  59 //-----------------------------------------------------------------------------
  60 // Private variables
  61 //-----------------------------------------------------------------------------
  62 static const char TAG[] = "TestHarness";
  63
  64 char gDeviceUUID[] = "myDeviceUUID";
  65 char gManufacturerName[] = "myName";
  66 static OCPrm_t pmSel;
  67 static char pinNumber;
  68 static OCDPDev_t peer;
  69
  70 std::chrono::seconds const SHORT_TEST_TIMEOUT = std::chrono::seconds(5);
  71
  72 //-----------------------------------------------------------------------------
  73 // Callback functions
  74 //-----------------------------------------------------------------------------
  75 extern "C"  OCStackApplicationResult asyncDoResourcesCallback(void* ctx,
  76         OCDoHandle /*handle*/, OCClientResponse * clientResponse)
  77 {
  78     OIC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
  79
  80     EXPECT_EQ(OC_STACK_OK, clientResponse->result);
  81
  82     if(ctx == (void*)DEFAULT_CONTEXT_VALUE) {
  83         OIC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
  84     }
  85     OIC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
  86
  87     return OC_STACK_KEEP_TRANSACTION;
  88 }
  89
  90 static void resultCallback(void *UNUSED1, OCDPDev_t *UNUSED2, OCStackResult UNUSED3)
  91 {
  92     (void) (UNUSED1);
  93     (void) (UNUSED2);
  94     (void) (UNUSED3);
  95 }
  96
  97 extern "C" OCStackApplicationResult discoveryCallback(void* ctx,
  98         OCDoHandle /*handle*/, OCClientResponse * clientResponse)
  99 {
 100     OIC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
 101
 102     EXPECT_EQ(OC_STACK_OK, clientResponse->result);
 103
 104     if(ctx == (void*)DEFAULT_CONTEXT_VALUE)
 105     {
 106         OIC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
 107     }
 108
 109     OIC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
 110
 111     OCDiscoveryPayload *discoveryPayload = ((OCDiscoveryPayload *) clientResponse->payload);
 112     EXPECT_TRUE(discoveryPayload != NULL);
 113     OCResourcePayload *res = discoveryPayload->resources;
 114     int count = 0;
 115     for (OCResourcePayload *res1 = discoveryPayload->resources; res1; res1 = res1->next)
 116     {
 117         count++;
 118     }
 119     EXPECT_EQ(3, count);
 120     EXPECT_EQ("/a/led1", res->uri);
 121     res = res->next;
 122     EXPECT_EQ("/a/led2", res->uri);
 123     res = res->next;
 124     EXPECT_EQ("/a/led3", res->uri);
 125     res = res->next;
 126     EXPECT_TRUE(res == NULL);
 127
 128     return OC_STACK_KEEP_TRANSACTION;
 129 }
 130
 131 //-----------------------------------------------------------------------------
 132 // Entity handler
 133 //-----------------------------------------------------------------------------
 134 OCEntityHandlerResult entityHandler(OCEntityHandlerFlag /*flag*/,
 135         OCEntityHandlerRequest * /*entityHandlerRequest*/,
 136         void* /*callbackParam*/)
 137 {
 138     OIC_LOG(INFO, TAG, "Entering entityHandler");
 139
 140     return OC_EH_OK;
 141 }
 142
 143 //-----------------------------------------------------------------------------
 144 //  Local functions
 145 //-----------------------------------------------------------------------------
 146 void InitStack(OCMode mode)
 147 {
 148     OIC_LOG(INFO, TAG, "Entering InitStack");
 149
 150     EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, mode));
 151     OIC_LOG(INFO, TAG, "Leaving InitStack");
 152 }
 153
 154 uint8_t InitNumExpectedResources()
 155 {
 156 #ifdef WITH_PRESENCE
 157     // When presence is enabled, it is a resource and so is (currently) included
 158     // in the returned resource count returned by the OCGetNumberOfResources API.
 159     return 1;
 160 #else
 161     return 0;
 162 #endif
 163 }
 164
 165 uint8_t InitResourceIndex()
 166 {
 167 #ifdef WITH_PRESENCE
 168     // When presence is enabled, it is a resource and so is (currently) included
 169     // in the returned resource count returned by the OCGetNumberOfResources API.
 170     // The index of the presence resource is 0, so the first user app resource index
 171     // is 1.
 172     return 1;
 173 #else
 174     return 0;
 175 #endif
 176 }
 177 //-----------------------------------------------------------------------------
 178 //  Tests
 179 //-----------------------------------------------------------------------------
 180
 181 TEST(StackInit, StackInitNullAddr)
 182 {
 183     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 184     EXPECT_EQ(OC_STACK_OK, OCInit(0, 5683, OC_SERVER));
 185     EXPECT_EQ(OC_STACK_OK, OCStop());
 186 }
 187
 188 TEST(StackInit, StackInitNullPort)
 189 {
 190     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 191     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 0, OC_SERVER));
 192     EXPECT_EQ(OC_STACK_OK, OCStop());
 193 }
 194
 195 TEST(StackInit, StackInitNullAddrAndPort)
 196 {
 197     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 198     EXPECT_EQ(OC_STACK_OK, OCInit(0, 0, OC_SERVER));
 199     EXPECT_EQ(OC_STACK_OK, OCStop());
 200 }
 201
 202 TEST(StackInit, StackInitInvalidMode)
 203 {
 204     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 205     EXPECT_EQ(OC_STACK_ERROR, OCInit(0, 0, (OCMode)10));
 206     EXPECT_EQ(OC_STACK_ERROR, OCStop());
 207 }
 208
 209 TEST(StackStart, StackStartSuccessClient)
 210 {
 211     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 212     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 213     EXPECT_EQ(OC_STACK_OK, OCStop());
 214 }
 215
 216 TEST(StackStart, StackStartSuccessServer)
 217 {
 218     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 219     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 220     EXPECT_EQ(OC_STACK_OK, OCStop());
 221 }
 222
 223 TEST(StackStart, StackStartSuccessClientServer)
 224 {
 225     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 226     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT_SERVER));
 227     EXPECT_EQ(OC_STACK_OK, OCStop());
 228 }
 229
 230 TEST(StackStart, StackStartSuccessServerThenClient)
 231 {
 232     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 233     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 234     EXPECT_EQ(OC_STACK_OK, OCStop());
 235     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 236     EXPECT_EQ(OC_STACK_OK, OCStop());
 237 }
 238
 239 TEST(StackStart, StackStartSuccessClientThenServer)
 240 {
 241     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 242     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 243     EXPECT_EQ(OC_STACK_OK, OCStop());
 244     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 245     EXPECT_EQ(OC_STACK_OK, OCStop());
 246 }
 247
 248 TEST(StackStart, StackStartSuccessiveInits)
 249 {
 250     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 251     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 252     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.2", 5683, OC_SERVER));
 253     EXPECT_EQ(OC_STACK_OK, OCStop());
 254 }
 255
 256 TEST(StackStart, SetPlatformInfoValid)
 257 {
 258     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 259     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 260
 261     OCPlatformInfo info =
 262     {
 263         gDeviceUUID,
 264         gManufacturerName,
 265         0, 0, 0, 0, 0, 0, 0, 0, 0
 266     };
 267     EXPECT_EQ(OC_STACK_OK, OCSetPlatformInfo(info));
 268     EXPECT_EQ(OC_STACK_OK, OCStop());
 269 }
 270
 271 TEST(StackStart, SetPlatformInfoWithClientMode)
 272 {
 273     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 274     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 275
 276     OCPlatformInfo info =
 277     {
 278         gDeviceUUID,
 279         gManufacturerName,
 280         0, 0, 0, 0, 0, 0, 0, 0, 0
 281     };
 282     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 283     EXPECT_EQ(OC_STACK_OK, OCStop());
 284 }
 285
 286 TEST(StackStart, SetPlatformInfoWithNoPlatformID)
 287 {
 288     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 289     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 290
 291     OCPlatformInfo info =
 292      {
 293          0,
 294          gDeviceUUID,
 295          0, 0, 0, 0, 0, 0, 0, 0, 0
 296      };
 297
 298     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 299     EXPECT_EQ(OC_STACK_OK, OCStop());
 300 }
 301
 302 TEST(StackStart, SetPlatformInfoWithNoManufacturerName)
 303 {
 304     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 305     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 306
 307     OCPlatformInfo info =
 308     {
 309         gDeviceUUID,
 310         0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 311     };
 312
 313     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 314     EXPECT_EQ(OC_STACK_OK, OCStop());
 315 }
 316
 317 TEST(StackStart, SetPlatformInfoWithZeroLengthManufacturerName)
 318 {
 319     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 320     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 321
 322     OCPlatformInfo info =
 323     {
 324         gDeviceUUID,
 325         0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 326     };
 327     info.manufacturerName = (char *) "";
 328
 329     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 330     EXPECT_EQ(OC_STACK_OK, OCStop());
 331 }
 332
 333 TEST(StackStart, SetPlatformInfoWithTooLongManufacName)
 334 {
 335     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 336     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 337     char gTooLongManufacturerName[MAX_PLATFORM_NAME_LENGTH+2];
 338     for (int i = 0; i <= MAX_PLATFORM_NAME_LENGTH; i++ )
 339     {
 340         gTooLongManufacturerName[i] = 'a';
 341     }
 342     gTooLongManufacturerName[MAX_PLATFORM_NAME_LENGTH+1] = '\0';
 343     OCPlatformInfo info =
 344     {
 345         gDeviceUUID,
 346         gTooLongManufacturerName,
 347         0, 0, 0, 0, 0, 0, 0, 0, 0
 348     };
 349
 350     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 351     EXPECT_EQ(OC_STACK_OK, OCStop());
 352 }
 353
 354 TEST(StackStart, SetPlatformInfoWithTooLongManufacURL)
 355 {
 356     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 357     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 358     char gManufacturerUrl[MAX_PLATFORM_URL_LENGTH+2];
 359     for (int i = 0; i <= MAX_PLATFORM_URL_LENGTH; i++ )
 360     {
 361         gManufacturerUrl[i] = 'a';
 362     }
 363     gManufacturerUrl[MAX_PLATFORM_URL_LENGTH+1] = '\0';
 364     OCPlatformInfo info =
 365     {
 366         gDeviceUUID,
 367         gManufacturerName,
 368         gManufacturerUrl,
 369         0, 0, 0, 0, 0, 0, 0, 0
 370     };
 371
 372     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
 373     EXPECT_EQ(OC_STACK_OK, OCStop());
 374 }
 375
 376 TEST(StackStart, SetPlatformInfoWithOCSetPropertyValueAPI)
 377 {
 378     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 379     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 380     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, gDeviceUUID));
 381     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, gManufacturerName));
 382     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, "http://www.iotivity.org"));
 383     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, "S777"));
 384     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, "15 Nov, 2016"));
 385     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, "1.1"));
 386     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, "14"));
 387     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, "0.1"));
 388     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, "0.1"));
 389     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, "http://www.iotivity.org"));
 390     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, ""));
 391     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", "value"));
 392     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, NULL, ""));
 393     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL));
 394     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL));
 395     EXPECT_EQ(OC_STACK_OK, OCStop());
 396 }
 397
 398 TEST(StackStart, GetPlatformInfoWithOCGetPropertyValueAPI)
 399 {
 400     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 401     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 402     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, gDeviceUUID));
 403     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, gManufacturerName));
 404     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, "http://www.iotivity.org"));
 405     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, "S777"));
 406     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, "15 Nov, 2016"));
 407     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, "1.1"));
 408     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, "14"));
 409     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, "0.1"));
 410     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, "0.1"));
 411     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, "http://www.iotivity.org"));
 412     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, ""));
 413     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", "value"));
 414
 415     void *value = NULL;
 416     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_ID, &value));
 417     ASSERT_TRUE(value != NULL);
 418     EXPECT_STREQ(gDeviceUUID, (char *)value);
 419     OICFree(value);
 420     value = NULL;
 421
 422     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_NAME, &value));
 423     ASSERT_TRUE(value != NULL);
 424     EXPECT_STREQ(gManufacturerName, (char *)value);
 425     OICFree(value);
 426     value = NULL;
 427
 428     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_URL, &value));
 429     ASSERT_TRUE(value != NULL);
 430     EXPECT_STREQ("http://www.iotivity.org", (char *)value);
 431     OICFree(value);
 432     value = NULL;
 433
 434     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MODEL_NUM, &value));
 435     ASSERT_TRUE(value != NULL);
 436     EXPECT_STREQ("S777", (char *)value);
 437     OICFree(value);
 438     value = NULL;
 439
 440     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_MFG_DATE, &value));
 441     ASSERT_TRUE(value != NULL);
 442     EXPECT_STREQ("15 Nov, 2016", (char *)value);
 443     OICFree(value);
 444     value = NULL;
 445
 446     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_OS_VERSION, &value));
 447     ASSERT_TRUE(value != NULL);
 448     EXPECT_STREQ("1.1", (char *)value);
 449     OICFree(value);
 450     value = NULL;
 451
 452     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_PLATFORM_VERSION, &value));
 453     ASSERT_TRUE(value != NULL);
 454     EXPECT_STREQ("14", (char *)value);
 455     OICFree(value);
 456     value = NULL;
 457
 458     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_HARDWARE_VERSION, &value));
 459     ASSERT_TRUE(value != NULL);
 460     EXPECT_STREQ("0.1", (char *)value);
 461     OICFree(value);
 462     value = NULL;
 463
 464     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_FIRMWARE_VERSION, &value));
 465     ASSERT_TRUE(value != NULL);
 466     EXPECT_STREQ("0.1", (char *)value);
 467     OICFree(value);
 468     value = NULL;
 469
 470     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SUPPORT_URL, &value));
 471     ASSERT_TRUE(value != NULL);
 472     EXPECT_STREQ("http://www.iotivity.org", (char *)value);
 473     OICFree(value);
 474     value = NULL;
 475
 476     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, OC_RSRVD_SYSTEM_TIME, &value));
 477     ASSERT_TRUE(value != NULL);
 478     EXPECT_STREQ("", (char *)value);
 479     OICFree(value);
 480     value = NULL;
 481
 482     EXPECT_EQ(OC_STACK_OK,OCGetPropertyValue(PAYLOAD_TYPE_PLATFORM, "x.org.iotivity.AAAA", &value));
 483     ASSERT_TRUE(value != NULL);
 484     EXPECT_STREQ("value", (char *)value);
 485     OICFree(value);
 486
 487     EXPECT_EQ(OC_STACK_OK, OCStop());
 488 }
 489
 490 TEST(StackStart, SetDeviceInfoAPI)
 491 {
 492     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 493     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 494     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, "Sample"));
 495     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, "specVersion"));
 496     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", "value"));
 497     OCStringLL *dataModelVersions = OCCreateOCStringLL("Data Model Version");
 498     EXPECT_TRUE(dataModelVersions != NULL);
 499     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION, dataModelVersions));
 500     OCFreeOCStringLL(dataModelVersions);
 501     OCResourceHandle handle = OCGetResourceHandleAtUri(OC_RSRVD_DEVICE_URI);
 502     EXPECT_TRUE(handle != NULL);
 503     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "oic.wk.tv"));
 504     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, NULL, NULL));
 505     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPropertyValue(PAYLOAD_TYPE_INVALID, "", NULL));
 506     EXPECT_EQ(OC_STACK_OK, OCStop());
 507 }
 508
 509 TEST(StackStart, GetDeviceInfoAPI)
 510 {
 511     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 512     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
 513     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, "Sample"));
 514     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, "specVersion"));
 515     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", "value"));
 516     OCStringLL *dataModelVersions = OCCreateOCStringLL("Data Model Version");
 517     EXPECT_TRUE(dataModelVersions != NULL);
 518     EXPECT_EQ(OC_STACK_OK, OCSetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION, dataModelVersions));
 519     OCFreeOCStringLL(dataModelVersions);
 520     OCResourceHandle handle = OCGetResourceHandleAtUri(OC_RSRVD_DEVICE_URI);
 521     EXPECT_TRUE(handle != NULL);
 522     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "oic.wk.tv"));
 523
 524     void *value = NULL;
 525     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DEVICE_NAME, &value));
 526     ASSERT_TRUE(value != NULL);
 527     EXPECT_STREQ("Sample", (char *)value);
 528     OICFree(value);
 529     value = NULL;
 530
 531     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_SPEC_VERSION, &value));
 532     ASSERT_TRUE(value != NULL);
 533     EXPECT_STREQ("specVersion", (char *)value);
 534     OICFree(value);
 535     value = NULL;
 536
 537     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, "x.org.iotivity.newproperty", &value));
 538     ASSERT_TRUE(value != NULL);
 539     EXPECT_STREQ("value", (char *)value);
 540     OICFree(value);
 541     value = NULL;
 542
 543     EXPECT_EQ(OC_STACK_OK, OCGetPropertyValue(PAYLOAD_TYPE_DEVICE, OC_RSRVD_DATA_MODEL_VERSION, &value));
 544     ASSERT_TRUE(value != NULL);
 545     ASSERT_TRUE(((OCStringLL *)value)->value);
 546     EXPECT_STREQ("Data Model Version", ((OCStringLL *)value)->value);
 547     OCFreeOCStringLL((OCStringLL *) value);
 548     value = NULL;
 549
 550     EXPECT_STREQ("oic.wk.d", OCGetResourceTypeName(handle, 0));
 551     EXPECT_STREQ("oic.wk.tv", OCGetResourceTypeName(handle, 1));
 552
 553     EXPECT_EQ(OC_STACK_OK, OCStop());
 554 }
 555
 556 TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery)
 557 {
 558     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 559     OCCallbackData cbData;
 560     OCDoHandle handle;
 561
 562     OIC_LOG(INFO, TAG, "Starting DoResourceDeviceDiscovery test ");
 563     InitStack(OC_CLIENT);
 564
 565     /* Start a discovery query*/
 566     char szQueryUri[MAX_QUERY_LENGTH] = { 0 };
 567     strcpy(szQueryUri, OC_RSRVD_WELL_KNOWN_URI);
 568     cbData.cb = asyncDoResourcesCallback;
 569     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 570     cbData.cd = NULL;
 571     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
 572                                         OC_REST_GET,
 573                                         szQueryUri,
 574                                         0,
 575                                         0,
 576                                         CT_ADAPTER_IP,
 577                                         OC_LOW_QOS,
 578                                         &cbData,
 579                                         NULL,
 580                                         0));
 581     EXPECT_EQ(OC_STACK_OK, OCStop());
 582 }
 583
 584 TEST(StackStop, StackStopWithoutInit)
 585 {
 586     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 587     EXPECT_EQ(OC_STACK_ERROR, OCStop());
 588 }
 589
 590 TEST(StackStop, StackStopRepeated)
 591 {
 592     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 593     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
 594     EXPECT_EQ(OC_STACK_OK, OCStop());
 595     EXPECT_EQ(OC_STACK_ERROR, OCStop());
 596 }
 597
 598 TEST(StackResource, DISABLED_UpdateResourceNullURI)
 599 {
 600     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 601     OCCallbackData cbData;
 602     OCDoHandle handle;
 603
 604     OIC_LOG(INFO, TAG, "Starting UpdateResourceNullURI test");
 605     InitStack(OC_CLIENT);
 606
 607     /* Start a discovery query*/
 608     char szQueryUri[MAX_QUERY_LENGTH] = { 0 };
 609     strcpy(szQueryUri, OC_RSRVD_WELL_KNOWN_URI);
 610     cbData.cb = asyncDoResourcesCallback;
 611     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
 612     cbData.cd = NULL;
 613     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
 614                                         OC_REST_GET,
 615                                         szQueryUri,
 616                                         0,
 617                                         0,
 618                                         CT_ADAPTER_IP,
 619                                         OC_LOW_QOS,
 620                                         &cbData,
 621                                         NULL,
 622                                         0));
 623     EXPECT_EQ(OC_STACK_OK, OCStop());
 624 }
 625
 626 TEST(StackResource, CreateResourceBadParams)
 627 {
 628     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 629     OIC_LOG(INFO, TAG, "Starting CreateResourceBadParams test");
 630     InitStack(OC_SERVER);
 631
 632     OCResourceHandle handle;
 633
 634     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(NULL, //&handle,
 635                                             "core.led",
 636                                             "core.rw",
 637                                             "/a/led",
 638                                             0,
 639                                             NULL,
 640                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 641
 642     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 643                                             NULL, //"core.led",
 644                                             "core.rw",
 645                                             "/a/led",
 646                                             0,
 647                                             NULL,
 648                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 649
 650     // Property bitmask out of range
 651     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 652                                             "core.led",
 653                                             "core.rw",
 654                                             "/a/led",
 655                                             0,
 656                                             NULL,
 657                                             255));// invalid bitmask for OCResourceProperty
 658
 659     EXPECT_EQ(OC_STACK_OK, OCStop());
 660 }
 661
 662 TEST(StackResource, CreateResourceBadUri)
 663 {
 664     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 665     OIC_LOG(INFO, TAG, "Starting CreateResourceBadUri test");
 666     InitStack(OC_SERVER);
 667
 668     const char *uri257 = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVW";
 669
 670     OCResourceHandle handle;
 671
 672     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 673                                             "core.led",
 674                                             "core.rw",
 675                                             NULL, //"/a/led",
 676                                             0,
 677                                             0,
 678                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 679
 680     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 681                                             "core.led",
 682                                             "core.rw",
 683                                             "", //"/a/led",
 684                                             0,
 685                                             0,
 686                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 687
 688     EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
 689                                             "core.led",
 690                                             "core.rw",
 691                                             uri257, //"/a/led",
 692                                             0,
 693                                             0,
 694                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 695
 696     EXPECT_EQ(OC_STACK_OK, OCStop());
 697 }
 698
 699 TEST(StackResource, CreateResourceSuccess)
 700 {
 701     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 702     OIC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
 703     InitStack(OC_SERVER);
 704
 705     OCResourceHandle handle;
 706     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 707                                             "core.led",
 708                                             "core.rw",
 709                                             "/a/led",
 710                                             0,
 711                                             NULL,
 712                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 713     const char *url = OCGetResourceUri(handle);
 714     EXPECT_STREQ("/a/led", url);
 715
 716     EXPECT_EQ(OC_STACK_OK, OCStop());
 717 }
 718
 719 TEST(StackResource, CreateResourceSuccessWithResourcePolicyPropNone)
 720 {
 721     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 722     OIC_LOG(INFO, TAG, "Starting CreateResourceSuccessWithResourcePolicyPropNone test");
 723     InitStack(OC_SERVER);
 724
 725     OCResourceHandle handle;
 726     // the resource is non-discoverable & non-observable by the client.
 727     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 728                                             "core.led",
 729                                             "core.rw",
 730                                             "/a/led",
 731                                             0,
 732                                             NULL,
 733                                             OC_RES_PROP_NONE));// the resource is non-discoverable &
 734                                                 // non-observable by the client.
 735     const char* url = OCGetResourceUri(handle);
 736     EXPECT_STREQ("/a/led", url);
 737
 738     EXPECT_EQ(OC_STACK_OK, OCStop());
 739 }
 740
 741 TEST(StackResource, CreateResourceWithClientStackMode)
 742 {
 743     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 744     OIC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
 745     InitStack(OC_CLIENT);
 746
 747     OCResourceHandle handle;
 748     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 749                                             "core.led",
 750                                             "core.rw",
 751                                             "/a/led",
 752                                             0,
 753                                             NULL,
 754                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 755
 756     EXPECT_EQ(OC_STACK_OK, OCStop());
 757 }
 758
 759 TEST(StackResource, CreateResourceFailDuplicateUri)
 760 {
 761     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 762     OIC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
 763     InitStack(OC_SERVER);
 764
 765     OCResourceHandle handle;
 766     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 767                                             "core.led",
 768                                             "core.rw",
 769                                             "/a/led",
 770                                             0,
 771                                             NULL,
 772                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 773     const char *url = OCGetResourceUri(handle);
 774     EXPECT_STREQ("/a/led", url);
 775
 776     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 777                                             "core.led",
 778                                             "core.rw",
 779                                             "/a/led",
 780                                             0,
 781                                             NULL,
 782                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 783
 784     EXPECT_EQ(OC_STACK_OK, OCStop());
 785 }
 786
 787 TEST(StackResource, CreateResourceMultipleResources)
 788 {
 789     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 790     OIC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
 791     InitStack(OC_SERVER);
 792
 793     OCResourceHandle handle1;
 794     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
 795                                             "core.led",
 796                                             "core.rw",
 797                                             "/a/led1",
 798                                             0,
 799                                             NULL,
 800                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 801
 802     OCResourceHandle handle2;
 803     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
 804                                             "core.led",
 805                                             "core.rw",
 806                                             "/a/led2",
 807                                             0,
 808                                             NULL,
 809                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 810     OCResourceHandle handle3;
 811     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
 812                                             "core.led",
 813                                             "core.rw",
 814                                             "/a/led3",
 815                                             0,
 816                                             NULL,
 817                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 818
 819     const char *url = OCGetResourceUri(handle1);
 820     EXPECT_STREQ("/a/led1", url);
 821
 822     url = OCGetResourceUri(handle2);
 823     EXPECT_STREQ("/a/led2", url);
 824
 825     url = OCGetResourceUri(handle3);
 826     EXPECT_STREQ("/a/led3", url);
 827
 828     EXPECT_EQ(OC_STACK_OK, OCStop());
 829 }
 830
 831 TEST(StackResource, CreateResourceBadResoureType)
 832 {
 833     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 834     OIC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
 835     InitStack(OC_SERVER);
 836
 837     OCResourceHandle handle;
 838     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
 839                                             NULL, //"core.led",
 840                                             "core.rw",
 841                                             "/a/led",
 842                                             0,
 843                                             NULL,
 844                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 845
 846     OCResourceHandle handle2;
 847     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle2,
 848                                             "",
 849                                             "core.rw",
 850                                             "/a/led",
 851                                             0,
 852                                             NULL,
 853                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 854
 855     EXPECT_EQ(OC_STACK_OK, OCStop());
 856 }
 857
 858 TEST(StackResource, CreateResourceGoodResourceType)
 859 {
 860     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 861     OIC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
 862     InitStack(OC_SERVER);
 863
 864     OCResourceHandle handle;
 865     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 866                                             "core.led",
 867                                             "core.rw",
 868                                             "/a/led",
 869                                             0,
 870                                             NULL,
 871                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 872
 873     EXPECT_EQ(OC_STACK_OK, OCStop());
 874 }
 875
 876 TEST(StackResource, ResourceTypeName)
 877 {
 878     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 879     OIC_LOG(INFO, TAG, "Starting ResourceTypeName test");
 880     InitStack(OC_SERVER);
 881
 882     OCResourceHandle handle;
 883     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 884                                             "core.led",
 885                                             "core.rw",
 886                                             "/a/led",
 887                                             0,
 888                                             NULL,
 889                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 890
 891     uint8_t numResourceTypes;
 892     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 893     EXPECT_EQ(1, numResourceTypes);
 894     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
 895     EXPECT_STREQ("core.led", resourceTypeName);
 896
 897     // try getting resource type names with an invalid index
 898     resourceTypeName = OCGetResourceTypeName(handle, 1);
 899     EXPECT_STREQ(NULL, resourceTypeName);
 900     // try getting resource type names with an invalid index
 901     resourceTypeName = OCGetResourceTypeName(handle, 10);
 902     EXPECT_STREQ(NULL, resourceTypeName);
 903
 904     EXPECT_EQ(OC_STACK_OK, OCStop());
 905 }
 906
 907 TEST(StackResource, ResourceTypeAttrRepresentation)
 908 {
 909     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 910     OIC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
 911     InitStack(OC_SERVER);
 912
 913     OCResourceHandle handle;
 914     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 915                                             "core.led",
 916                                             "core.rw",
 917                                             "/a/led",
 918                                             0,
 919                                             NULL,
 920                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 921
 922     uint8_t numResourceTypes;
 923     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
 924     EXPECT_EQ(1, numResourceTypes);
 925
 926     EXPECT_EQ(OC_STACK_OK, OCStop());
 927 }
 928
 929 TEST(StackResource, ResourceTypeInterface)
 930 {
 931     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 932     OIC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
 933     InitStack(OC_SERVER);
 934
 935     OCResourceHandle handle;
 936     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 937                                             "core.led",
 938                                             "core.rw",
 939                                             "/a/led",
 940                                             0,
 941                                             NULL,
 942                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 943
 944     uint8_t numResourceInterfaces;
 945     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 946     EXPECT_EQ(2, numResourceInterfaces);
 947     const char *resourceInterfaceName1 = OCGetResourceInterfaceName(handle, 0);
 948     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, resourceInterfaceName1);
 949     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
 950     EXPECT_STREQ("core.rw", resourceInterfaceName);
 951
 952     // try getting resource interface names with an invalid index
 953     resourceInterfaceName = OCGetResourceInterfaceName(handle, 2);
 954     EXPECT_STREQ(NULL, resourceInterfaceName);
 955     // try getting resource interface names with an invalid index
 956     resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
 957     EXPECT_STREQ(NULL, resourceInterfaceName);
 958
 959     EXPECT_EQ(OC_STACK_OK, OCStop());
 960 }
 961
 962 TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
 963 {
 964     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 965
 966     OIC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
 967
 968     InitStack(OC_SERVER);
 969
 970     OCResourceHandle handle;
 971     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
 972                                             "core.led",
 973                                             "core.rw",
 974                                             "/a/led",
 975                                             0,
 976                                             NULL,
 977                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 978     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
 979                                         OC_RSRVD_INTERFACE_DEFAULT));
 980     uint8_t numResourceInterfaces;
 981     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
 982     EXPECT_EQ(2, numResourceInterfaces);
 983
 984     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
 985     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
 986
 987     const char*interfaceName_2 = OCGetResourceInterfaceName(handle, 1);
 988     EXPECT_STREQ("core.rw", interfaceName_2);
 989
 990     EXPECT_EQ(OC_STACK_OK, OCStop());
 991 }
 992
 993 TEST(StackResource, ResourceDuplicateDefaultInterfaces)
 994 {
 995     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 996
 997     OIC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
 998
 999     InitStack(OC_SERVER);
1000
1001     OCResourceHandle handle;
1002     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1003                                             "core.led",
1004                                             "core.rw",
1005                                             "/a/led",
1006                                             0,
1007                                             NULL,
1008                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1009
1010     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1011                                         OC_RSRVD_INTERFACE_DEFAULT));
1012     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1013                                         OC_RSRVD_INTERFACE_DEFAULT));
1014
1015     uint8_t numResourceInterfaces;
1016     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1017     EXPECT_EQ(2, numResourceInterfaces);
1018
1019     const char *interfaceName_1 = OCGetResourceInterfaceName(handle, 0);
1020     EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, interfaceName_1);
1021
1022     EXPECT_EQ(OC_STACK_OK, OCStop());
1023 }
1024
1025 TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
1026 {
1027     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1028
1029     OIC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
1030
1031     InitStack(OC_SERVER);
1032
1033     OCResourceHandle handle;
1034     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1035                                             "core.led",
1036                                             "core.rw",
1037                                             "/a/led",
1038                                             0,
1039                                             NULL,
1040                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1041
1042     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1043                                         "core.rw"));
1044     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
1045                                         "core.rw"));
1046
1047     uint8_t numResourceInterfaces;
1048     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1049     EXPECT_EQ(2, numResourceInterfaces);
1050
1051     EXPECT_EQ(OC_STACK_OK, OCStop());
1052 }
1053
1054 TEST(StackResource, ResourceTypeInterfaceMethods)
1055 {
1056     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1057     OIC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
1058     InitStack(OC_SERVER);
1059
1060     OCResourceHandle handle;
1061     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1062                                             "core.led",
1063                                             "core.rw",
1064                                             "/a/led",
1065                                             0,
1066                                             NULL,
1067                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1068
1069     uint8_t numResourceInterfaces;
1070     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1071     EXPECT_EQ(2, numResourceInterfaces);
1072
1073     EXPECT_EQ(OC_STACK_OK, OCStop());
1074 }
1075
1076 TEST(StackResource, GetResourceProperties)
1077 {
1078     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1079     OIC_LOG(INFO, TAG, "Starting GetResourceProperties test");
1080     InitStack(OC_SERVER);
1081
1082     OCResourceHandle handle;
1083     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1084                                             "core.led",
1085                                             "core.rw",
1086                                             "/a/led",
1087                                             0,
1088                                             NULL,
1089                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1090
1091 #ifdef MQ_PUBLISHER
1092     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE|OC_MQ_PUBLISHER, OCGetResourceProperties(handle));
1093 #else
1094     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
1095 #endif
1096     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1097
1098     EXPECT_EQ(OC_STACK_OK, OCStop());
1099 }
1100
1101 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
1102 {
1103     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1104     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
1105     InitStack(OC_SERVER);
1106     uint8_t numResources = 0;
1107     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1108
1109     OCResourceHandle handle;
1110     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1111                                             "core.led",
1112                                             "core.rw",
1113                                             "/a1/led",
1114                                             0,
1115                                             NULL,
1116                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1117     const char *url = OCGetResourceUri(handle);
1118     EXPECT_STREQ("/a1/led", url);
1119
1120     //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
1121     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1122     uint8_t numExpectedResources = 0;
1123
1124     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1125     EXPECT_EQ(numExpectedResources, numResources);
1126
1127     EXPECT_EQ(OC_STACK_OK, OCStop());
1128 }
1129
1130 TEST(StackResource, StackTestResourceDiscoverOneResource)
1131 {
1132     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1133     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
1134     InitStack(OC_SERVER);
1135
1136     OCResourceHandle handle;
1137     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1138                                             "core.led",
1139                                             "core.rw",
1140                                             "/a/led",
1141                                             0,
1142                                             NULL,
1143                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1144     const char *url = OCGetResourceUri(handle);
1145     EXPECT_STREQ("/a/led", url);
1146
1147     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1148     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
1149
1150     EXPECT_EQ(OC_STACK_OK, OCStop());
1151 }
1152
1153 TEST(StackResource, StackTestResourceDiscoverManyResources)
1154 {
1155     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1156     OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
1157     InitStack(OC_SERVER);
1158
1159     OCResourceHandle handle1;
1160     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1161                                             "core.led",
1162                                             "core.rw",
1163                                             "/a/led1",
1164                                             0,
1165                                             NULL,
1166                                             OC_DISCOVERABLE));
1167     const char *url = OCGetResourceUri(handle1);
1168     EXPECT_STREQ("/a/led1", url);
1169
1170     OCResourceHandle handle2;
1171     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1172                                             "core.led",
1173                                             "core.rw",
1174                                             "/a/led2",
1175                                             0,
1176                                             NULL,
1177                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1178     url = OCGetResourceUri(handle2);
1179     EXPECT_STREQ("/a/led2", url);
1180
1181     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.brightled"));
1182     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle2, "core.colorled"));
1183
1184     OCResourceHandle handle3;
1185     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1186                                             "core.led",
1187                                             "core.rw",
1188                                             "/a/led3",
1189                                             0,
1190                                             NULL,
1191                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1192     url = OCGetResourceUri(handle3);
1193     EXPECT_STREQ("/a/led3", url);
1194
1195     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
1196     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
1197
1198     OCResourceHandle handle4;
1199     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1200                                             "core.led",
1201                                             "core.rw",
1202                                             "/a/led4",
1203                                             0,
1204                                             NULL,
1205                                             OC_DISCOVERABLE));
1206     url = OCGetResourceUri(handle4);
1207     EXPECT_STREQ("/a/led4", url);
1208
1209     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
1210     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
1211     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
1212
1213     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
1214
1215     EXPECT_EQ(OC_STACK_OK, OCStop());
1216 }
1217
1218 TEST(StackBind, BindResourceTypeNameBad)
1219 {
1220     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1221     OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
1222     InitStack(OC_SERVER);
1223
1224     OCResourceHandle handle;
1225     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1226                                             "core.led",
1227                                             "core.rw",
1228                                             "/a/led",
1229                                             0,
1230                                             NULL,
1231                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1232
1233     uint8_t numResourceTypes;
1234     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1235     EXPECT_EQ(1, numResourceTypes);
1236     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1237     EXPECT_STREQ("core.led", resourceTypeName);
1238
1239     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, NULL));
1240     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, "core.nameBad"));
1241     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceTypeToResource(handle, "core.name bad"));
1242
1243     EXPECT_EQ(OC_STACK_OK, OCStop());
1244 }
1245
1246 TEST(StackBind, BindResourceTypeNameGood)
1247 {
1248     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1249     OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
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     uint8_t numResourceTypes;
1262     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1263     EXPECT_EQ(1, numResourceTypes);
1264     const char *resourceTypeName = OCGetResourceTypeName(handle, 0);
1265     EXPECT_STREQ("core.led", resourceTypeName);
1266
1267     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1268     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1269     EXPECT_EQ(2, numResourceTypes);
1270     resourceTypeName = OCGetResourceTypeName(handle, 1);
1271     EXPECT_STREQ("core.brightled", resourceTypeName);
1272
1273     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1274     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1275     EXPECT_EQ(3, numResourceTypes);
1276     resourceTypeName = OCGetResourceTypeName(handle, 2);
1277     EXPECT_STREQ("core.reallybrightled", resourceTypeName);
1278
1279     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "x.ReallyReallyBrightLED"));
1280     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1281     EXPECT_EQ(4, numResourceTypes);
1282     resourceTypeName = OCGetResourceTypeName(handle, 3);
1283     EXPECT_STREQ("x.ReallyReallyBrightLED", resourceTypeName);
1284
1285     EXPECT_EQ(OC_STACK_OK, OCStop());
1286 }
1287
1288 TEST(StackBind, BindResourceTypeAttribRepGood)
1289 {
1290     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1291     OIC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
1292     InitStack(OC_SERVER);
1293
1294     OCResourceHandle handle;
1295     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1296                                             "core.led",
1297                                             "core.rw",
1298                                             "/a/led",
1299                                             0,
1300                                             NULL,
1301                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1302
1303     uint8_t numResourceTypes;
1304     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1305     EXPECT_EQ(1, numResourceTypes);
1306
1307     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.brightled"));
1308     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1309     EXPECT_EQ(2, numResourceTypes);
1310
1311     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle, "core.reallybrightled"));
1312     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceTypes(handle, &numResourceTypes));
1313     EXPECT_EQ(3, numResourceTypes);
1314
1315     EXPECT_EQ(OC_STACK_OK, OCStop());
1316 }
1317
1318
1319 TEST(StackBind, BindResourceInterfaceNameBad)
1320 {
1321     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1322     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
1323     InitStack(OC_SERVER);
1324
1325     OCResourceHandle handle;
1326     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1327                                             "core.led",
1328                                             "core.rw",
1329                                             "/a/led",
1330                                             0,
1331                                             NULL,
1332                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1333
1334     uint8_t numResourceInterfaces;
1335     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1336     EXPECT_EQ(2, numResourceInterfaces);
1337     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1338     EXPECT_STREQ("core.rw", resourceInterfaceName);
1339
1340     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
1341
1342     EXPECT_EQ(OC_STACK_OK, OCStop());
1343 }
1344
1345 TEST(StackBind, BindResourceInterfaceNameGood)
1346 {
1347     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1348     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
1349     InitStack(OC_SERVER);
1350
1351     OCResourceHandle handle;
1352     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1353                                             "core.led",
1354                                             "core.rw",
1355                                             "/a/led",
1356                                             0,
1357                                             NULL,
1358                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1359
1360     uint8_t numResourceInterfaces;
1361     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1362     EXPECT_EQ(2, numResourceInterfaces);
1363     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
1364     EXPECT_STREQ("core.rw", resourceInterfaceName);
1365
1366     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1367
1368     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1369     EXPECT_EQ(3, numResourceInterfaces);
1370     resourceInterfaceName = OCGetResourceInterfaceName(handle, 2);
1371     EXPECT_STREQ("core.r", resourceInterfaceName);
1372
1373     EXPECT_EQ(OC_STACK_OK, OCStop());
1374 }
1375
1376 TEST(StackBind, BindResourceInterfaceMethodsBad)
1377 {
1378     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1379     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
1380     InitStack(OC_SERVER);
1381
1382     OCResourceHandle handle;
1383     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1384                                             "core.led",
1385                                             "core.rw",
1386                                             "/a/led",
1387                                             0,
1388                                             NULL,
1389                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1390
1391     uint8_t numResourceInterfaces;
1392     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1393     EXPECT_EQ(2, numResourceInterfaces);
1394
1395     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
1396
1397     EXPECT_EQ(OC_STACK_OK, OCStop());
1398 }
1399
1400 TEST(StackBind, BindResourceInterfaceMethodsGood)
1401 {
1402     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1403     OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
1404     InitStack(OC_SERVER);
1405
1406     OCResourceHandle handle;
1407     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1408                                             "core.led",
1409                                             "core.rw",
1410                                             "/a/led",
1411                                             0,
1412                                             NULL,
1413                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1414
1415     uint8_t numResourceInterfaces;
1416     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1417     EXPECT_EQ(2, numResourceInterfaces);
1418
1419     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
1420
1421     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
1422     EXPECT_EQ(3, numResourceInterfaces);
1423
1424     EXPECT_EQ(OC_STACK_OK, OCStop());
1425 }
1426
1427 TEST(StackBind, BindContainedResourceBad)
1428 {
1429     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1430     OIC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
1431     InitStack(OC_SERVER);
1432
1433     OCResourceHandle containerHandle;
1434     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1435                                             "core.led",
1436                                             "core.rw",
1437                                             "/a/kitchen",
1438                                             0,
1439                                             NULL,
1440                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1441
1442     OCResourceHandle handle0;
1443     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1444                                             "core.led",
1445                                             "core.rw",
1446                                             "/a/led",
1447                                             0,
1448                                             NULL,
1449                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1450
1451     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
1452
1453     EXPECT_EQ(OC_STACK_ERROR, OCBindResource((OCResourceHandle) 0, handle0));
1454
1455     EXPECT_EQ(OC_STACK_OK, OCStop());
1456 }
1457
1458 TEST(StackBind, BindContainedResourceGood)
1459 {
1460     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1461     OIC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
1462     InitStack(OC_SERVER);
1463
1464     uint8_t numResources = 0;
1465     uint8_t numExpectedResources = 0;
1466
1467     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1468
1469     OCResourceHandle containerHandle;
1470     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1471                                             "core.led",
1472                                             "core.rw",
1473                                             "/a/kitchen",
1474                                             0,
1475                                             NULL,
1476                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1477     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1478     EXPECT_EQ(++numExpectedResources, numResources);
1479
1480     OCResourceHandle handle0;
1481     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1482                                             "core.led",
1483                                             "core.rw",
1484                                             "/a/led0",
1485                                             0,
1486                                             NULL,
1487                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1488     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1489     EXPECT_EQ(++numExpectedResources, numResources);
1490
1491     OCResourceHandle handle1;
1492     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1493                                             "core.led",
1494                                             "core.rw",
1495                                             "/a/led1",
1496                                             0,
1497                                             NULL,
1498                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1499     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1500     EXPECT_EQ(++numExpectedResources, numResources);
1501
1502     OCResourceHandle handle2;
1503     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1504                                             "core.led",
1505                                             "core.rw",
1506                                             "/a/led2",
1507                                             0,
1508                                             NULL,
1509                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1510     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1511     EXPECT_EQ(++numExpectedResources, numResources);
1512
1513     OCResourceHandle handle3;
1514     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1515                                             "core.led",
1516                                             "core.rw",
1517                                             "/a/led3",
1518                                             0,
1519                                             NULL,
1520                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1521     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1522     EXPECT_EQ(++numExpectedResources, numResources);
1523
1524     OCResourceHandle handle4;
1525     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1526                                             "core.led",
1527                                             "core.rw",
1528                                             "/a/led4",
1529                                             0,
1530                                             NULL,
1531                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1532     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1533     EXPECT_EQ(++numExpectedResources, numResources);
1534
1535     OCResourceHandle handle5;
1536     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1537                                             "core.led",
1538                                             "core.rw",
1539                                             "/a/led5",
1540                                             0,
1541                                             NULL,
1542                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1543     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1544     EXPECT_EQ(++numExpectedResources, numResources);
1545
1546
1547     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle0));
1548     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle1));
1549     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
1550     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
1551     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
1552     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle5));
1553
1554     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
1555     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
1556     EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
1557     EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
1558     EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
1559     EXPECT_EQ(handle5, OCGetResourceHandleFromCollection(containerHandle, 5));
1560
1561     EXPECT_EQ(OC_STACK_OK, OCStop());
1562 }
1563
1564
1565 TEST(StackBind, BindEntityHandlerBad)
1566 {
1567     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1568     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
1569     InitStack(OC_SERVER);
1570
1571     OCResourceHandle handle;
1572     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1573                                             "core.led",
1574                                             "core.rw",
1575                                             "/a/led",
1576                                             0,
1577                                             NULL,
1578                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1579
1580     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
1581
1582     EXPECT_EQ(OC_STACK_OK, OCStop());
1583 }
1584
1585 TEST(StackBind, BindEntityHandlerGood)
1586 {
1587     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1588     OIC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
1589     InitStack(OC_SERVER);
1590
1591     OCResourceHandle handle;
1592     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
1593                                             "core.led",
1594                                             "core.rw",
1595                                             "/a/led",
1596                                             0,
1597                                             NULL,
1598                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1599
1600     OCEntityHandler myHandler = entityHandler;
1601
1602     EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
1603
1604     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
1605
1606     EXPECT_EQ(OC_STACK_OK, OCStop());
1607 }
1608
1609 TEST(StackResourceAccess, GetResourceByIndex)
1610 {
1611     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1612     OIC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
1613     InitStack(OC_SERVER);
1614
1615     uint8_t numResources = 0;
1616     uint8_t numExpectedResources = 0;
1617     uint8_t resourceIndex = 0;
1618     uint8_t prevResources = 0;
1619     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1620     prevResources = numExpectedResources;
1621     OCResourceHandle containerHandle;
1622     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
1623                                             "core.led",
1624                                             "core.rw",
1625                                             "/a/kitchen",
1626                                             0,
1627                                             NULL,
1628                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1629     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1630     EXPECT_EQ(++numExpectedResources, numResources);
1631
1632     OCResourceHandle handle0;
1633     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1634                                             "core.led",
1635                                             "core.rw",
1636                                             "/a/led0",
1637                                             0,
1638                                             NULL,
1639                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1640     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1641     EXPECT_EQ(++numExpectedResources, numResources);
1642
1643     OCResourceHandle handle1;
1644     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1645                                             "core.led",
1646                                             "core.rw",
1647                                             "/a/led1",
1648                                             0,
1649                                             NULL,
1650                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1651     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1652     EXPECT_EQ(++numExpectedResources, numResources);
1653
1654     OCResourceHandle handle2;
1655     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1656                                             "core.led",
1657                                             "core.rw",
1658                                             "/a/led2",
1659                                             0,
1660                                             NULL,
1661                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1662     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1663     EXPECT_EQ(++numExpectedResources, numResources);
1664
1665     OCResourceHandle handle3;
1666     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1667                                             "core.led",
1668                                             "core.rw",
1669                                             "/a/led3",
1670                                             0,
1671                                             NULL,
1672                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1673     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1674     EXPECT_EQ(++numExpectedResources, numResources);
1675
1676     OCResourceHandle handle4;
1677     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
1678                                             "core.led",
1679                                             "core.rw",
1680                                             "/a/led4",
1681                                             0,
1682                                             NULL,
1683                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1684     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1685     EXPECT_EQ(++numExpectedResources, numResources);
1686
1687     OCResourceHandle handle5;
1688     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle5,
1689                                             "core.led",
1690                                             "core.rw",
1691                                             "/a/led5",
1692                                             0,
1693                                             NULL,
1694                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1695     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1696     EXPECT_EQ(++numExpectedResources, numResources);
1697     resourceIndex += prevResources;
1698     EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
1699     EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
1700     EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
1701     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1702     EXPECT_EQ(handle3, OCGetResourceHandle(++resourceIndex));
1703     EXPECT_EQ(handle4, OCGetResourceHandle(++resourceIndex));
1704     EXPECT_EQ(handle5, OCGetResourceHandle(++resourceIndex));
1705
1706     EXPECT_EQ(OC_STACK_OK, OCStop());
1707 }
1708
1709 TEST(StackResourceAccess, DeleteHeadResource)
1710 {
1711     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1712     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
1713     InitStack(OC_SERVER);
1714
1715     uint8_t numResources = 0;
1716     uint8_t numExpectedResources = 0;
1717
1718     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1719
1720     OCResourceHandle handle0;
1721     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1722                                             "core.led",
1723                                             "core.rw",
1724                                             "/a/led0",
1725                                             0,
1726                                             NULL,
1727                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1728     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1729     EXPECT_EQ(++numExpectedResources, numResources);
1730
1731     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1732     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1733     EXPECT_EQ(--numExpectedResources, numResources);
1734
1735     EXPECT_EQ(OC_STACK_OK, OCStop());
1736 }
1737
1738 TEST(StackResourceAccess, DeleteHeadResource2)
1739 {
1740     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1741     OIC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
1742     InitStack(OC_SERVER);
1743
1744     uint8_t numResources = 0;
1745     uint8_t numExpectedResources = 0;
1746
1747     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1748     OCResourceHandle handle0;
1749     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1750                                             "core.led",
1751                                             "core.rw",
1752                                             "/a/led0",
1753                                             0,
1754                                             NULL,
1755                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1756     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1757     EXPECT_EQ(++numExpectedResources, numResources);
1758
1759     OCResourceHandle handle1;
1760     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1761                                             "core.led",
1762                                             "core.rw",
1763                                             "/a/led1",
1764                                             0,
1765                                             NULL,
1766                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1767     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1768     EXPECT_EQ(++numExpectedResources, numResources);
1769
1770     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle0));
1771     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1772     EXPECT_EQ(--numExpectedResources, numResources);
1773
1774     EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
1775
1776     EXPECT_EQ(OC_STACK_OK, OCStop());
1777 }
1778
1779
1780 TEST(StackResourceAccess, DeleteLastResource)
1781 {
1782     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1783     OIC_LOG(INFO, TAG, "Starting DeleteLastResource test");
1784     InitStack(OC_SERVER);
1785
1786     uint8_t numResources = 0;
1787     uint8_t numExpectedResources = 0;
1788
1789     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1790
1791     OCResourceHandle handle0;
1792     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1793                                             "core.led",
1794                                             "core.rw",
1795                                             "/a/led0",
1796                                             0,
1797                                             NULL,
1798                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1799     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1800     EXPECT_EQ(++numExpectedResources, numResources);
1801
1802     OCResourceHandle handle1;
1803     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1804                                             "core.led",
1805                                             "core.rw",
1806                                             "/a/led1",
1807                                             0,
1808                                             NULL,
1809                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1810     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1811     EXPECT_EQ(++numExpectedResources, numResources);
1812
1813     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1814     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1815     EXPECT_EQ(--numExpectedResources, numResources);
1816
1817     EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
1818
1819     OCResourceHandle handle2;
1820     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1821                                             "core.led",
1822                                             "core.rw",
1823                                             "/a/led2",
1824                                             0,
1825                                             NULL,
1826                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1827     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1828     EXPECT_EQ(++numExpectedResources, numResources);
1829
1830     EXPECT_EQ(OC_STACK_OK, OCStop());
1831 }
1832
1833 TEST(StackResourceAccess, DeleteMiddleResource)
1834 {
1835     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1836     OIC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
1837     InitStack(OC_SERVER);
1838
1839     uint8_t numResources = 0;
1840     uint8_t numExpectedResources = 0;
1841     uint8_t resourceIndex = InitResourceIndex();
1842
1843     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
1844     resourceIndex = numExpectedResources;
1845     OCResourceHandle handle0;
1846     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
1847                                             "core.led",
1848                                             "core.rw",
1849                                             "/a/led0",
1850                                             0,
1851                                             NULL,
1852                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1853     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1854     EXPECT_EQ(++numExpectedResources, numResources);
1855
1856     OCResourceHandle handle1;
1857     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1858                                             "core.led",
1859                                             "core.rw",
1860                                             "/a/led1",
1861                                             0,
1862                                             NULL,
1863                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1864     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1865     EXPECT_EQ(++numExpectedResources, numResources);
1866
1867     OCResourceHandle handle2;
1868     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1869                                             "core.led",
1870                                             "core.rw",
1871                                             "/a/led2",
1872                                             0,
1873                                             NULL,
1874                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1875     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1876     EXPECT_EQ(++numExpectedResources, numResources);
1877
1878     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle1));
1879     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
1880     EXPECT_EQ(--numExpectedResources, numResources);
1881
1882     EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
1883     EXPECT_EQ(handle2, OCGetResourceHandle(++resourceIndex));
1884
1885     // Make sure the resource elements are still correct
1886     uint8_t numResourceInterfaces;
1887     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
1888     EXPECT_EQ(2, numResourceInterfaces);
1889     const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 1);
1890     EXPECT_STREQ("core.rw", resourceInterfaceName);
1891
1892     EXPECT_EQ(OC_STACK_OK, OCStop());
1893 }
1894
1895 // Visual Studio versions earlier than 2015 have bugs in is_pod and report the wrong answer.
1896 #if !defined(_MSC_VER) || (_MSC_VER >= 1900)
1897 TEST(PODTests, OCHeaderOption)
1898 {
1899     EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
1900 }
1901
1902 TEST(PODTests, OCCallbackData)
1903 {
1904     EXPECT_TRUE(std::is_pod<OCCallbackData>::value);
1905 }
1906 #endif
1907
1908 TEST(OCDoDirectPairingTests, Nullpeer)
1909 {
1910     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, NULL, pmSel, &pinNumber, &resultCallback));
1911 }
1912
1913 TEST(OCDoDirectPairingTests, NullCallback)
1914 {
1915     EXPECT_EQ(OC_STACK_INVALID_CALLBACK,OCDoDirectPairing(NULL, &peer, pmSel, &pinNumber, NULL));
1916 }
1917
1918 TEST(OCDoDirectPairingTests, NullpinNumber)
1919 {
1920     EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, &peer, pmSel, NULL, &resultCallback));
1921 }
1922
1923 TEST(StackResource, MultipleResourcesDiscovery)
1924 {
1925     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
1926     OIC_LOG(INFO, TAG, "Starting MultipleResourcesDiscovery test");
1927     InitStack(OC_SERVER);
1928
1929     OCResourceHandle handle1;
1930     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
1931                                             "core.led",
1932                                             "core.rw",
1933                                             "/a/led1",
1934                                             0,
1935                                             NULL,
1936                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1937
1938     OCResourceHandle handle2;
1939     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
1940                                             "core.led",
1941                                             "core.rw",
1942                                             "/a/led2",
1943                                             0,
1944                                             NULL,
1945                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1946     OCResourceHandle handle3;
1947     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
1948                                             "core.led",
1949                                             "core.rw",
1950                                             "/a/led3",
1951                                             0,
1952                                             NULL,
1953                                             OC_DISCOVERABLE|OC_OBSERVABLE));
1954     /* Start a discovery query*/
1955     char szQueryUri[MAX_QUERY_LENGTH] = "/oic/res?if=oic.if.ll";
1956     OCCallbackData cbData;
1957     cbData.cb = discoveryCallback;
1958     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
1959     cbData.cd = NULL;
1960
1961     OCDoHandle handle;
1962     EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
1963                                         OC_REST_DISCOVER,
1964                                         szQueryUri,
1965                                         0,
1966                                         0,
1967                                         CT_ADAPTER_IP,
1968                                         OC_LOW_QOS,
1969                                         &cbData,
1970                                         NULL,
1971                                         0));
1972
1973     EXPECT_EQ(OC_STACK_OK, OCStop());
1974 }
1975
1976 TEST(StackPayload, CloneByteString)
1977 {
1978     uint8_t bytes[] = { 0, 1, 2, 3 };
1979     OCByteString byteString;
1980     byteString.bytes = bytes;
1981     byteString.len = sizeof(bytes);
1982
1983     OCRepPayload *original = OCRepPayloadCreate();
1984     ASSERT_TRUE(original != NULL);
1985     EXPECT_TRUE(OCRepPayloadSetPropByteString(original, "name", byteString));
1986
1987     OCRepPayload *clone = OCRepPayloadClone(original);
1988     ASSERT_TRUE(clone != NULL);
1989
1990     OCRepPayloadDestroy(original);
1991
1992     OCByteString cloneByteString;
1993     EXPECT_TRUE(OCRepPayloadGetPropByteString(clone, "name", &cloneByteString));
1994     ASSERT_TRUE(cloneByteString.bytes != NULL);
1995     EXPECT_EQ(sizeof(bytes), cloneByteString.len);
1996     EXPECT_TRUE(0 == memcmp(bytes, cloneByteString.bytes, sizeof(bytes)));
1997     OICFree(cloneByteString.bytes);
1998
1999     OCRepPayloadDestroy(clone);
2000 }
2001
2002 TEST(StackUri, Rfc6874_Noop_1)
2003 {
2004     char validIPv6Address[] = "FF01:0:0:0:0:0:0:FB";
2005     char bytes[100] = {0};
2006     strncpy(bytes, validIPv6Address, sizeof(bytes));
2007
2008     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2009
2010     // No % sign, should do nothing
2011     EXPECT_STREQ(bytes, validIPv6Address);
2012     EXPECT_EQ(OC_STACK_OK, result);
2013 }
2014
2015 TEST(StackUri, Rfc6874_Noop_2)
2016 {
2017     char validIPv6Address[] = "3812:a61::4:1";
2018     char bytes[100] = {0};
2019
2020     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2021
2022     // No % sign, should do nothing
2023     EXPECT_STREQ(bytes, validIPv6Address);
2024     EXPECT_EQ(OC_STACK_OK, result);
2025 }
2026
2027 TEST(StackUri, Rfc6874_WithEncoding)
2028 {
2029     char validIPv6Address[] =        "fe80::dafe:e3ff:fe00:ebfa%wlan0";
2030     char validIPv6AddressEncoded[] = "fe80::dafe:e3ff:fe00:ebfa%25wlan0";
2031     char bytes[100] = "";
2032     strncpy(bytes, validIPv6Address, sizeof(bytes));
2033
2034     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2035
2036     // Encoding should have occured
2037     EXPECT_STREQ(bytes, validIPv6AddressEncoded);
2038     EXPECT_EQ(OC_STACK_OK, result);
2039 }
2040
2041 TEST(StackUri, Rfc6874_WithEncoding_ExtraPercent)
2042 {
2043     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%%wlan0";
2044     char bytes[100] = {0};
2045
2046     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6Address);
2047
2048     // Encoding should have failed due to extra '%' character
2049     EXPECT_STREQ(bytes, "");
2050     EXPECT_EQ(OC_STACK_ERROR, result);
2051 }
2052
2053 TEST(StackUri, Rfc6874_AlreadyEncoded)
2054 {
2055     char validIPv6AddressEncoded[] = "fe80::dafe:e3ff:fe00:ebfa%25wlan0";
2056     char bytes[100] = {0};
2057
2058     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), validIPv6AddressEncoded);
2059
2060     // Encoding should have failed due to extra '%' character
2061     EXPECT_STREQ(bytes, "");
2062     EXPECT_EQ(OC_STACK_ERROR, result);
2063 }
2064
2065 TEST(StackUri, Rfc6874_NoOverflow)
2066 {
2067     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0";
2068     char addrBuffer[100];
2069     char bytes[100] = {0};
2070     memset(addrBuffer, sizeof(addrBuffer), '_');
2071
2072     // Just enough room to encode
2073     addrBuffer[sizeof(addrBuffer) - sizeof(validIPv6Address) - 3] = '\0';
2074     strcat(addrBuffer, validIPv6Address);
2075
2076     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), addrBuffer);
2077
2078     // Encoding should have succeeded
2079     EXPECT_EQ(OC_STACK_OK, result);
2080 }
2081
2082 TEST(StackUri, Rfc6874_NoOverflow_2)
2083 {
2084     char validIPv6Address[] = "fe80::dafe:e3ff:fe00:ebfa%wlan0";
2085     char addrBuffer[100];
2086     char bytes[100] = {0};
2087     memset(addrBuffer, sizeof(addrBuffer), '_');
2088
2089     // Not enough room to encode
2090     addrBuffer[sizeof(addrBuffer) - sizeof(validIPv6Address) - 1] = '\0';
2091     strcat(addrBuffer, validIPv6Address);
2092
2093     OCStackResult result = OCEncodeAddressForRFC6874(bytes, sizeof(bytes), addrBuffer);
2094
2095     // Encoding should have failed due to output size limitations
2096     EXPECT_STREQ(bytes, "");
2097     EXPECT_EQ(OC_STACK_ERROR, result);
2098 }
2099
2100 TEST(StackHeaderOption, setHeaderOption)
2101 {
2102     uint8_t optionValue1[MAX_HEADER_OPTION_DATA_LENGTH] =
2103     { 1 };
2104     OCHeaderOption options[MAX_HEADER_OPTIONS] =
2105     {
2106     { OC_COAP_ID, 6, 8, optionValue1 }, };
2107     uint8_t optionData = 255;
2108     size_t optionDataSize = sizeof(optionData);
2109     size_t numOptions = 1;
2110     uint16_t optionID = 2048;
2111     EXPECT_EQ(OC_STACK_OK, OCSetHeaderOption(options,
2112                                              &numOptions,
2113                                              optionID,
2114                                              &optionData,
2115                                              optionDataSize));
2116     EXPECT_EQ(options[1].optionID, optionID);
2117     EXPECT_EQ(options[1].optionData[0], 255);
2118 }
2119
2120 TEST(StackHeaderOption, getHeaderOption)
2121 {
2122     uint8_t optionValue1[MAX_HEADER_OPTION_DATA_LENGTH] =
2123     { 1 };
2124     uint8_t optionValue2[MAX_HEADER_OPTION_DATA_LENGTH] =
2125     { 255 };
2126     OCHeaderOption options[MAX_HEADER_OPTIONS] =
2127     {
2128     { OC_COAP_ID, 6, 8, optionValue1 },
2129     { OC_COAP_ID, 2048, 16, optionValue2 }, };
2130     uint8_t optionData[MAX_HEADER_OPTION_DATA_LENGTH];
2131     size_t optionDataSize = sizeof(optionData);
2132     size_t numOptions = 2;
2133     uint16_t optionID = 6;
2134     uint16_t actualDataSize = 0;
2135     EXPECT_EQ(OC_STACK_OK, OCGetHeaderOption(options,
2136                                              numOptions,
2137                                              optionID,
2138                                              optionData,
2139                                              optionDataSize,
2140                                              &actualDataSize));
2141     EXPECT_EQ(optionData[0], 1);
2142     EXPECT_EQ(actualDataSize, 8);
2143 }