IOT-982 Query handling for /oic/res

[platform/upstream/iotivity.git] / resource / csdk / stack / test / stacktests.cpp

diff --git a/resource/csdk/stack/test/stacktests.cpp b/resource/csdk/stack/test/stacktests.cpp
old mode 100644 (file)
new mode 100755 (executable)
index e3914ff..037edcd
--- a/resource/csdk/stack/test/stacktests.cpp
+++ b/resource/csdk/stack/test/stacktests.cpp
@@ -22,8 +22,9 @@
 extern "C"
 {
     #include "ocstack.h"
+    #include "ocstackinternal.h"
     #include "logger.h"
-    #include "ocmalloc.h"
+    #include "oic_malloc.h"
 }
 
 #include "gtest/gtest.h"
@@ -56,21 +57,70 @@ namespace itst = iotivity::test;
 //-----------------------------------------------------------------------------
 static const char TAG[] = "TestHarness";
 
+char gDeviceUUID[] = "myDeviceUUID";
+char gManufacturerName[] = "myName";
+char gTooLongManufacturerName[] = "extremelylongmanufacturername";
+char gManufacturerUrl[] = "www.foooooooooooooooo.baaaaaaaaaaaaar";
+static OCPrm_t pmSel;
+static char pinNumber;
+static OCDPDev_t peer;
+
 std::chrono::seconds const SHORT_TEST_TIMEOUT = std::chrono::seconds(5);
 
 //-----------------------------------------------------------------------------
 // Callback functions
 //-----------------------------------------------------------------------------
-extern "C"  OCStackApplicationResult asyncDoResourcesCallback(void* ctx, OCDoHandle handle, OCClientResponse * clientResponse)
+extern "C"  OCStackApplicationResult asyncDoResourcesCallback(void* ctx,
+        OCDoHandle /*handle*/, OCClientResponse * clientResponse)
 {
-    OC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
+    OIC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
 
     EXPECT_EQ(OC_STACK_OK, clientResponse->result);
 
     if(ctx == (void*)DEFAULT_CONTEXT_VALUE) {
-        OC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
+        OIC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
+    }
+    OIC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
+
+    return OC_STACK_KEEP_TRANSACTION;
+}
+
+static void resultCallback(OCDPDev_t *UNUSED1, OCStackResult UNUSED2)
+{
+    (void) (UNUSED1);
+    (void) (UNUSED2);
+}
+
+extern "C" OCStackApplicationResult discoveryCallback(void* ctx,
+        OCDoHandle /*handle*/, OCClientResponse * clientResponse)
+{
+    OIC_LOG(INFO, TAG, "Entering asyncDoResourcesCallback");
+
+    EXPECT_EQ(OC_STACK_OK, clientResponse->result);
+
+    if(ctx == (void*)DEFAULT_CONTEXT_VALUE)
+    {
+        OIC_LOG_V(INFO, TAG, "Callback Context recvd successfully");
+    }
+
+    OIC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
+
+    OCDiscoveryPayload *discoveryPayload = ((OCDiscoveryPayload *) clientResponse->payload);
+    EXPECT_TRUE(discoveryPayload != NULL);
+    OCResourcePayload *res = discoveryPayload->resources;
+    size_t count = 0;
+    for (OCResourcePayload *res1 = discoveryPayload->resources; res1; res1 = res1->next)
+    {
+        count++;
     }
-    OC_LOG_V(INFO, TAG, "result = %d", clientResponse->result);
+    EXPECT_EQ(3, count);
+    EXPECT_EQ("/a/led1", res->uri);
+    res = res->next;
+    EXPECT_EQ("/a/led2", res->uri);
+    res = res->next;
+    EXPECT_EQ("/a/led3", res->uri);
+    res = res->next;
+    EXPECT_TRUE(res == NULL);
 
     return OC_STACK_KEEP_TRANSACTION;
 }
