Changed if/rt to be space-delimited strings in CBOR encoding

The Spec says that if/rt should be space-delimited values rather than
just an array of strings, so this changes all encodings of if and rt to
be space-delimited.

Also adds some unit tests to validate the defensive nature of this
reading.

Change-Id: Iebd1d5a215a06abb023bb1b33112dac1df3511a1
Signed-off-by: Erich Keane <erich.keane@intel.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/2645
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: Patrick Lankswert <patrick.lankswert@intel.com>

diff --git a/resource/csdk/stack/include/ocpayload.h b/resource/csdk/stack/include/ocpayload.h
index 37d56f9..4cde824 100755 (executable)
--- a/resource/csdk/stack/include/ocpayload.h
+++ b/resource/csdk/stack/include/ocpayload.h
@@ -118,6 +118,9 @@ void OCSecurityPayloadDestroy(OCSecurityPayload* payload);
 void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource* res,
         uint16_t port);
 void OCDiscoveryPayloadAddNewResource(OCDiscoveryPayload* payload, OCResourcePayload* res);
+bool OCResourcePayloadAddResourceType(OCResourcePayload* payload, const char* resourceType);
+bool OCResourcePayloadAddInterface(OCResourcePayload* payload, const char* interface);
+
 size_t OCDiscoveryPayloadGetResourceCount(OCDiscoveryPayload* payload);
 OCResourcePayload* OCDiscoveryPayloadGetResource(OCDiscoveryPayload* payload, size_t index);
 

diff --git a/resource/csdk/stack/src/ocpayload.c b/resource/csdk/stack/src/ocpayload.c
index 6be1ffe..cb3c6d6 100755 (executable)
--- a/resource/csdk/stack/src/ocpayload.c
+++ b/resource/csdk/stack/src/ocpayload.c
@@ -1260,6 +1260,104 @@ void OCDiscoveryPayloadAddResource(OCDiscoveryPayload* payload, const OCResource
     OCDiscoveryPayloadAddNewResource(payload, OCCopyResource(res, port));
 }
 
+bool OCResourcePayloadAddResourceType(OCResourcePayload* payload, const char* resourceType)
+{
+    if (!resourceType)
+    {
+        return false;
+    }
+
+    char* dup = OICStrdup(resourceType);
+
+    if (!dup)
+    {
+        return false;
+    }
+
+    if (!payload->types)
+    {
+        payload->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
+
+        if (!payload->types)
+        {
+            OICFree(dup);
+            return false;
+        }
+
+        payload->types->value = dup;
+        return true;
+    }
+
+    else
+    {
+        OCStringLL* temp = payload->types;
+
+        while(temp->next)
+        {
+            temp = temp->next;
+        }
+
+        temp->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
+        if (!temp->next)
+        {
+            OICFree(dup);
+            return false;
+        }
+
+        temp->next->value = dup;
+        return true;
+    }
+}
+
+bool OCResourcePayloadAddInterface(OCResourcePayload* payload, const char* interface)
+{
+    if (!interface)
+    {
+        return false;
+    }
+
+    char* dup = OICStrdup(interface);
+
+    if (!dup)
+    {
+        return false;
+    }
+
+    if (!payload->interfaces)
+    {
+        payload->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
+
+        if (!payload->interfaces)
+        {
+            OICFree(dup);
+            return false;
+        }
+
+        payload->interfaces->value = dup;
+        return true;
+    }
+
+    else
+    {
+        OCStringLL* temp = payload->interfaces;
+
+        while(temp->next)
+        {
+            temp = temp->next;
+        }
+
+        temp->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
+        if (!temp->next)
+        {
+            OICFree(dup);
+            return false;
+        }
+
+        temp->next->value = dup;
+        return true;
+    }
+}
+
 void OCDiscoveryPayloadAddNewResource(OCDiscoveryPayload* payload, OCResourcePayload* res)
 {
     if(!payload->resources)

diff --git a/resource/csdk/stack/src/ocpayloadconvert.c b/resource/csdk/stack/src/ocpayloadconvert.c
index e838e4d..ae2aaef 100644 (file)
--- a/resource/csdk/stack/src/ocpayloadconvert.c
+++ b/resource/csdk/stack/src/ocpayloadconvert.c
@@ -22,6 +22,7 @@
 #include "platform_features.h"
 #include <stdlib.h>
 #include "oic_malloc.h"
+#include "oic_string.h"
 #include "logger.h"
 #include "ocpayload.h"
 #include "ocrandom.h"
@@ -192,6 +193,35 @@ static int64_t OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t* out
 
 }
 
