resource/csdk/stack/test/stacktests.cpp

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