@@ -78,9 +128,11 @@ extern "C"  OCStackApplicationResult asyncDoResourcesCallback(void* ctx, OCDoHan
 //-----------------------------------------------------------------------------
 // Entity handler
 //-----------------------------------------------------------------------------
-OCEntityHandlerResult entityHandler(OCEntityHandlerFlag flag, OCEntityHandlerRequest * entityHandlerRequest)
+OCEntityHandlerResult entityHandler(OCEntityHandlerFlag /*flag*/,
+        OCEntityHandlerRequest * /*entityHandlerRequest*/,
+        void* /*callbackParam*/)
 {
-    OC_LOG(INFO, TAG, "Entering entityHandler");
+    OIC_LOG(INFO, TAG, "Entering entityHandler");
 
     return OC_EH_OK;
 }
@@ -90,10 +142,10 @@ OCEntityHandlerResult entityHandler(OCEntityHandlerFlag flag, OCEntityHandlerReq
 //-----------------------------------------------------------------------------
 void InitStack(OCMode mode)
 {
-    OC_LOG(INFO, TAG, "Entering InitStack");
+    OIC_LOG(INFO, TAG, "Entering InitStack");
 
     EXPECT_EQ(OC_STACK_OK, OCInit(NULL, 0, mode));
-    OC_LOG(INFO, TAG, "Leaving InitStack");
+    OIC_LOG(INFO, TAG, "Leaving InitStack");
 }
 
 uint8_t InitNumExpectedResources()
@@ -180,18 +232,127 @@ TEST(StackStart, StackStartSuccessiveInits)
     EXPECT_EQ(OC_STACK_OK, OCStop());
 }
 
+TEST(StackStart, SetPlatformInfoValid)
+{
+    itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
+    EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
+
+    OCPlatformInfo info =
+    {
+        gDeviceUUID,
+        gManufacturerName,
+        0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+    EXPECT_EQ(OC_STACK_OK, OCSetPlatformInfo(info));
+    EXPECT_EQ(OC_STACK_OK, OCStop());
+}
+
+TEST(StackStart, SetPlatformInfoWithClientMode)
+{
+    itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
+    EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
+
+    OCPlatformInfo info =
+    {
+        gDeviceUUID,
+        gManufacturerName,
+        0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+    EXPECT_EQ(OC_STACK_ERROR, OCSetPlatformInfo(info));
+    EXPECT_EQ(OC_STACK_OK, OCStop());
+}
+
+TEST(StackStart, SetPlatformInfoWithNoPlatformID)
+{
+    itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
+    EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
+
+    OCPlatformInfo info =
+     {
+         0,
+         gDeviceUUID,
+         0, 0, 0, 0, 0, 0, 0, 0, 0
+     };
+
+    EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
+    EXPECT_EQ(OC_STACK_OK, OCStop());
+}
+
+TEST(StackStart, SetPlatformInfoWithNoManufacturerName)
+{
+    itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
+    EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
+
+    OCPlatformInfo info =
+    {
+        gDeviceUUID,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+
+    EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
+    EXPECT_EQ(OC_STACK_OK, OCStop());
+}
+
+TEST(StackStart, SetPlatformInfoWithZeroLengthManufacturerName)
+{
+    itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
+    EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
+
+    OCPlatformInfo info =
+    {
+        gDeviceUUID,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+    info.manufacturerName = (char *) "";
+
+    EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
+    EXPECT_EQ(OC_STACK_OK, OCStop());
+}
+
+TEST(StackStart, SetPlatformInfoWithTooLongManufacName)
+{
+    itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
+    EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
+
+    OCPlatformInfo info =
+    {
+        gDeviceUUID,
+        gTooLongManufacturerName,
+        0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+
+    EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
+    EXPECT_EQ(OC_STACK_OK, OCStop());
+}
+
+TEST(StackStart, SetPlatformInfoWithTooLongManufacURL)
+{
+    itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
+    EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_SERVER));
+    OCPlatformInfo info =
+    {
+        gDeviceUUID,
+        gManufacturerName,
+        gManufacturerUrl,
+        0, 0, 0, 0, 0, 0, 0, 0
+    };
+
+    EXPECT_EQ(OC_STACK_INVALID_PARAM, OCSetPlatformInfo(info));
+    EXPECT_EQ(OC_STACK_OK, OCStop());
+}
+
 TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
     OCCallbackData cbData;
     OCDoHandle handle;
 
-    OC_LOG(INFO, TAG, "Starting DoResourceDeviceDiscovery test ");
+    OIC_LOG(INFO, TAG, "Starting DoResourceDeviceDiscovery test ");
     InitStack(OC_CLIENT);
 
     /* Start a discovery query*/
     char szQueryUri[64] = { 0 };
-    strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
+    strcpy(szQueryUri, OC_RSRVD_WELL_KNOWN_URI);
     cbData.cb = asyncDoResourcesCallback;
     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
     cbData.cd = NULL;
@@ -200,7 +361,7 @@ TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery)
                                         szQueryUri,
                                         0,
                                         0,
-                                        OC_WIFI,
+                                        CT_ADAPTER_IP,
                                         OC_LOW_QOS,
                                         &cbData,
                                         NULL,
@@ -211,6 +372,12 @@ TEST(StackDiscovery, DISABLED_DoResourceDeviceDiscovery)
 TEST(StackStop, StackStopWithoutInit)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
+    EXPECT_EQ(OC_STACK_ERROR, OCStop());
+}
+
+TEST(StackStop, StackStopRepeated)
+{
+    itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
     EXPECT_EQ(OC_STACK_OK, OCInit("127.0.0.1", 5683, OC_CLIENT));
     EXPECT_EQ(OC_STACK_OK, OCStop());
     EXPECT_EQ(OC_STACK_ERROR, OCStop());
@@ -222,12 +389,12 @@ TEST(StackResource, DISABLED_UpdateResourceNullURI)
     OCCallbackData cbData;
     OCDoHandle handle;
 
-    OC_LOG(INFO, TAG, "Starting UpdateResourceNullURI test");
+    OIC_LOG(INFO, TAG, "Starting UpdateResourceNullURI test");
     InitStack(OC_CLIENT);
 
     /* Start a discovery query*/
     char szQueryUri[64] = { 0 };
-    strcpy(szQueryUri, OC_WELL_KNOWN_QUERY);
+    strcpy(szQueryUri, OC_RSRVD_WELL_KNOWN_URI);
     cbData.cb = asyncDoResourcesCallback;
     cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
     cbData.cd = NULL;
@@ -236,7 +403,7 @@ TEST(StackResource, DISABLED_UpdateResourceNullURI)
                                         szQueryUri,
                                         0,
                                         0,
-                                        OC_WIFI,
+                                        CT_ADAPTER_IP,
                                         OC_LOW_QOS,
                                         &cbData,
                                         NULL,
@@ -247,7 +414,7 @@ TEST(StackResource, DISABLED_UpdateResourceNullURI)
 TEST(StackResource, CreateResourceBadParams)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting CreateResourceBadParams test");
+    OIC_LOG(INFO, TAG, "Starting CreateResourceBadParams test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -257,6 +424,7 @@ TEST(StackResource, CreateResourceBadParams)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
@@ -264,6 +432,7 @@ TEST(StackResource, CreateResourceBadParams)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     // Property bitmask out of range
@@ -272,16 +441,53 @@ TEST(StackResource, CreateResourceBadParams)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             128));// invalid bitmask for OCResourceProperty
 
     EXPECT_EQ(OC_STACK_OK, OCStop());
 }
 
+TEST(StackResource, CreateResourceBadUri)
+{
+    itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
+    OIC_LOG(INFO, TAG, "Starting CreateResourceBadUri test");
+    InitStack(OC_SERVER);
+
+    const char *uri65 = "ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKL";
+
+    OCResourceHandle handle;
+
+    EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
+                                            "core.led",
+                                            "core.rw",
+                                            NULL, //"/a/led",
+                                            0,
+                                            0,
+                                            OC_DISCOVERABLE|OC_OBSERVABLE));
+
+    EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
+                                            "core.led",
+                                            "core.rw",
+                                            "", //"/a/led",
+                                            0,
+                                            0,
+                                            OC_DISCOVERABLE|OC_OBSERVABLE));
+
+    EXPECT_EQ(OC_STACK_INVALID_URI, OCCreateResource(&handle,
+                                            "core.led",
+                                            "core.rw",
+                                            uri65, //"/a/led",
+                                            0,
+                                            0,
+                                            OC_DISCOVERABLE|OC_OBSERVABLE));
+
+    EXPECT_EQ(OC_STACK_OK, OCStop());
+}
 
 TEST(StackResource, CreateResourceSuccess)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