+static char* OCStringLLJoin(OCStringLL* val)
+{
+    OCStringLL* temp = val;
+    size_t size = strlen(temp->value);
+
+    while (temp->next)
+    {
+        ++size;
+        temp = temp->next;
+        size += strlen(temp->value);
+    }
+
+    char* joinedStr = (char*)OICCalloc(sizeof(char), size + 1);
+
+    if (!joinedStr)
+    {
+        return NULL;
+    }
+
+    OICStrcat(joinedStr, size + 1, val->value);
+    while (val->next)
+    {
+        val = val->next;
+        OICStrcat(joinedStr, size + 1, " ");
+        OICStrcat(joinedStr, size + 1, val->value);
+    }
+    return joinedStr;
+}
+
 static int64_t OCConvertDiscoveryPayload(OCDiscoveryPayload* payload, uint8_t* outPayload,
         size_t* size)
 {
@@ -232,40 +262,40 @@ static int64_t OCConvertDiscoveryPayload(OCDiscoveryPayload* payload, uint8_t* o
             err = err | cbor_encoder_create_map(&map, &propMap, 3);
 
             // Resource Type
+            if (resource->types)
             {
-                CborEncoder rtArray;
-                err = err | cbor_encode_text_string(&propMap, OC_RSRVD_RESOURCE_TYPE,
-                    sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
-                err = err | cbor_encoder_create_array(&propMap, &rtArray, CborIndefiniteLength);
-
-                OCStringLL* rtPtr = resource->types;
-                while(rtPtr)
+                char* joinedTypes = OCStringLLJoin(resource->types);
+                if (joinedTypes)
                 {
-                    err = err | cbor_encode_text_string(&rtArray, rtPtr->value,
-                            strlen(rtPtr->value));
-                    rtPtr = rtPtr->next;
+                    err = err | cbor_encode_text_string(&propMap, OC_RSRVD_RESOURCE_TYPE,
+                            sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
+                    err = err | cbor_encode_text_string(&propMap, joinedTypes,
+                            strlen(joinedTypes));
+                    OICFree(joinedTypes);
+                }
+                else
+                {
+                    return OC_STACK_NO_MEMORY;
                 }
-
-                err = err | cbor_encoder_close_container(&propMap, &rtArray);
             }
-
             // Interface Types
+            if (resource->interfaces)
             {
-                CborEncoder ifArray;
-                err = err | cbor_encode_text_string(&propMap, OC_RSRVD_INTERFACE,
-                        sizeof(OC_RSRVD_INTERFACE) - 1);
-                err = err | cbor_encoder_create_array(&propMap, &ifArray, CborIndefiniteLength);
-                OCStringLL* ifPtr = resource->interfaces;
-
-                while(ifPtr)
+                char* joinedInterfaces = OCStringLLJoin(resource->interfaces);
+                if (joinedInterfaces)
                 {
-                    err = err | cbor_encode_text_string(&ifArray, ifPtr->value,
-                        strlen(ifPtr->value));
-                    ifPtr= ifPtr->next;
+                    err = err | cbor_encode_text_string(&propMap, OC_RSRVD_INTERFACE,
+                            sizeof(OC_RSRVD_INTERFACE) - 1);
+                    err = err | cbor_encode_text_string(&propMap, joinedInterfaces,
+                            strlen(joinedInterfaces));
+                    OICFree(joinedInterfaces);
+                }
+                else
+                {
+                    return OC_STACK_NO_MEMORY;
                 }
-
-                err = err | cbor_encoder_close_container(&propMap, &ifArray);
             }
+
             // Policy
             {
                 CborEncoder policyMap;
@@ -573,34 +603,37 @@ static int64_t OCConvertSingleRepPayload(CborEncoder* parent, const OCRepPayload
         CborEncoder propMap;
         err = err | cbor_encoder_create_map(&map, &propMap, 2);
 
-        CborEncoder curArray;
-        if(payload->types)
+        if (payload->types)
         {
-            err = err | cbor_encode_text_string(&propMap,
-                    OC_RSRVD_RESOURCE_TYPE,
-                    sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
-            err = err | cbor_encoder_create_array(&propMap, &curArray, CborIndefiniteLength);
-            OCStringLL* val = payload->types;
-            while(val)
+            char* joinedTypes = OCStringLLJoin(payload->types);
+            if (joinedTypes)
             {
-                err = err | cbor_encode_text_string(&curArray, val->value, strlen(val->value));
-                val = val->next;
+                err = err | cbor_encode_text_string(&propMap, OC_RSRVD_RESOURCE_TYPE,
+                        sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
+                err = err | cbor_encode_text_string(&propMap, joinedTypes,
+                        strlen(joinedTypes));
+                OICFree(joinedTypes);
+            }
+            else
+            {
+                return OC_STACK_NO_MEMORY;
             }
-            err = err | cbor_encoder_close_container(&propMap, &curArray);
         }
-        if(payload->interfaces)
+        if (payload->interfaces)
         {
-            err = err | cbor_encode_text_string(&propMap,
-                    OC_RSRVD_INTERFACE,
-                    sizeof(OC_RSRVD_INTERFACE) - 1);
-            err = err | cbor_encoder_create_array(&propMap, &curArray, CborIndefiniteLength);
-            OCStringLL* val = payload->interfaces;
-            while(val)
+            char* joinedInterfaces = OCStringLLJoin(payload->interfaces);
+            if (joinedInterfaces)
             {
-                err = err | cbor_encode_text_string(&curArray, val->value, strlen(val->value));
-                val = val->next;
+                err = err | cbor_encode_text_string(&propMap, OC_RSRVD_INTERFACE,
+                        sizeof(OC_RSRVD_INTERFACE) - 1);
+                err = err | cbor_encode_text_string(&propMap, joinedInterfaces,
+                        strlen(joinedInterfaces));
+                OICFree(joinedInterfaces);
+            }
+            else
+            {
+                return OC_STACK_NO_MEMORY;
             }
-            err = err | cbor_encoder_close_container(&propMap, &curArray);
         }
         err = err | cbor_encoder_close_container(&map, &propMap);
     }

diff --git a/resource/csdk/stack/src/ocpayloadparse.c b/resource/csdk/stack/src/ocpayloadparse.c
index e3596da..60472ba 100644 (file)
--- a/resource/csdk/stack/src/ocpayloadparse.c
+++ b/resource/csdk/stack/src/ocpayloadparse.c
@@ -18,6 +18,15 @@
 //
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
+// Defining _POSIX_C_SOURCE macro with 200112L (or greater) as value
+// causes header files to expose definitions
+// corresponding to the POSIX.1-2001 base
+// specification (excluding the XSI extension).
+// For POSIX.1-2001 base specification,
+// Refer http://pubs.opengroup.org/onlinepubs/009695399/
+// Required for strok_r
+#define _POSIX_C_SOURCE 200112L
+#include <string.h>
 #include "ocpayloadcbor.h"
 #include <stdlib.h>
 #include "logger.h"
@@ -25,6 +34,7 @@
 #include "ocstackinternal.h"
 #include "ocpayload.h"
 #include "cbor.h"
+#include "oic_string.h"
 
 #define TAG "OCPayloadParse"
 
@@ -154,6 +164,24 @@ static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, CborValue* a
 
 }
 
+static char* InPlaceStringTrim(char* str)
+{
+    while (str[0] == ' ')
+    {
+        ++str;
+    }
+
+    size_t lastchar = strlen(str);
+
+    while (str[lastchar] == ' ')
+    {
+        str[lastchar] = '\0';
+        --lastchar;
+    }
+
+    return str;
+}
+
 static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue* arrayVal)
 {
     if (!outPayload)
@@ -194,118 +222,76 @@ static OCStackResult OCParseDiscoveryPayload(OCPayload** outPayload, CborValue*
 
         // Prop Tag
         {
-             err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_PROPERTY, &curVal);
+            err = err || cbor_value_map_find_value(arrayVal, OC_RSRVD_PROPERTY, &curVal);
             // ResourceTypes
-            CborValue rtArray;
-             err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_RESOURCE_TYPE, &rtArray);
-
             CborValue rtVal;
-             err = err || cbor_value_enter_container(&rtArray, &rtVal);
+            err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_RESOURCE_TYPE, &rtVal);
 
-            OCStringLL* llPtr = NULL;
-            while(!err && cbor_value_is_text_string(&rtVal))
+            if (!err && cbor_value_is_text_string(&rtVal))
             {
-                if(resource->types == NULL)
-                {
-                    resource->types = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
-                    llPtr = resource->types;
-                    if(!llPtr)
-                    {
-                        OC_LOG(ERROR, TAG, "Memory allocation failed");
-                        OICFree(resource->uri);
-                        OICFree(resource->sid);
-                        OICFree(resource);
-                        OCDiscoveryPayloadDestroy(out);
-                        return OC_STACK_NO_MEMORY;
-                    }
-                }
-                else if(llPtr)
+                char* input = NULL;
+                char* savePtr;
+                err = err || cbor_value_dup_text_string(&rtVal, &input, &len, NULL);
+
+                if (input)
                 {
-                    llPtr->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
-                    llPtr = llPtr->next;
-                    if(!llPtr)
+                    char* curPtr = strtok_r(input, " ", &savePtr);
+
+                    while (curPtr)
                     {
-                        OC_LOG(ERROR, TAG, "Memory allocation failed");
-                        OICFree(resource->uri);
-                        OICFree(resource->sid);
-                        OCFreeOCStringLL(resource->types);
-                        OICFree(resource);
-                        OCDiscoveryPayloadDestroy(out);
-                        return OC_STACK_NO_MEMORY;
+                        char* trimmed = InPlaceStringTrim(curPtr);
+                        if (trimmed[0] !='\0')
+                        {
+                            if (!OCResourcePayloadAddResourceType(resource, trimmed))
+                            {
+                                OICFree(resource->uri);
+                                OICFree(resource->sid);
+                                OCFreeOCStringLL(resource->types);
+                                OICFree(resource);
+                                OCDiscoveryPayloadDestroy(out);
+                                return OC_STACK_NO_MEMORY;
+                            }
+                        }
+                        curPtr = strtok_r(NULL, " ", &savePtr);
                     }
+                    OICFree(input);
                 }
-                else
-                {
-                        OC_LOG(ERROR, TAG, "Unknown state in resource type copying");
-                        OICFree(resource->uri);
-                        OICFree(resource->sid);
-                        OCFreeOCStringLL(resource->types);
-                        OICFree(resource);
-                        OCDiscoveryPayloadDestroy(out);
-                        return OC_STACK_NO_MEMORY;
-                }
-
-                 err = err || cbor_value_dup_text_string(&rtVal, &(llPtr->value), &len, NULL);
-                 err = err || cbor_value_advance(&rtVal);
             }
 
-             err = err || cbor_value_leave_container(&rtArray, &rtVal);
-            //
             // Interface Types
-            CborValue ifArray;
-             err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_INTERFACE, &ifArray);
             CborValue ifVal;
-             err = err || cbor_value_enter_container(&ifArray, &ifVal);
+            err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_INTERFACE, &ifVal);
 
-            llPtr = NULL;
-            while(!err && cbor_value_is_text_string(&ifVal))
+            if (!err && cbor_value_is_text_string(&ifVal))
             {
-                if(resource->interfaces == NULL)
-                {
-                    resource->interfaces = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
-                    llPtr = resource->interfaces;
-                    if(!llPtr)
-                    {
-                        OC_LOG(ERROR, TAG, "Memory allocation failed");
-                        OICFree(resource->uri);
-                        OICFree(resource->sid);
-                        OCFreeOCStringLL(resource->types);
-                        OICFree(resource);
-                        OCDiscoveryPayloadDestroy(out);
-                        return OC_STACK_NO_MEMORY;
-                    }
-                }
-                else if (llPtr)
+                char* input = NULL;
+                char* savePtr;
+                err = err || cbor_value_dup_text_string(&ifVal, &input, &len, NULL);
+
+                if (input)
                 {
-                    llPtr->next = (OCStringLL*)OICCalloc(1, sizeof(OCStringLL));
-                    llPtr = llPtr->next;
-                    if(!llPtr)
+                    char* curPtr = strtok_r(input, " ", &savePtr);
+
+                    while (curPtr)
                     {
-                        OC_LOG(ERROR, TAG, "Memory allocation failed");
-                        OICFree(resource->uri);
-                        OICFree(resource->sid);
-                        OCFreeOCStringLL(resource->types);
-                        OCFreeOCStringLL(resource->interfaces);
-                        OICFree(resource);
-                        OCDiscoveryPayloadDestroy(out);
-                        return OC_STACK_NO_MEMORY;
+                        char* trimmed = InPlaceStringTrim(curPtr);
+                        if (trimmed[0] !='\0')
+                        {
+                            if (!OCResourcePayloadAddInterface(resource, trimmed))
+                            {
+                                OICFree(resource->uri);
+                                OICFree(resource->sid);
+                                OCFreeOCStringLL(resource->types);
+                                OICFree(resource);
+                                OCDiscoveryPayloadDestroy(out);
+                                return OC_STACK_NO_MEMORY;
+                            }
+                        }
+                        curPtr = strtok_r(NULL, " ", &savePtr);
                     }
+                    OICFree(input);
                 }
-                else
-                {
-                        OC_LOG(ERROR, TAG, "Unknown state in resource interfaces copying");
-                        OICFree(resource->uri);
-                        OICFree(resource->sid);
-                        OCFreeOCStringLL(resource->types);
-                        OICFree(resource);
-                        OCDiscoveryPayloadDestroy(out);
-                        return OC_STACK_NO_MEMORY;
-                }
-
-                 err = err || cbor_value_dup_text_string(&ifVal, &(llPtr->value), &len, NULL);
-                 err = err || cbor_value_advance(&ifVal);
             }
-             err = err || cbor_value_leave_container(&ifArray, &ifVal);
 
             // Policy
             {
@@ -906,42 +892,58 @@ static bool OCParseSingleRepPayload(OCRepPayload** outPayload, CborValue* repPar
     err = err || cbor_value_map_find_value(repParent, OC_RSRVD_PROPERTY, &curVal);
     if(cbor_value_is_valid(&curVal))
     {
-        CborValue insidePropArray = {0};
+        CborValue insidePropValue = {0};
         err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_RESOURCE_TYPE,
-                &insidePropArray);
+                &insidePropValue);
 
-        if(cbor_value_is_array(&insidePropArray))
+        if(cbor_value_is_text_string(&insidePropValue))
         {
-            CborValue rtArray;
-            err = err || cbor_value_enter_container(&insidePropArray, &rtArray);
+            char* allRt = NULL;
+            err = err || cbor_value_dup_text_string(&insidePropValue, &allRt, &len, NULL);
+
+            char* savePtr;
 
-            while(!err && cbor_value_is_valid(&rtArray))
+            if (allRt)
             {
-                char* curRt;
-                err = err || cbor_value_dup_text_string(&rtArray, &curRt, &len, NULL);
-                err = err || cbor_value_advance(&rtArray);
-                OCRepPayloadAddResourceTypeAsOwner(curPayload, curRt);
-            }
+                char* curPtr = strtok_r(allRt, " ", &savePtr);
 
-            err = err || cbor_value_leave_container(&insidePropArray, &rtArray);
+                while (curPtr)
+                {
+                    char* trimmed = InPlaceStringTrim(curPtr);
+                    if (trimmed[0] != '\0')
+                    {
+                        OCRepPayloadAddResourceType(curPayload, curPtr);
+                    }
+                    curPtr = strtok_r(NULL, " ", &savePtr);
+                }
+            }
+            OICFree(allRt);
         }
 
-        err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_INTERFACE, &insidePropArray);
+        err = err || cbor_value_map_find_value(&curVal, OC_RSRVD_INTERFACE, &insidePropValue);
 
-        if(cbor_value_is_array(&insidePropArray))
+        if(cbor_value_is_text_string(&insidePropValue))
         {
-            CborValue ifArray;
-            err = err || cbor_value_enter_container(&insidePropArray, &ifArray);
+            char* allIf = NULL;
+            err = err || cbor_value_dup_text_string(&insidePropValue, &allIf, &len, NULL);
 
-            while(!err && cbor_value_is_valid(&ifArray))
+            char* savePtr;
+
+            if (allIf)
             {
-                char* curIf;
-                err = err || cbor_value_dup_text_string(&ifArray, &curIf, &len, NULL);
-                err = err || cbor_value_advance(&ifArray);
-                OCRepPayloadAddInterfaceAsOwner(curPayload, curIf);
-            }
+                char* curPtr = strtok_r(allIf, " ", &savePtr);
 
-            err = err || cbor_value_leave_container(&insidePropArray, &ifArray);
+                while (curPtr)
+                {
+                    char* trimmed = InPlaceStringTrim(curPtr);
+                    if (trimmed[0] != '\0')
+                    {
+                        OCRepPayloadAddInterface(curPayload, curPtr);
+                    }
+                    curPtr = strtok_r(NULL, " ", &savePtr);
+                }
+            }
+            OICFree(allIf);
         }
     }
 