+    OIC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -290,6 +496,7 @@ TEST(StackResource, CreateResourceSuccess)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     const char *url = OCGetResourceUri(handle);
     EXPECT_STREQ("/a/led", url);
@@ -297,10 +504,50 @@ TEST(StackResource, CreateResourceSuccess)
     EXPECT_EQ(OC_STACK_OK, OCStop());
 }
 
+TEST(StackResource, CreateResourceSuccessWithResourcePolicyPropNone)
+{
+    itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
+    OIC_LOG(INFO, TAG, "Starting CreateResourceSuccessWithResourcePolicyPropNone test");
+    InitStack(OC_SERVER);
+
+    OCResourceHandle handle;
+    // the resource is non-discoverable & non-observable by the client.
+    EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
+                                            "core.led",
+                                            "core.rw",
+                                            "/a/led",
+                                            0,
+                                            NULL,
+                                            OC_RES_PROP_NONE));// the resource is non-discoverable &
+                                                // non-observable by the client.
+    const char* url = OCGetResourceUri(handle);
+    EXPECT_STREQ("/a/led", url);
+
+    EXPECT_EQ(OC_STACK_OK, OCStop());
+}
+
+TEST(StackResource, CreateResourceWithClientStackMode)
+{
+    itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
+    OIC_LOG(INFO, TAG, "Starting CreateResourceSuccess test");
+    InitStack(OC_CLIENT);
+
+    OCResourceHandle handle;
+    EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle,
+                                            "core.led",
+                                            "core.rw",
+                                            "/a/led",
+                                            0,
+                                            NULL,
+                                            OC_DISCOVERABLE|OC_OBSERVABLE));
+
+    EXPECT_EQ(OC_STACK_OK, OCStop());
+}
+
 TEST(StackResource, CreateResourceFailDuplicateUri)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
+    OIC_LOG(INFO, TAG, "Starting CreateResourceFailDuplicateUri test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -309,6 +556,7 @@ TEST(StackResource, CreateResourceFailDuplicateUri)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     const char *url = OCGetResourceUri(handle);
     EXPECT_STREQ("/a/led", url);
@@ -318,6 +566,7 @@ TEST(StackResource, CreateResourceFailDuplicateUri)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     EXPECT_EQ(OC_STACK_OK, OCStop());
@@ -326,7 +575,7 @@ TEST(StackResource, CreateResourceFailDuplicateUri)
 TEST(StackResource, CreateResourceMultipleResources)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
+    OIC_LOG(INFO, TAG, "Starting CreateResourceMultipleResources test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle1;
@@ -335,6 +584,7 @@ TEST(StackResource, CreateResourceMultipleResources)
                                             "core.rw",
                                             "/a/led1",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     OCResourceHandle handle2;
@@ -343,6 +593,7 @@ TEST(StackResource, CreateResourceMultipleResources)
                                             "core.rw",
                                             "/a/led2",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     OCResourceHandle handle3;
     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
@@ -350,6 +601,7 @@ TEST(StackResource, CreateResourceMultipleResources)
                                             "core.rw",
                                             "/a/led3",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     const char *url = OCGetResourceUri(handle1);
@@ -367,7 +619,7 @@ TEST(StackResource, CreateResourceMultipleResources)
 TEST(StackResource, CreateResourceBadResoureType)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
+    OIC_LOG(INFO, TAG, "Starting CreateResourceBadResoureType test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -376,6 +628,16 @@ TEST(StackResource, CreateResourceBadResoureType)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
+                                            OC_DISCOVERABLE|OC_OBSERVABLE));
+
+    OCResourceHandle handle2;
+    EXPECT_EQ(OC_STACK_INVALID_PARAM, OCCreateResource(&handle2,
+                                            "",
+                                            "core.rw",
+                                            "/a/led",
+                                            0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     EXPECT_EQ(OC_STACK_OK, OCStop());
@@ -384,7 +646,7 @@ TEST(StackResource, CreateResourceBadResoureType)
 TEST(StackResource, CreateResourceGoodResourceType)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
+    OIC_LOG(INFO, TAG, "Starting CreateResourceGoodResourceType test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -393,6 +655,7 @@ TEST(StackResource, CreateResourceGoodResourceType)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     EXPECT_EQ(OC_STACK_OK, OCStop());
@@ -401,7 +664,7 @@ TEST(StackResource, CreateResourceGoodResourceType)
 TEST(StackResource, ResourceTypeName)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting ResourceTypeName test");
+    OIC_LOG(INFO, TAG, "Starting ResourceTypeName test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -410,6 +673,7 @@ TEST(StackResource, ResourceTypeName)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     uint8_t numResourceTypes;
@@ -431,7 +695,7 @@ TEST(StackResource, ResourceTypeName)
 TEST(StackResource, ResourceTypeAttrRepresentation)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
+    OIC_LOG(INFO, TAG, "Starting ResourceTypeAttrRepresentation test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -440,6 +704,7 @@ TEST(StackResource, ResourceTypeAttrRepresentation)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     uint8_t numResourceTypes;
@@ -452,7 +717,7 @@ TEST(StackResource, ResourceTypeAttrRepresentation)
 TEST(StackResource, ResourceTypeInterface)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
+    OIC_LOG(INFO, TAG, "Starting ResourceTypeInterface test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -461,16 +726,19 @@ TEST(StackResource, ResourceTypeInterface)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     uint8_t numResourceInterfaces;
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
-    EXPECT_EQ(1, numResourceInterfaces);
-    const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
+    EXPECT_EQ(2, numResourceInterfaces);
+    const char *resourceInterfaceName1 = OCGetResourceInterfaceName(handle, 0);
+    EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, resourceInterfaceName1);
+    const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
     EXPECT_STREQ("core.rw", resourceInterfaceName);
 
     // try getting resource interface names with an invalid index
-    resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
+    resourceInterfaceName = OCGetResourceInterfaceName(handle, 2);
     EXPECT_STREQ(NULL, resourceInterfaceName);
     // try getting resource interface names with an invalid index
     resourceInterfaceName = OCGetResourceInterfaceName(handle, 10);
@@ -483,8 +751,7 @@ TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 
-    const char * OC_RSRVD_INTERFACE_DEFAULT = "oc.mi.def";
-    OC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
+    OIC_LOG(INFO, TAG, "Starting ResourceDefaultInterfaceAlwaysFirst test");
 
     InitStack(OC_SERVER);
 
@@ -494,6 +761,7 @@ TEST(StackResource, ResourceDefaultInterfaceAlwaysFirst)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
                                         OC_RSRVD_INTERFACE_DEFAULT));
@@ -514,8 +782,7 @@ TEST(StackResource, ResourceDuplicateDefaultInterfaces)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 
-    const char * OC_RSRVD_INTERFACE_DEFAULT = "oc.mi.def";
-    OC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
+    OIC_LOG(INFO, TAG, "Starting ResourceDuplicateDefaultInterfaces test");
 
     InitStack(OC_SERVER);
 
@@ -525,6 +792,7 @@ TEST(StackResource, ResourceDuplicateDefaultInterfaces)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
@@ -546,7 +814,7 @@ TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
 
-    OC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
+    OIC_LOG(INFO, TAG, "Starting ResourceDuplicateInterfaces test");
 
     InitStack(OC_SERVER);
 
@@ -556,6 +824,7 @@ TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle,
@@ -565,7 +834,7 @@ TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
 
     uint8_t numResourceInterfaces;
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
-    EXPECT_EQ(1, numResourceInterfaces);
+    EXPECT_EQ(2, numResourceInterfaces);
 
     EXPECT_EQ(OC_STACK_OK, OCStop());
 }
@@ -573,7 +842,7 @@ TEST(StackResource, ResourceDuplicateNonDefaultInterfaces)
 TEST(StackResource, ResourceTypeInterfaceMethods)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
+    OIC_LOG(INFO, TAG, "Starting ResourceTypeInterfaceMethods test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -582,11 +851,12 @@ TEST(StackResource, ResourceTypeInterfaceMethods)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     uint8_t numResourceInterfaces;
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
-    EXPECT_EQ(1, numResourceInterfaces);
+    EXPECT_EQ(2, numResourceInterfaces);
 
     EXPECT_EQ(OC_STACK_OK, OCStop());
 }
@@ -594,7 +864,7 @@ TEST(StackResource, ResourceTypeInterfaceMethods)
 TEST(StackResource, GetResourceProperties)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting GetResourceProperties test");
+    OIC_LOG(INFO, TAG, "Starting GetResourceProperties test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -603,6 +873,7 @@ TEST(StackResource, GetResourceProperties)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     EXPECT_EQ(OC_ACTIVE|OC_DISCOVERABLE|OC_OBSERVABLE, OCGetResourceProperties(handle));
@@ -614,8 +885,10 @@ TEST(StackResource, GetResourceProperties)
 TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
+    OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResourceBad test");
     InitStack(OC_SERVER);
+    uint8_t numResources = 0;
+    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
 
     OCResourceHandle handle;
     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle,
@@ -623,16 +896,16 @@ TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
                                             "core.rw",
                                             "/a1/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     const char *url = OCGetResourceUri(handle);
     EXPECT_STREQ("/a1/led", url);
 
     //EXPECT_EQ(OC_STACK_INVALID_URI, OCHandleServerRequest(&res, uri, query, req, rsp));
     EXPECT_EQ(OC_STACK_OK, OCDeleteResource(handle));
-    uint8_t numResources = 0;
-    uint8_t numExpectedResources = InitNumExpectedResources();
+    uint8_t numExpectedResources = 0;
 
-    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
+    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
     EXPECT_EQ(numExpectedResources, numResources);
 
     EXPECT_EQ(OC_STACK_OK, OCStop());
@@ -641,7 +914,7 @@ TEST(StackResource, StackTestResourceDiscoverOneResourceBad)
 TEST(StackResource, StackTestResourceDiscoverOneResource)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
+    OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverOneResource test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -650,6 +923,7 @@ TEST(StackResource, StackTestResourceDiscoverOneResource)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     const char *url = OCGetResourceUri(handle);
     EXPECT_STREQ("/a/led", url);
@@ -663,7 +937,7 @@ TEST(StackResource, StackTestResourceDiscoverOneResource)
 TEST(StackResource, StackTestResourceDiscoverManyResources)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
+    OIC_LOG(INFO, TAG, "Starting StackTestResourceDiscoverManyResources test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle1;
@@ -672,6 +946,7 @@ TEST(StackResource, StackTestResourceDiscoverManyResources)
                                             "core.rw",
                                             "/a/led1",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE));
     const char *url = OCGetResourceUri(handle1);
     EXPECT_STREQ("/a/led1", url);
@@ -682,6 +957,7 @@ TEST(StackResource, StackTestResourceDiscoverManyResources)
                                             "core.rw",
                                             "/a/led2",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     url = OCGetResourceUri(handle2);
     EXPECT_STREQ("/a/led2", url);
@@ -695,12 +971,13 @@ TEST(StackResource, StackTestResourceDiscoverManyResources)
                                             "core.rw",
                                             "/a/led3",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     url = OCGetResourceUri(handle3);
     EXPECT_STREQ("/a/led3", url);
 
-    EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, "oc.mi.ll"));
-    EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, "oc.mi.b"));
+    EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_LL));
+    EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle3, OC_RSRVD_INTERFACE_BATCH));
 
     OCResourceHandle handle4;
     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle4,