diff --git a/resource/unittests/OCRepresentationEncodingTest.cpp b/resource/unittests/OCRepresentationEncodingTest.cpp
index dab9c74..c679495 100644 (file)
--- a/resource/unittests/OCRepresentationEncodingTest.cpp
+++ b/resource/unittests/OCRepresentationEncodingTest.cpp
@@ -25,6 +25,7 @@
 #include <ocpayload.h>
 #include <ocpayloadcbor.h>
 #include <oic_malloc.h>
+#include <oic_string.h>
 
 namespace OC
 {
@@ -627,4 +628,518 @@ namespace OCRepresentationEncodingTest
         EXPECT_EQ(objarr, objarr2);
         OCPayloadDestroy(cparsed);
     }
+
+    TEST(DiscoveryRTandIF, SingleItemNormal)
+    {
+        OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
+        OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
+        payload->resources = resource;
+
+        OCResourcePayloadAddResourceType(resource, "rt.singleitem");
+        OCResourcePayloadAddInterface(resource, "if.singleitem");
+        resource->uri = OICStrdup("/uri/thing");
+        resource->sid = (uint8_t*)OICMalloc(16);
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
+                    cborData, cborSize));
+
+        EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
+        OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
+
+        EXPECT_EQ(NULL, parsedResource->next);
+
+        EXPECT_EQ(NULL, parsedResource->types->next);
+        EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
+        EXPECT_EQ(NULL, parsedResource->interfaces->next);
+        EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
+
+        OICFree(cborData);
+        OCPayloadDestroy(cparsed);
+        OCDiscoveryPayloadDestroy(payload);
+    }
+
+    TEST(DiscoveryRTandIF, SingleItemFrontTrim)
+    {
+        OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
+        OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
+        payload->resources = resource;
+
+        OCResourcePayloadAddResourceType(resource, "    rt.singleitem");
+        OCResourcePayloadAddInterface(resource, "    if.singleitem");
+        resource->uri = OICStrdup("/uri/thing");
+        resource->sid = (uint8_t*)OICMalloc(16);
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
+                    cborData, cborSize));
+
+        EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
+        OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
+
+        EXPECT_EQ(NULL, parsedResource->next);
+
+        EXPECT_EQ(NULL, parsedResource->types->next);
+        EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
+        EXPECT_EQ(NULL, parsedResource->interfaces->next);
+        EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
+
+        OICFree(cborData);
+        OCPayloadDestroy(cparsed);
+        OCDiscoveryPayloadDestroy(payload);
+    }
+    TEST(DiscoveryRTandIF, SingleItemBackTrim)
+    {
+        OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
+        OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
+        payload->resources = resource;
+
+        OCResourcePayloadAddResourceType(resource, "rt.singleitem    ");
+        OCResourcePayloadAddInterface(resource, "if.singleitem    ");
+        resource->uri = OICStrdup("/uri/thing");
+        resource->sid = (uint8_t*)OICMalloc(16);
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
+                    cborData, cborSize));
+
+        EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
+        OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
+
+        EXPECT_EQ(NULL, parsedResource->next);
+
+        EXPECT_EQ(NULL, parsedResource->types->next);
+        EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
+        EXPECT_EQ(NULL, parsedResource->interfaces->next);
+        EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
+
+        OICFree(cborData);
+        OCPayloadDestroy(cparsed);
+        OCDiscoveryPayloadDestroy(payload);
+    }
+    TEST(DiscoveryRTandIF, SingleItemBothTrim)
+    {
+        OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
+        OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
+        payload->resources = resource;
+
+        OCResourcePayloadAddResourceType(resource, "    rt.singleitem    ");
+        OCResourcePayloadAddInterface(resource, "    if.singleitem     ");
+        resource->uri = OICStrdup("/uri/thing");
+        resource->sid = (uint8_t*)OICMalloc(16);
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
+                    cborData, cborSize));
+
+        EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
+        OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
+
+        EXPECT_EQ(NULL, parsedResource->next);
+
+        EXPECT_EQ(NULL, parsedResource->types->next);
+        EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
+        EXPECT_EQ(NULL, parsedResource->interfaces->next);
+        EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
+
+        OICFree(cborData);
+        OCPayloadDestroy(cparsed);
+        OCDiscoveryPayloadDestroy(payload);
+    }
+    TEST(DiscoveryRTandIF, MultiItemsNormal)
+    {
+        OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
+        OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
+        payload->resources = resource;
+
+        OCResourcePayloadAddResourceType(resource, "rt.firstitem");
+        OCResourcePayloadAddResourceType(resource, "rt.seconditem");
+        OCResourcePayloadAddInterface(resource, "if.firstitem");
+        OCResourcePayloadAddInterface(resource, "if.seconditem");
+        resource->uri = OICStrdup("/uri/thing");
+        resource->sid = (uint8_t*)OICMalloc(16);
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
+                    cborData, cborSize));
+
+        EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
+        OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
+
+        EXPECT_EQ(NULL, parsedResource->next);
+
+        EXPECT_EQ(NULL, parsedResource->types->next->next);
+        EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
+        EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
+        EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
+        EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
+        EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
+
+        OICFree(cborData);
+        OCPayloadDestroy(cparsed);
+        OCDiscoveryPayloadDestroy(payload);
+    }
+    TEST(DiscoveryRTandIF, MultiItemExtraLeadSpaces)
+    {
+        OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
+        OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
+        payload->resources = resource;
+
+        OCResourcePayloadAddResourceType(resource, "  rt.firstitem");
+        OCResourcePayloadAddResourceType(resource, "  rt.seconditem");
+        OCResourcePayloadAddInterface(resource, "  if.firstitem");
+        OCResourcePayloadAddInterface(resource, "  if.seconditem");
+        resource->uri = OICStrdup("/uri/thing");
+        resource->sid = (uint8_t*)OICMalloc(16);
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
+                    cborData, cborSize));
+
+        EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
+        OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
+
+        EXPECT_EQ(NULL, parsedResource->next);
+
+        EXPECT_EQ(NULL, parsedResource->types->next->next);
+        EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
+        EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
+        EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
+        EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
+        EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
+
+        OICFree(cborData);
+        OCPayloadDestroy(cparsed);
+        OCDiscoveryPayloadDestroy(payload);
+    }
+    TEST(DiscoveryRTandIF, MultiItemExtraTrailSpaces)
+    {
+        OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
+        OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
+        payload->resources = resource;
+
+        OCResourcePayloadAddResourceType(resource, "rt.firstitem  ");
+        OCResourcePayloadAddResourceType(resource, "rt.seconditem  ");
+        OCResourcePayloadAddInterface(resource, "if.firstitem  ");
+        OCResourcePayloadAddInterface(resource, "if.seconditem  ");
+        resource->uri = OICStrdup("/uri/thing");
+        resource->sid = (uint8_t*)OICMalloc(16);
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
+                    cborData, cborSize));
+
+        EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
+        OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
+
+        EXPECT_EQ(NULL, parsedResource->next);
+
+        EXPECT_EQ(NULL, parsedResource->types->next->next);
+        EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
+        EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
+        EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
+        EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
+        EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
+
+        OICFree(cborData);
+        OCPayloadDestroy(cparsed);
+        OCDiscoveryPayloadDestroy(payload);
+    }
+    TEST(DiscoveryRTandIF, MultiItemBothSpaces)
+    {
+        OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
+        OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
+        payload->resources = resource;
+
+        OCResourcePayloadAddResourceType(resource, "  rt.firstitem  ");
+        OCResourcePayloadAddResourceType(resource, "  rt.seconditem  ");
+        OCResourcePayloadAddInterface(resource, "  if.firstitem  ");
+        OCResourcePayloadAddInterface(resource, "  if.seconditem  ");
+        resource->uri = OICStrdup("/uri/thing");
+        resource->sid = (uint8_t*)OICMalloc(16);
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
+                    cborData, cborSize));
+
+        EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
+        OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
+
+        EXPECT_EQ(NULL, parsedResource->next);
+
+        EXPECT_EQ(NULL, parsedResource->types->next->next);
+        EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
+        EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
+        EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
+        EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
+        EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
+
+        OICFree(cborData);
+        OCPayloadDestroy(cparsed);
+        OCDiscoveryPayloadDestroy(payload);
+    }
+    TEST(RepresentationEncodingRTandIF, SingleItemNormal)
+    {
+        OCRepPayload* payload = OCRepPayloadCreate();
+        OCRepPayloadSetUri(payload, "/this/uri");
+        OCRepPayloadAddResourceType(payload, "rt.firstitem");
+        OCRepPayloadAddInterface(payload, "if.firstitem");
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
+                    cborData, cborSize));
+
+        OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
+
+        EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
+        EXPECT_EQ(NULL, parsedPayload->types->next);
+        EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
+        EXPECT_EQ(NULL, parsedPayload->interfaces->next);
+
+
+        OICFree(cborData);
+        OCRepPayloadDestroy(payload);
+        OCPayloadDestroy(cparsed);
+    }
+    TEST(RepresentationEncodingRTandIF, SingleItemFrontTrim)
+    {
+        OCRepPayload* payload = OCRepPayloadCreate();
+        OCRepPayloadSetUri(payload, "/this/uri");
+        OCRepPayloadAddResourceType(payload, "  rt.firstitem");
+        OCRepPayloadAddInterface(payload, "  if.firstitem");
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
+                    cborData, cborSize));
+
+        OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
+
+        EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
+        EXPECT_EQ(NULL, parsedPayload->types->next);
+        EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
+        EXPECT_EQ(NULL, parsedPayload->interfaces->next);
+
+
+        OICFree(cborData);
+        OCRepPayloadDestroy(payload);
+        OCPayloadDestroy(cparsed);
+    }
+    TEST(RepresentationEncodingRTandIF, SingleItemBackTrim)
+    {
+        OCRepPayload* payload = OCRepPayloadCreate();
+        OCRepPayloadSetUri(payload, "/this/uri");
+        OCRepPayloadAddResourceType(payload, "rt.firstitem  ");
+        OCRepPayloadAddInterface(payload, "if.firstitem  ");
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
+                    cborData, cborSize));
+
+        OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
+
+        EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
+        EXPECT_EQ(NULL, parsedPayload->types->next);
+        EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
+        EXPECT_EQ(NULL, parsedPayload->interfaces->next);
+
+
+        OICFree(cborData);
+        OCRepPayloadDestroy(payload);
+        OCPayloadDestroy(cparsed);
+    }
+    TEST(RepresentationEncodingRTandIF, SingleItemBothTrim)
+    {
+        OCRepPayload* payload = OCRepPayloadCreate();
+        OCRepPayloadSetUri(payload, "/this/uri");
+        OCRepPayloadAddResourceType(payload, "  rt.firstitem  ");
+        OCRepPayloadAddInterface(payload, "  if.firstitem  ");
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
+                    cborData, cborSize));
+
+        OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
+
+        EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
+        EXPECT_EQ(NULL, parsedPayload->types->next);
+        EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
+        EXPECT_EQ(NULL, parsedPayload->interfaces->next);
+
+
+        OICFree(cborData);
+        OCRepPayloadDestroy(payload);
+        OCPayloadDestroy(cparsed);
+    }
+    TEST(RepresentationEncodingRTandIF, MultiItemsNormal)
+    {
+        OCRepPayload* payload = OCRepPayloadCreate();
+        OCRepPayloadSetUri(payload, "/this/uri");
+        OCRepPayloadAddResourceType(payload, "rt.firstitem");
+        OCRepPayloadAddResourceType(payload, "rt.seconditem");
+        OCRepPayloadAddInterface(payload, "if.firstitem");
+        OCRepPayloadAddInterface(payload, "if.seconditem");
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
+                    cborData, cborSize));
+
+        OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
+
+        EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
+        EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
+        EXPECT_EQ(NULL, parsedPayload->types->next->next);
+        EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
+        EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
+        EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
+
+
+        OICFree(cborData);
+        OCRepPayloadDestroy(payload);
+        OCPayloadDestroy(cparsed);
+    }
+    TEST(RepresentationEncodingRTandIF, MultiItemExtraLeadSpaces)
+    {
+        OCRepPayload* payload = OCRepPayloadCreate();
+        OCRepPayloadSetUri(payload, "/this/uri");
+        OCRepPayloadAddResourceType(payload, "  rt.firstitem");
+        OCRepPayloadAddResourceType(payload, "  rt.seconditem");
+        OCRepPayloadAddInterface(payload, "  if.firstitem");
+        OCRepPayloadAddInterface(payload, "  if.seconditem");
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
+                    cborData, cborSize));
+
+        OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
+
+        EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
+        EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
+        EXPECT_EQ(NULL, parsedPayload->types->next->next);
+        EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
+        EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
+        EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
+
+
+        OICFree(cborData);
+        OCRepPayloadDestroy(payload);
+        OCPayloadDestroy(cparsed);
+    }
+    TEST(RepresentationEncodingRTandIF, MultiItemExtraTrailSpaces)
+    {
+        OCRepPayload* payload = OCRepPayloadCreate();
+        OCRepPayloadSetUri(payload, "/this/uri");
+        OCRepPayloadAddResourceType(payload, "rt.firstitem  ");
+        OCRepPayloadAddResourceType(payload, "rt.seconditem  ");
+        OCRepPayloadAddInterface(payload, "if.firstitem  ");
+        OCRepPayloadAddInterface(payload, "if.seconditem  ");
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
+                    cborData, cborSize));
+
+        OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
+
+        EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
+        EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
+        EXPECT_EQ(NULL, parsedPayload->types->next->next);
+        EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
+        EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
+        EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
+
+
+        OICFree(cborData);
+        OCRepPayloadDestroy(payload);
+        OCPayloadDestroy(cparsed);
+    }
+    TEST(RepresentationEncodingRTandIF, MultiItemExtraMiddleSpaces)
+    {
+        OCRepPayload* payload = OCRepPayloadCreate();
+        OCRepPayloadSetUri(payload, "/this/uri");
+        OCRepPayloadAddResourceType(payload, "  rt.firstitem  ");
+        OCRepPayloadAddResourceType(payload, "  rt.seconditem  ");
+        OCRepPayloadAddInterface(payload, "  if.firstitem  ");
+        OCRepPayloadAddInterface(payload, "  if.seconditem  ");
+
+        uint8_t* cborData;
+        size_t cborSize;
+        OCPayload* cparsed;
+
+        EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
+        EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
+                    cborData, cborSize));
+
+        OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
+
+        EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
+        EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
+        EXPECT_EQ(NULL, parsedPayload->types->next->next);
+        EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
+        EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
+        EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
+
+
+        OICFree(cborData);
+        OCRepPayloadDestroy(payload);
+        OCPayloadDestroy(cparsed);
+    }
 }