@@ -708,13 +985,14 @@ TEST(StackResource, StackTestResourceDiscoverManyResources)
                                             "core.rw",
                                             "/a/led4",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE));
     url = OCGetResourceUri(handle4);
     EXPECT_STREQ("/a/led4", url);
 
     EXPECT_EQ(OC_STACK_OK, OCBindResourceTypeToResource(handle4, "core.brightled"));
-    EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, "oc.mi.ll"));
-    EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, "oc.mi.b"));
+    EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_LL));
+    EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle4, OC_RSRVD_INTERFACE_BATCH));
 
     //EXPECT_EQ(OC_STACK_OK, OCHandleServerRequest(&res, uri, query, req, rsp));
 
@@ -724,7 +1002,7 @@ TEST(StackResource, StackTestResourceDiscoverManyResources)
 TEST(StackBind, BindResourceTypeNameBad)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
+    OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameBad test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -733,6 +1011,7 @@ TEST(StackBind, BindResourceTypeNameBad)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     uint8_t numResourceTypes;
@@ -749,7 +1028,7 @@ TEST(StackBind, BindResourceTypeNameBad)
 TEST(StackBind, BindResourceTypeNameGood)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
+    OIC_LOG(INFO, TAG, "Starting BindResourceTypeNameGood test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -758,6 +1037,7 @@ TEST(StackBind, BindResourceTypeNameGood)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     uint8_t numResourceTypes;
@@ -784,7 +1064,7 @@ TEST(StackBind, BindResourceTypeNameGood)
 TEST(StackBind, BindResourceTypeAttribRepGood)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
+    OIC_LOG(INFO, TAG, "Starting BindResourceTypeAttribRepGood test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -793,6 +1073,7 @@ TEST(StackBind, BindResourceTypeAttribRepGood)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     uint8_t numResourceTypes;
@@ -814,7 +1095,7 @@ TEST(StackBind, BindResourceTypeAttribRepGood)
 TEST(StackBind, BindResourceInterfaceNameBad)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
+    OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameBad test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -823,12 +1104,13 @@ TEST(StackBind, BindResourceInterfaceNameBad)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     uint8_t numResourceInterfaces;
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
-    EXPECT_EQ(1, numResourceInterfaces);
-    const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
+    EXPECT_EQ(2, numResourceInterfaces);
+    const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
     EXPECT_STREQ("core.rw", resourceInterfaceName);
 
     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, NULL));
@@ -839,7 +1121,7 @@ TEST(StackBind, BindResourceInterfaceNameBad)
 TEST(StackBind, BindResourceInterfaceNameGood)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
+    OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceNameGood test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -848,19 +1130,20 @@ TEST(StackBind, BindResourceInterfaceNameGood)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     uint8_t numResourceInterfaces;
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
-    EXPECT_EQ(1, numResourceInterfaces);
-    const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 0);
+    EXPECT_EQ(2, numResourceInterfaces);
+    const char *resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
     EXPECT_STREQ("core.rw", resourceInterfaceName);
 
     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
 
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
-    EXPECT_EQ(2, numResourceInterfaces);
-    resourceInterfaceName = OCGetResourceInterfaceName(handle, 1);
+    EXPECT_EQ(3, numResourceInterfaces);
+    resourceInterfaceName = OCGetResourceInterfaceName(handle, 2);
     EXPECT_STREQ("core.r", resourceInterfaceName);
 
     EXPECT_EQ(OC_STACK_OK, OCStop());
@@ -869,7 +1152,7 @@ TEST(StackBind, BindResourceInterfaceNameGood)
 TEST(StackBind, BindResourceInterfaceMethodsBad)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
+    OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsBad test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -878,11 +1161,12 @@ TEST(StackBind, BindResourceInterfaceMethodsBad)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     uint8_t numResourceInterfaces;
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
-    EXPECT_EQ(1, numResourceInterfaces);
+    EXPECT_EQ(2, numResourceInterfaces);
 
     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceInterfaceToResource(handle, 0));
 
@@ -892,7 +1176,7 @@ TEST(StackBind, BindResourceInterfaceMethodsBad)
 TEST(StackBind, BindResourceInterfaceMethodsGood)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
+    OIC_LOG(INFO, TAG, "Starting BindResourceInterfaceMethodsGood test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -901,16 +1185,17 @@ TEST(StackBind, BindResourceInterfaceMethodsGood)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     uint8_t numResourceInterfaces;
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
-    EXPECT_EQ(1, numResourceInterfaces);
+    EXPECT_EQ(2, numResourceInterfaces);
 
     EXPECT_EQ(OC_STACK_OK, OCBindResourceInterfaceToResource(handle, "core.r"));
 
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle, &numResourceInterfaces));
-    EXPECT_EQ(2, numResourceInterfaces);
+    EXPECT_EQ(3, numResourceInterfaces);
 
     EXPECT_EQ(OC_STACK_OK, OCStop());
 }
@@ -918,7 +1203,7 @@ TEST(StackBind, BindResourceInterfaceMethodsGood)
 TEST(StackBind, BindContainedResourceBad)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
+    OIC_LOG(INFO, TAG, "Starting BindContainedResourceBad test");
     InitStack(OC_SERVER);
 
     OCResourceHandle containerHandle;
@@ -927,6 +1212,7 @@ TEST(StackBind, BindContainedResourceBad)
                                             "core.rw",
                                             "/a/kitchen",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     OCResourceHandle handle0;
@@ -935,6 +1221,7 @@ TEST(StackBind, BindContainedResourceBad)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResource(containerHandle, containerHandle));
@@ -947,14 +1234,13 @@ TEST(StackBind, BindContainedResourceBad)
 TEST(StackBind, BindContainedResourceGood)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
+    OIC_LOG(INFO, TAG, "Starting BindContainedResourceGood test");
     InitStack(OC_SERVER);
 
     uint8_t numResources = 0;
-    uint8_t numExpectedResources = InitNumExpectedResources();
+    uint8_t numExpectedResources = 0;
 
-    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
-    EXPECT_EQ(numExpectedResources, numResources);
+    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
 
     OCResourceHandle containerHandle;
     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
@@ -962,6 +1248,7 @@ TEST(StackBind, BindContainedResourceGood)
                                             "core.rw",
                                             "/a/kitchen",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -972,6 +1259,7 @@ TEST(StackBind, BindContainedResourceGood)
                                             "core.rw",
                                             "/a/led0",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -982,6 +1270,7 @@ TEST(StackBind, BindContainedResourceGood)
                                             "core.rw",
                                             "/a/led1",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -992,6 +1281,7 @@ TEST(StackBind, BindContainedResourceGood)
                                             "core.rw",
                                             "/a/led2",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1002,6 +1292,7 @@ TEST(StackBind, BindContainedResourceGood)
                                             "core.rw",
                                             "/a/led3",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1012,6 +1303,7 @@ TEST(StackBind, BindContainedResourceGood)
                                             "core.rw",
                                             "/a/led4",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1022,6 +1314,7 @@ TEST(StackBind, BindContainedResourceGood)
                                             "core.rw",
                                             "/a/led5",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1032,15 +1325,14 @@ TEST(StackBind, BindContainedResourceGood)
     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle2));
     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle3));
     EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle4));
-    EXPECT_EQ(OC_STACK_ERROR, OCBindResource(containerHandle, handle5));
+    EXPECT_EQ(OC_STACK_OK, OCBindResource(containerHandle, handle5));
 
     EXPECT_EQ(handle0, OCGetResourceHandleFromCollection(containerHandle, 0));
     EXPECT_EQ(handle1, OCGetResourceHandleFromCollection(containerHandle, 1));
     EXPECT_EQ(handle2, OCGetResourceHandleFromCollection(containerHandle, 2));
     EXPECT_EQ(handle3, OCGetResourceHandleFromCollection(containerHandle, 3));
     EXPECT_EQ(handle4, OCGetResourceHandleFromCollection(containerHandle, 4));
-
-    EXPECT_EQ(NULL, OCGetResourceHandleFromCollection(containerHandle, 5));
+    EXPECT_EQ(handle5, OCGetResourceHandleFromCollection(containerHandle, 5));
 
     EXPECT_EQ(OC_STACK_OK, OCStop());
 }
@@ -1049,7 +1341,7 @@ TEST(StackBind, BindContainedResourceGood)
 TEST(StackBind, BindEntityHandlerBad)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
+    OIC_LOG(INFO, TAG, "Starting BindEntityHandlerBad test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -1058,9 +1350,10 @@ TEST(StackBind, BindEntityHandlerBad)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
-    EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL));
+    EXPECT_EQ(OC_STACK_INVALID_PARAM, OCBindResourceHandler(NULL, NULL, NULL));
 
     EXPECT_EQ(OC_STACK_OK, OCStop());
 }
@@ -1068,7 +1361,7 @@ TEST(StackBind, BindEntityHandlerBad)
 TEST(StackBind, BindEntityHandlerGood)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
+    OIC_LOG(INFO, TAG, "Starting BindEntityHandlerGood test");
     InitStack(OC_SERVER);
 
     OCResourceHandle handle;
@@ -1077,11 +1370,12 @@ TEST(StackBind, BindEntityHandlerGood)
                                             "core.rw",
                                             "/a/led",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
 
     OCEntityHandler myHandler = entityHandler;
 
-    EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler));
+    EXPECT_EQ(OC_STACK_OK, OCBindResourceHandler(handle, myHandler, NULL));
 
     EXPECT_EQ(myHandler, OCGetResourceHandler(handle));
 
@@ -1091,22 +1385,22 @@ TEST(StackBind, BindEntityHandlerGood)
 TEST(StackResourceAccess, GetResourceByIndex)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
+    OIC_LOG(INFO, TAG, "Starting GetResourceByIndex test");
     InitStack(OC_SERVER);
 
     uint8_t numResources = 0;
-    uint8_t numExpectedResources = InitNumExpectedResources();
-    uint8_t resourceIndex = InitResourceIndex();
-
-    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
-    EXPECT_EQ(numExpectedResources, numResources);
-
+    uint8_t numExpectedResources = 0;
+    uint8_t resourceIndex = 0;
+    uint8_t prevResources = 0;
+    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
+    prevResources = numExpectedResources;
     OCResourceHandle containerHandle;
     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&containerHandle,
                                             "core.led",
                                             "core.rw",
                                             "/a/kitchen",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1117,6 +1411,7 @@ TEST(StackResourceAccess, GetResourceByIndex)
                                             "core.rw",
                                             "/a/led0",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1127,6 +1422,7 @@ TEST(StackResourceAccess, GetResourceByIndex)
                                             "core.rw",
                                             "/a/led1",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1137,6 +1433,7 @@ TEST(StackResourceAccess, GetResourceByIndex)
                                             "core.rw",
                                             "/a/led2",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1147,6 +1444,7 @@ TEST(StackResourceAccess, GetResourceByIndex)
                                             "core.rw",
                                             "/a/led3",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1157,6 +1455,7 @@ TEST(StackResourceAccess, GetResourceByIndex)
                                             "core.rw",
                                             "/a/led4",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1167,10 +1466,11 @@ TEST(StackResourceAccess, GetResourceByIndex)
                                             "core.rw",
                                             "/a/led5",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
-
+    resourceIndex += prevResources;
     EXPECT_EQ(containerHandle, OCGetResourceHandle(resourceIndex));
     EXPECT_EQ(handle0, OCGetResourceHandle(++resourceIndex));
     EXPECT_EQ(handle1, OCGetResourceHandle(++resourceIndex));
@@ -1185,14 +1485,13 @@ TEST(StackResourceAccess, GetResourceByIndex)
 TEST(StackResourceAccess, DeleteHeadResource)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
+    OIC_LOG(INFO, TAG, "Starting DeleteHeadResource test");
     InitStack(OC_SERVER);
 
     uint8_t numResources = 0;
-    uint8_t numExpectedResources = InitNumExpectedResources();
+    uint8_t numExpectedResources = 0;
 
-    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
-    EXPECT_EQ(numExpectedResources, numResources);
+    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
 
     OCResourceHandle handle0;
     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
@@ -1200,6 +1499,7 @@ TEST(StackResourceAccess, DeleteHeadResource)
                                             "core.rw",
                                             "/a/led0",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1214,22 +1514,20 @@ TEST(StackResourceAccess, DeleteHeadResource)
 TEST(StackResourceAccess, DeleteHeadResource2)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
+    OIC_LOG(INFO, TAG, "Starting DeleteHeadResource2 test");
     InitStack(OC_SERVER);
 
     uint8_t numResources = 0;
-    uint8_t numExpectedResources = InitNumExpectedResources();
-    uint8_t resourceIndex = InitResourceIndex();
-
-    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
-    EXPECT_EQ(numExpectedResources, numResources);
+    uint8_t numExpectedResources = 0;
 
+    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
     OCResourceHandle handle0;
     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
                                             "core.led",
                                             "core.rw",
                                             "/a/led0",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1240,6 +1538,7 @@ TEST(StackResourceAccess, DeleteHeadResource2)
                                             "core.rw",
                                             "/a/led1",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1248,7 +1547,7 @@ TEST(StackResourceAccess, DeleteHeadResource2)
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(--numExpectedResources, numResources);
 
-    EXPECT_EQ(handle1, OCGetResourceHandle(resourceIndex));
+    EXPECT_EQ(handle1, OCGetResourceHandle(numResources - 1));
 
     EXPECT_EQ(OC_STACK_OK, OCStop());
 }
@@ -1257,15 +1556,13 @@ TEST(StackResourceAccess, DeleteHeadResource2)
 TEST(StackResourceAccess, DeleteLastResource)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting DeleteLastResource test");
+    OIC_LOG(INFO, TAG, "Starting DeleteLastResource test");
     InitStack(OC_SERVER);
 
     uint8_t numResources = 0;
-    uint8_t numExpectedResources = InitNumExpectedResources();
-    uint8_t resourceIndex = InitResourceIndex();
+    uint8_t numExpectedResources = 0;
 
-    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
-    EXPECT_EQ(numExpectedResources, numResources);
+    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
 
     OCResourceHandle handle0;
     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
@@ -1273,6 +1570,7 @@ TEST(StackResourceAccess, DeleteLastResource)
                                             "core.rw",
                                             "/a/led0",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1283,6 +1581,7 @@ TEST(StackResourceAccess, DeleteLastResource)
                                             "core.rw",
                                             "/a/led1",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1291,7 +1590,7 @@ TEST(StackResourceAccess, DeleteLastResource)
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(--numExpectedResources, numResources);
 
-    EXPECT_EQ(handle0, OCGetResourceHandle(resourceIndex));
+    EXPECT_EQ(handle0, OCGetResourceHandle(numResources - 1));
 
     OCResourceHandle handle2;
     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
@@ -1299,6 +1598,7 @@ TEST(StackResourceAccess, DeleteLastResource)
                                             "core.rw",
                                             "/a/led2",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1309,22 +1609,22 @@ TEST(StackResourceAccess, DeleteLastResource)
 TEST(StackResourceAccess, DeleteMiddleResource)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
+    OIC_LOG(INFO, TAG, "Starting DeleteMiddleResource test");
     InitStack(OC_SERVER);
 
     uint8_t numResources = 0;
-    uint8_t numExpectedResources = InitNumExpectedResources();
+    uint8_t numExpectedResources = 0;
     uint8_t resourceIndex = InitResourceIndex();
 
-    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
-    EXPECT_EQ(numExpectedResources, numResources);
-
+    EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numExpectedResources));
+    resourceIndex = numExpectedResources;
     OCResourceHandle handle0;
     EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle0,
                                             "core.led",
                                             "core.rw",
                                             "/a/led0",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1335,6 +1635,7 @@ TEST(StackResourceAccess, DeleteMiddleResource)
                                             "core.rw",
                                             "/a/led1",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1345,6 +1646,7 @@ TEST(StackResourceAccess, DeleteMiddleResource)
                                             "core.rw",
                                             "/a/led2",
                                             0,
+                                            NULL,
                                             OC_DISCOVERABLE|OC_OBSERVABLE));
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResources(&numResources));
     EXPECT_EQ(++numExpectedResources, numResources);
@@ -1359,82 +1661,87 @@ TEST(StackResourceAccess, DeleteMiddleResource)
     // Make sure the resource elements are still correct
     uint8_t numResourceInterfaces;
     EXPECT_EQ(OC_STACK_OK, OCGetNumberOfResourceInterfaces(handle2, &numResourceInterfaces));
-    EXPECT_EQ(1, numResourceInterfaces);
-    const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 0);
+    EXPECT_EQ(2, numResourceInterfaces);
+    const char *resourceInterfaceName = OCGetResourceInterfaceName(handle2, 1);
     EXPECT_STREQ("core.rw", resourceInterfaceName);
 
     EXPECT_EQ(OC_STACK_OK, OCStop());
 }
 
+TEST(PODTests, OCHeaderOption)
+{
+    EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
+}
+
+TEST(PODTests, OCCallbackData)
+{
+    EXPECT_TRUE(std::is_pod<OCHeaderOption>::value);
+}
+
+TEST(OCDoDirectPairingTests, Nullpeer)
+{
+    EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(NULL, pmSel, &pinNumber, &resultCallback));
+}
+
+TEST(OCDoDirectPairingTests, NullCallback)
+{
+    EXPECT_EQ(OC_STACK_INVALID_CALLBACK,OCDoDirectPairing(&peer, pmSel, &pinNumber, NULL));
+}
 
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-    void parsePresencePayload(char* payload, uint32_t* seqNum, uint32_t* maxAge, char** resType);
-#ifdef __cplusplus
+TEST(OCDoDirectPairingTests, NullpinNumber)
+{
+    EXPECT_EQ(OC_STACK_INVALID_PARAM,OCDoDirectPairing(&peer, pmSel, NULL, &resultCallback));
 }
-#endif // __cplusplus
 
-TEST(StackPresence, ParsePresencePayload)
+TEST(StackResource, MultipleResourcesDiscovery)
 {
     itst::DeadmanTimer killSwitch(SHORT_TEST_TIMEOUT);
-    OC_LOG(INFO, TAG, "Starting ParsePresencePayload test");
-
-    char payload[100];
-    uint32_t seqNum = 0, maxAge = 0;
-    char * resType = NULL;
-
-    //Good Scenario
-    strncpy(payload, "{\"oc\":[100:99:presence]}", sizeof(payload));
-    parsePresencePayload(payload, &seqNum, &maxAge, &resType);
-    EXPECT_TRUE(100 == seqNum);
-    EXPECT_TRUE(99 == maxAge);
-    EXPECT_STREQ("presence", resType);
-    OCFree(resType);
-
-    //Bad Scenario -- should not result in Seg Fault
-    parsePresencePayload(payload, NULL, &maxAge, &resType);
-
-    //Bad Scenario
-    seqNum = 0; maxAge = 0; resType = NULL;
-    strncpy(payload, "{abracadabra}", sizeof(payload));
-    parsePresencePayload(payload, &seqNum, &maxAge, &resType);
-    EXPECT_TRUE(0 == seqNum);
-    EXPECT_TRUE(0 == maxAge);
-    EXPECT_EQ(NULL, resType);
-    OCFree(resType);
-
-    //Bad Scenario
-    seqNum = 0; maxAge = 0; resType = NULL;
-    strncpy(payload, "{\"oc\":[100]}", sizeof(payload));
-    parsePresencePayload(payload, &seqNum, &maxAge, &resType);
-    EXPECT_TRUE(100 == seqNum);
-    EXPECT_TRUE(0 == maxAge);
-    EXPECT_EQ(NULL, resType);
-    OCFree(resType);
-
-    //Bad Scenario
-    seqNum = 0; maxAge = 0; resType = NULL;
-    strncpy(payload, "{\"oc\":[]}", sizeof(payload));
-    parsePresencePayload(payload, &seqNum, &maxAge, &resType);
-    EXPECT_TRUE(0 == seqNum);
-    EXPECT_TRUE(0 == maxAge);
-    EXPECT_EQ(NULL, resType);
-    OCFree(resType);
-
-    //Bad Scenario
-    strncpy(payload, "{:]}", sizeof(payload));
-    parsePresencePayload(payload, &seqNum, &maxAge, &resType);
-    EXPECT_TRUE(0 == seqNum);
-    EXPECT_TRUE(0 == maxAge);
-    EXPECT_EQ(NULL, resType);
-    OCFree(resType);
-
-    //Bad Scenario
-    strncpy(payload, "{:[presence}", sizeof(payload));
-    parsePresencePayload(payload, &seqNum, &maxAge, &resType);
-    EXPECT_TRUE(0 == seqNum);
-    EXPECT_TRUE(0 == maxAge);
-    EXPECT_EQ(NULL, resType);
-    OCFree(resType);
+    OIC_LOG(INFO, TAG, "Starting MultipleResourcesDiscovery test");
+    InitStack(OC_SERVER);
+
+    OCResourceHandle handle1;
+    EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle1,
+                                            "core.led",
+                                            "core.rw",
+                                            "/a/led1",
+                                            0,
+                                            NULL,
+                                            OC_DISCOVERABLE|OC_OBSERVABLE));
+
+    OCResourceHandle handle2;
+    EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle2,
+                                            "core.led",
+                                            "core.rw",
+                                            "/a/led2",
+                                            0,
+                                            NULL,
+                                            OC_DISCOVERABLE|OC_OBSERVABLE));
+    OCResourceHandle handle3;
+    EXPECT_EQ(OC_STACK_OK, OCCreateResource(&handle3,
+                                            "core.led",
+                                            "core.rw",
+                                            "/a/led3",
+                                            0,
+                                            NULL,
+                                            OC_DISCOVERABLE|OC_OBSERVABLE));
+    /* Start a discovery query*/
+    char szQueryUri[256] = "/oic/res?if=oic.if.ll";
+    OCCallbackData cbData;
+    cbData.cb = discoveryCallback;
+    cbData.context = (void*)DEFAULT_CONTEXT_VALUE;
+    cbData.cd = NULL;
+
+    OCDoHandle handle;
+    EXPECT_EQ(OC_STACK_OK, OCDoResource(&handle,
+                                        OC_REST_DISCOVER,
+                                        szQueryUri,
+                                        0,
+                                        0,
+                                        CT_ADAPTER_IP,
+                                        OC_LOW_QOS,
+                                        &cbData,
+                                        NULL,
+                                        0));
+
+    EXPECT_EQ(OC_STACK_OK, OCStop());
 }