resource/unittests/OCRepresentationEncodingTest.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Intel Mobile Communications GmbH All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include <gtest/gtest.h>
  22 #include <OCApi.h>
  23 #include <OCRepresentation.h>
  24 #include <octypes.h>
  25 #include <ocpayload.h>
  26 #include <ocpayloadcbor.h>
  27 #include <oic_malloc.h>
  28 #include <oic_string.h>
  29 #include "payload_logging.h"
  30
  31 namespace OC
  32 {
  33     bool operator==(const OC::NullType&, const OC::NullType&)
  34     {
  35         return true;
  36     }
  37
  38     bool operator==(const OC::OCRepresentation& lhs, const OC::OCRepresentation& rhs)
  39     {
  40         return lhs.getUri() == rhs.getUri() &&
  41             lhs.getChildren() == rhs.getChildren() &&
  42             lhs.getResourceInterfaces() == rhs.getResourceInterfaces() &&
  43             lhs.getResourceTypes() == rhs.getResourceTypes() &&
  44             lhs.m_values == rhs.m_values;
  45     }
  46 }
  47 // these tests validate the OCRepresentation->OCPayload, OCPayload->CBOR,
  48 // CBOR->OCPayload and OCPayload->OCRepresentation conversions
  49 namespace OCRepresentationEncodingTest
  50 {
  51     static const uint8_t sid1[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
  52     static const char devicename1[] = "device name";
  53     static const char specver1[] = "spec version";
  54     static const char dmver1[] = "data model version";
  55     // Device Payloads
  56     TEST(DeviceDiscoveryEncoding, Normal)
  57     {
  58         OCDevicePayload* device = OCDevicePayloadCreate(
  59                 sid1,
  60                 devicename1,
  61                 specver1,
  62                 dmver1);
  63
  64         EXPECT_STREQ(devicename1, device->deviceName);
  65         EXPECT_STREQ(specver1, device->specVersion);
  66         EXPECT_STREQ(dmver1, device->dataModelVersion);
  67         EXPECT_EQ(PAYLOAD_TYPE_DEVICE, ((OCPayload*)device)->type);
  68
  69         for (uint8_t i = 1; i <= sizeof(sid1); ++i)
  70         {
  71             EXPECT_EQ(i, sid1[i - 1]);
  72         }
  73
  74         uint8_t* cborData;
  75         size_t cborSize;
  76         OCPayload* parsedDevice;
  77         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)device, &cborData, &cborSize));
  78         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedDevice, PAYLOAD_TYPE_DEVICE,
  79                     cborData, cborSize));
  80         OICFree(cborData);
  81
  82         EXPECT_STREQ(device->deviceName, ((OCDevicePayload*)parsedDevice)->deviceName);
  83         EXPECT_STREQ(device->specVersion, ((OCDevicePayload*)parsedDevice)->specVersion);
  84         EXPECT_STREQ(device->dataModelVersion, ((OCDevicePayload*)parsedDevice)->dataModelVersion);
  85         EXPECT_EQ(device->base.type, ((OCDevicePayload*)parsedDevice)->base.type);
  86
  87         OCPayloadDestroy((OCPayload*)device);
  88
  89         OC::MessageContainer mc;
  90         mc.setPayload(parsedDevice);
  91         EXPECT_EQ(1u, mc.representations().size());
  92         const OC::OCRepresentation& r = mc.representations()[0];
  93         EXPECT_STREQ(devicename1, r.getValue<std::string>(OC_RSRVD_DEVICE_NAME).c_str());
  94         EXPECT_STREQ(specver1, r.getValue<std::string>(OC_RSRVD_SPEC_VERSION).c_str());
  95         EXPECT_STREQ(dmver1, r.getValue<std::string>(OC_RSRVD_DATA_MODEL_VERSION).c_str());
  96
  97         OCPayloadDestroy(parsedDevice);
  98     }
  99
 100     static const char uri1[] = "/testuri";
 101     static char pfid1[] = "pfid";
 102     static char mfgnm1[] = "mfgnm";
 103     static char mfgurl1[] = "mfgurl";
 104     static char modelnum1[] = "modelnum";
 105     static char dom1[] = "dom";
 106     static char pfver1[] = "pfver";
 107     static char osver1[] = "osver";
 108     static char hwver1[] = "hwver";
 109     static char fwver1[] = "fwver";
 110     static char url1[] = "url";
 111     static char time1[] = "time";
 112
 113     // Platform Payloads
 114     TEST(PlatformDiscoveryEncoding, Normal)
 115     {
 116         OCPlatformInfo info {pfid1, mfgnm1, mfgurl1, modelnum1, dom1, pfver1, osver1, hwver1,
 117             fwver1, url1, time1};
 118         OCPlatformPayload* platform = OCPlatformPayloadCreate(&info);
 119         EXPECT_EQ(PAYLOAD_TYPE_PLATFORM, ((OCPayload*)platform)->type);
 120         EXPECT_STREQ(pfid1, platform->info.platformID);
 121         EXPECT_STREQ(mfgnm1, platform->info.manufacturerName);
 122         EXPECT_STREQ(mfgurl1, platform->info.manufacturerUrl);
 123         EXPECT_STREQ(modelnum1, platform->info.modelNumber);
 124         EXPECT_STREQ(dom1, platform->info.dateOfManufacture);
 125         EXPECT_STREQ(pfver1, platform->info.platformVersion);
 126         EXPECT_STREQ(osver1, platform->info.operatingSystemVersion);
 127         EXPECT_STREQ(hwver1, platform->info.hardwareVersion);
 128         EXPECT_STREQ(fwver1, platform->info.firmwareVersion);
 129         EXPECT_STREQ(url1, platform->info.supportUrl);
 130         EXPECT_STREQ(time1, platform->info.systemTime);
 131
 132         uint8_t* cborData;
 133         size_t cborSize;
 134         OCPayload* parsedPlatform;
 135         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)platform, &cborData, &cborSize));
 136         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedPlatform, PAYLOAD_TYPE_PLATFORM,
 137                     cborData, cborSize));
 138         OICFree(cborData);
 139
 140         EXPECT_EQ(platform->base.type, ((OCPlatformPayload*)parsedPlatform)->base.type);
 141         OCPlatformPayload* platform2 = (OCPlatformPayload*)parsedPlatform;
 142         EXPECT_STREQ(platform->info.platformID, platform2->info.platformID);
 143         EXPECT_STREQ(platform->info.manufacturerName, platform->info.manufacturerName);
 144         EXPECT_STREQ(platform->info.manufacturerUrl, platform->info.manufacturerUrl);
 145         EXPECT_STREQ(platform->info.modelNumber, platform->info.modelNumber);
 146         EXPECT_STREQ(platform->info.dateOfManufacture, platform->info.dateOfManufacture);
 147         EXPECT_STREQ(platform->info.platformVersion, platform->info.platformVersion);
 148         EXPECT_STREQ(platform->info.operatingSystemVersion, platform->info.operatingSystemVersion);
 149         EXPECT_STREQ(platform->info.hardwareVersion, platform->info.hardwareVersion);
 150         EXPECT_STREQ(platform->info.firmwareVersion, platform->info.firmwareVersion);
 151         EXPECT_STREQ(platform->info.supportUrl, platform->info.supportUrl);
 152         EXPECT_STREQ(platform->info.systemTime, platform2->info.systemTime);
 153
 154         OCPayloadDestroy((OCPayload*)platform);
 155
 156         OC::MessageContainer mc;
 157         mc.setPayload(parsedPlatform);
 158         EXPECT_EQ(1u, mc.representations().size());
 159         const OC::OCRepresentation& r = mc.representations()[0];
 160         EXPECT_STREQ(pfid1, r.getValue<std::string>(OC_RSRVD_PLATFORM_ID).c_str());
 161         EXPECT_STREQ(mfgnm1, r.getValue<std::string>(OC_RSRVD_MFG_NAME).c_str());
 162         EXPECT_STREQ(mfgurl1, r.getValue<std::string>(OC_RSRVD_MFG_URL).c_str());
 163         EXPECT_STREQ(modelnum1, r.getValue<std::string>(OC_RSRVD_MODEL_NUM).c_str());
 164         EXPECT_STREQ(dom1, r.getValue<std::string>(OC_RSRVD_MFG_DATE).c_str());
 165         EXPECT_STREQ(pfver1, r.getValue<std::string>(OC_RSRVD_PLATFORM_VERSION).c_str());
 166         EXPECT_STREQ(osver1, r.getValue<std::string>(OC_RSRVD_OS_VERSION).c_str());
 167         EXPECT_STREQ(hwver1, r.getValue<std::string>(OC_RSRVD_HARDWARE_VERSION).c_str());
 168         EXPECT_STREQ(fwver1, r.getValue<std::string>(OC_RSRVD_FIRMWARE_VERSION).c_str());
 169         EXPECT_STREQ(url1, r.getValue<std::string>(OC_RSRVD_SUPPORT_URL).c_str());
 170         EXPECT_STREQ(time1, r.getValue<std::string>(OC_RSRVD_SYSTEM_TIME).c_str());
 171
 172         OCPayloadDestroy(parsedPlatform);
 173     }
 174     TEST(PresencePayload, Normal)
 175     {
 176         uint32_t maxAge = 0;
 177         uint32_t sequenceNumber = 0;
 178         OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE;
 179         OCPresencePayload *presence = OCPresencePayloadCreate(sequenceNumber, maxAge, trigger, uri1);
 180
 181         uint8_t* cborData;
 182         size_t cborSize;
 183         OCPayload* cparsed;
 184         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)presence, &cborData, &cborSize));
 185         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_PRESENCE,
 186                     cborData, cborSize));
 187         OCPayloadDestroy((OCPayload*)presence);
 188         OICFree(cborData);
 189
 190         OCPresencePayload* parsed = ((OCPresencePayload*)cparsed);
 191         EXPECT_EQ(sequenceNumber, parsed->sequenceNumber);
 192         EXPECT_EQ(maxAge, parsed->maxAge);
 193         EXPECT_EQ(trigger, parsed->trigger);
 194         EXPECT_STREQ(uri1, parsed->resourceType);
 195
 196         OCPayloadDestroy(cparsed);
 197     }
 198     // Representation Payloads
 199     TEST(RepresentationEncoding, BaseAttributeTypes)
 200     {
 201         OC::OCRepresentation startRep;
 202         startRep.setNULL("NullAttr");
 203         startRep.setValue("IntAttr", 77);
 204         startRep.setValue("DoubleAttr", 3.333);
 205         startRep.setValue("BoolAttr", true);
 206         startRep.setValue("StringAttr", std::string("String attr"));
 207         OC::MessageContainer mc1;
 208         mc1.addRepresentation(startRep);
 209
 210         OCRepPayload* cstart = mc1.getPayload();
 211         EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
 212
 213         uint8_t* cborData;
 214         size_t cborSize;
 215         OCPayload* cparsed;
 216         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
 217         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
 218                     cborData, cborSize));
 219         OCPayloadDestroy((OCPayload*)cstart);
 220         OICFree(cborData);
 221
 222         OC::MessageContainer mc2;
 223         mc2.setPayload(cparsed);
 224         EXPECT_EQ(1u, mc2.representations().size());
 225         const OC::OCRepresentation& r = mc2.representations()[0];
 226
 227         EXPECT_TRUE(r.isNULL("NullAttr"));
 228         EXPECT_EQ(77, r.getValue<int>("IntAttr"));
 229         EXPECT_EQ(3.333, r.getValue<double>("DoubleAttr"));
 230         EXPECT_EQ(true, r.getValue<bool>("BoolAttr"));
 231         EXPECT_STREQ("String attr", r.getValue<std::string>("StringAttr").c_str());
 232
 233         OCPayloadDestroy(cparsed);
 234     }
 235
 236     TEST(RepresentationEncoding, RepAttributeEmpty)
 237     {
 238         OC::OCRepresentation startRep;
 239         std::vector<int> iarr {};
 240         startRep["iarr"] = {};
 241
 242         OC::MessageContainer mc1;
 243         mc1.addRepresentation(startRep);
 244
 245         OCRepPayload* cstart = mc1.getPayload();
 246         EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
 247
 248         uint8_t *cborData = NULL;
 249         size_t cborSize = 0;
 250         OCPayload *cparsed = NULL;
 251         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
 252         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
 253                     cborData, cborSize));
 254         OCPayloadDestroy((OCPayload*)cstart);
 255         OICFree(cborData);
 256
 257         OC::MessageContainer mc2;
 258         mc2.setPayload(cparsed);
 259         EXPECT_EQ(1u, mc2.representations().size());
 260         const OC::OCRepresentation& r = mc2.representations()[0];
 261
 262         std::vector<int> iarr2 = r["iarr"];
 263
 264         EXPECT_EQ(iarr, iarr2);
 265         OCPayloadDestroy(cparsed);
 266     }
 267
 268     TEST(RepresentationEncoding, RepAttribute)
 269     {
 270         OC::OCRepresentation startRep;
 271         OC::OCRepresentation subRep;
 272         subRep.setNULL("NullAttr");
 273         subRep.setValue("IntAttr", 77);
 274         subRep.setValue("DoubleAttr", 3.333);
 275         subRep.setValue("BoolAttr", true);
 276         subRep.setValue("StringAttr", std::string("String attr"));
 277         startRep.setValue("Sub", subRep);
 278
 279         OC::MessageContainer mc1;
 280         mc1.addRepresentation(startRep);
 281
 282         OCRepPayload* cstart = mc1.getPayload();
 283         EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
 284
 285         uint8_t* cborData;
 286         size_t cborSize;
 287         OCPayload* cparsed;
 288         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
 289         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
 290                     cborData, cborSize));
 291         OCPayloadDestroy((OCPayload*)cstart);
 292         OICFree(cborData);
 293
 294         OC::MessageContainer mc2;
 295         mc2.setPayload(cparsed);
 296         EXPECT_EQ(1u, mc2.representations().size());
 297         const OC::OCRepresentation& r = mc2.representations()[0];
 298
 299         OC::OCRepresentation newSubRep = r["Sub"];
 300
 301         EXPECT_TRUE(newSubRep.isNULL("NullAttr"));
 302         EXPECT_EQ(77, newSubRep.getValue<int>("IntAttr"));
 303         EXPECT_EQ(3.333, newSubRep.getValue<double>("DoubleAttr"));
 304         EXPECT_EQ(true, newSubRep.getValue<bool>("BoolAttr"));
 305         EXPECT_STREQ("String attr", newSubRep.getValue<std::string>("StringAttr").c_str());
 306         OCPayloadDestroy(cparsed);
 307     }
 308
 309     TEST(RepresentationEncoding, OneDVectors)
 310     {
 311         // Setup
 312         OC::OCRepresentation startRep;
 313
 314         OC::OCRepresentation subRep1;
 315         OC::OCRepresentation subRep2;
 316         OC::OCRepresentation subRep3;
 317         subRep1.setNULL("NullAttr");
 318         subRep1.setValue("IntAttr", 77);
 319         subRep2.setValue("DoubleAttr", 3.333);
 320         subRep2.setValue("BoolAttr", true);
 321         subRep3.setValue("StringAttr", std::string("String attr"));
 322
 323         std::vector<int> iarr {1,2,3,4,5,6,7,8,9};
 324         std::vector<double> darr {1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9};
 325         std::vector<bool> barr {false, true, false, false, true, true};
 326         std::vector<std::string> strarr {"item1", "item2", "item3", "item4"};
 327         std::vector<OC::OCRepresentation> objarr {subRep1, subRep2, subRep3};
 328
 329         startRep["iarr"] = iarr;
 330         startRep["darr"] = darr;
 331         startRep["barr"] = barr;
 332         startRep["strarr"] = strarr;
 333         startRep["objarr"] = objarr;
 334
 335         // Encode/decode
 336         OC::MessageContainer mc1;
 337         mc1.addRepresentation(startRep);
 338
 339         OCRepPayload* cstart = mc1.getPayload();
 340         EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
 341
 342         uint8_t* cborData;
 343         size_t cborSize;
 344         OCPayload* cparsed;
 345         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
 346         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
 347                     cborData, cborSize));
 348         OCPayloadDestroy((OCPayload*)cstart);
 349         OICFree(cborData);
 350
 351         OC::MessageContainer mc2;
 352         mc2.setPayload(cparsed);
 353         EXPECT_EQ(1u, mc2.representations().size());
 354         const OC::OCRepresentation& r = mc2.representations()[0];
 355
 356         // Test
 357         std::vector<int> iarr2 = r["iarr"];
 358         std::vector<double> darr2 = r["darr"];
 359         std::vector<bool> barr2 = r["barr"];
 360         std::vector<std::string> strarr2 = r["strarr"];
 361         std::vector<OC::OCRepresentation> objarr2 = r["objarr"];
 362
 363         EXPECT_EQ(iarr, iarr2);
 364         EXPECT_EQ(darr, darr2);
 365         EXPECT_EQ(barr, barr2);
 366         EXPECT_EQ(strarr, strarr2);
 367         EXPECT_EQ(objarr, objarr2);
 368         OCPayloadDestroy(cparsed);
 369     }
 370
 371     TEST(RepresentationEncoding, TwoDVectors)
 372     {
 373         // Setup
 374         OC::OCRepresentation startRep;
 375
 376         OC::OCRepresentation subRep1;
 377         OC::OCRepresentation subRep2;
 378         OC::OCRepresentation subRep3;
 379         subRep1.setNULL("NullAttr");
 380         subRep1.setValue("IntAttr", 77);
 381         subRep2.setValue("DoubleAttr", 3.333);
 382         subRep2.setValue("BoolAttr", true);
 383         subRep3.setValue("StringAttr", std::string("String attr"));
 384
 385         std::vector<std::vector<int>> iarr {{1,2,3},{4,5,6},{7,8,9}};
 386         std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{7.7,8.8,9.9}};
 387         std::vector<std::vector<bool>> barr {{false, true}, {false, false}, {true, true}};
 388         std::vector<std::vector<std::string>> strarr {{"item1", "item2"}, {"item3", "item4"}};
 389         std::vector<std::vector<OC::OCRepresentation>> objarr
 390         {{subRep1, subRep2, subRep3}, {subRep3, subRep2, subRep1}};
 391
 392         startRep["iarr"] = iarr;
 393         startRep["darr"] = darr;
 394         startRep["barr"] = barr;
 395         startRep["strarr"] = strarr;
 396         startRep["objarr"] = objarr;
 397
 398         // Encode/decode
 399         OC::MessageContainer mc1;
 400         mc1.addRepresentation(startRep);
 401
 402         OCRepPayload* cstart = mc1.getPayload();
 403         EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
 404
 405         uint8_t* cborData;
 406         size_t cborSize;
 407         OCPayload* cparsed;
 408         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
 409         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
 410                     cborData, cborSize));
 411         OCPayloadDestroy((OCPayload*)cstart);
 412         OICFree(cborData);
 413
 414         OC::MessageContainer mc2;
 415         mc2.setPayload(cparsed);
 416         EXPECT_EQ(1u, mc2.representations().size());
 417         const OC::OCRepresentation& r = mc2.representations()[0];
 418
 419         // Test
 420         std::vector<std::vector<int>> iarr2 = r["iarr"];
 421         std::vector<std::vector<double>> darr2 = r["darr"];
 422         std::vector<std::vector<bool>> barr2 = r["barr"];
 423         std::vector<std::vector<std::string>> strarr2 = r["strarr"];
 424         std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
 425
 426         EXPECT_EQ(iarr, iarr2);
 427         EXPECT_EQ(darr, darr2);
 428         EXPECT_EQ(barr, barr2);
 429         EXPECT_EQ(strarr, strarr2);
 430         EXPECT_EQ(objarr, objarr2);
 431         OCPayloadDestroy(cparsed);
 432     }
 433
 434     TEST(RepresentationEncoding, TwoDVectorsJagged)
 435     {
 436         // Setup
 437         OC::OCRepresentation startRep;
 438
 439         OC::OCRepresentation subRep1;
 440         OC::OCRepresentation subRep2;
 441         OC::OCRepresentation subRep3;
 442         subRep1.setNULL("NullAttr");
 443         subRep1.setValue("IntAttr", 77);
 444         subRep2.setValue("DoubleAttr", 3.333);
 445         subRep2.setValue("BoolAttr", true);
 446         subRep3.setValue("StringAttr", std::string("String attr"));
 447
 448         std::vector<std::vector<int>> iarr {{1,2,3},{4,6},{7,8,9}};
 449         std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{8.8,9.9}};
 450         std::vector<std::vector<bool>> barr {{false, true}, {false}, {true, true}};
 451         std::vector<std::vector<std::string>> strarr {{"item1"}, {"item3", "item4"}};
 452         std::vector<std::vector<OC::OCRepresentation>> objarr
 453         {{subRep1, subRep3}, {subRep3, subRep2, subRep1}};
 454
 455         startRep["iarr"] = iarr;
 456         startRep["darr"] = darr;
 457         startRep["barr"] = barr;
 458         startRep["strarr"] = strarr;
 459         startRep["objarr"] = objarr;
 460
 461         // Encode/decode
 462         OC::MessageContainer mc1;
 463         mc1.addRepresentation(startRep);
 464
 465         OCRepPayload* cstart = mc1.getPayload();
 466         EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
 467
 468         uint8_t* cborData;
 469         size_t cborSize;
 470         OCPayload* cparsed;
 471         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
 472         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
 473                     cborData, cborSize));
 474         OCPayloadDestroy((OCPayload*)cstart);
 475         OICFree(cborData);
 476
 477         OC::MessageContainer mc2;
 478         mc2.setPayload(cparsed);
 479         EXPECT_EQ(1u, mc2.representations().size());
 480         const OC::OCRepresentation& r = mc2.representations()[0];
 481
 482         // Test
 483         std::vector<std::vector<int>> iarr2 = r["iarr"];
 484         std::vector<std::vector<double>> darr2 = r["darr"];
 485         std::vector<std::vector<bool>> barr2 = r["barr"];
 486         std::vector<std::vector<std::string>> strarr2 = r["strarr"];
 487         std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
 488
 489         // Note: due to the way that the CSDK works, all 2d arrays need to be rectangular.
 490         // Since std::vector doesn't require this, items received on the other side end up
 491         // being backfilled.  This section removes the backfilling
 492         iarr2[1].pop_back();
 493         darr2[2].pop_back();
 494         barr2[1].pop_back();
 495         strarr2[0].pop_back();
 496         objarr2[0].pop_back();
 497
 498         EXPECT_EQ(iarr, iarr2);
 499         EXPECT_EQ(darr, darr2);
 500         EXPECT_EQ(barr, barr2);
 501         EXPECT_EQ(strarr, strarr2);
 502         EXPECT_EQ(objarr, objarr2);
 503         OCPayloadDestroy(cparsed);
 504     }
 505
 506     TEST(RepresentationEncoding, ThreeDVectors)
 507     {
 508         // Setup
 509         OC::OCRepresentation startRep;
 510
 511         OC::OCRepresentation subRep1;
 512         OC::OCRepresentation subRep2;
 513         OC::OCRepresentation subRep3;
 514         subRep1.setNULL("NullAttr");
 515         subRep1.setValue("IntAttr", 77);
 516         subRep2.setValue("DoubleAttr", 3.333);
 517         subRep2.setValue("BoolAttr", true);
 518         subRep3.setValue("StringAttr", std::string("String attr"));
 519
 520         std::vector<std::vector<std::vector<int>>> iarr
 521             {{{1,2,3},{4,5,6}},{{7,8,9},{10,11,12}},{{13,14,15},{16,17,18}}};
 522         std::vector<std::vector<std::vector<double>>> darr
 523             {{{1.1,2.2,3.3},{4.4,5.5,6.6}},
 524                 {{7.7,8.7,9.7},{10.7,11.7,12.7}},
 525                 {{13.7,14.7,15.7},{16.7,17.7,18.7}}};
 526         std::vector<std::vector<std::vector<bool>>> barr
 527             {{{false, true},{true, false}},{{false, true},{true, false}}};
 528         std::vector<std::vector<std::vector<std::string>>> strarr
 529             {
 530                 {{"item1", "item2"},{"item3", "item4"}},
 531                 {{"item5", "item6"},{"item7", "item8"}},
 532                 {{"item9", "item10"},{"item11", ""}}
 533             };
 534         std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
 535             {
 536                 {{subRep1, subRep2},{subRep3, subRep1}},
 537                 {{subRep2, subRep3},{subRep2, subRep1}},
 538                 {{subRep3, subRep2},{subRep1, subRep2}}
 539             };
 540
 541         startRep["iarr"] = iarr;
 542         startRep["darr"] = darr;
 543         startRep["barr"] = barr;
 544         startRep["strarr"] = strarr;
 545         startRep["objarr"] = objarr;
 546
 547         // Encode/decode
 548         OC::MessageContainer mc1;
 549         mc1.addRepresentation(startRep);
 550
 551         OCRepPayload* cstart = mc1.getPayload();
 552         EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
 553
 554         uint8_t* cborData;
 555         size_t cborSize;
 556         OCPayload* cparsed;
 557         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
 558         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
 559                     cborData, cborSize));
 560         OCPayloadDestroy((OCPayload*)cstart);
 561         OICFree(cborData);
 562
 563         OC::MessageContainer mc2;
 564         mc2.setPayload(cparsed);
 565         EXPECT_EQ(1u, mc2.representations().size());
 566         const OC::OCRepresentation& r = mc2.representations()[0];
 567
 568         // Test
 569         std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
 570         std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
 571         std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
 572         std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
 573         std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
 574
 575         EXPECT_EQ(iarr, iarr2);
 576         EXPECT_EQ(darr, darr2);
 577         EXPECT_EQ(barr, barr2);
 578         EXPECT_EQ(strarr, strarr2);
 579         EXPECT_EQ(objarr, objarr2);
 580         OCPayloadDestroy(cparsed);
 581     }
 582
 583     TEST(RepresentationEncoding, ThreeDVectorsJagged)
 584     {
 585         // Setup
 586         OC::OCRepresentation startRep;
 587
 588         OC::OCRepresentation subRep1;
 589         OC::OCRepresentation subRep2;
 590         OC::OCRepresentation subRep3;
 591         subRep1.setNULL("NullAttr");
 592         subRep1.setValue("IntAttr", 77);
 593         subRep2.setValue("DoubleAttr", 3.333);
 594         subRep2.setValue("BoolAttr", true);
 595         subRep3.setValue("StringAttr", std::string("String attr"));
 596
 597         std::vector<std::vector<std::vector<int>>> iarr
 598             {
 599                 {{1,2,3},{4,5,6}},
 600                 {{7,8,9},{10,12}},
 601                 {{13,14,15},{16,17,18}}
 602             };
 603         std::vector<std::vector<std::vector<double>>> darr
 604             {
 605                 {{1.1,2.2,3.3},{4.4,5.5,6.6}},
 606                 {{7.7,8.7,9.7},{10.7,12.7}},
 607                 {{13.7,14.7,15.7},{16.7,17.7,18.7}}
 608             };
 609         std::vector<std::vector<std::vector<bool>>> barr
 610             {
 611                 {{false, true},{true}},
 612                 {{false, true},{true, false}}
 613             };
 614         std::vector<std::vector<std::vector<std::string>>> strarr
 615             {
 616                 {{"item1", "item2"},{"item3", "item4"}},
 617                 {{"item5", "item6"},{"item8"}},
 618                 {{"item9", "item10"},{"item11", ""}}
 619             };
 620         std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
 621             {
 622                 {{subRep1, subRep2},{subRep3, subRep1}},
 623                 {{subRep2, subRep3},{subRep2}},
 624                 {{subRep3, subRep2}}
 625             };
 626
 627         startRep["iarr"] = iarr;
 628         startRep["darr"] = darr;
 629         startRep["barr"] = barr;
 630         startRep["strarr"] = strarr;
 631         startRep["objarr"] = objarr;
 632
 633         // Encode/decode
 634         OC::MessageContainer mc1;
 635         mc1.addRepresentation(startRep);
 636
 637         OCRepPayload* cstart = mc1.getPayload();
 638         EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
 639
 640         uint8_t* cborData;
 641         size_t cborSize;
 642         OCPayload* cparsed;
 643         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
 644         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
 645                     cborData, cborSize));
 646         OCPayloadDestroy((OCPayload*)cstart);
 647         OICFree(cborData);
 648
 649         OC::MessageContainer mc2;
 650         mc2.setPayload(cparsed);
 651         EXPECT_EQ(1u, mc2.representations().size());
 652         const OC::OCRepresentation& r = mc2.representations()[0];
 653
 654         // Test
 655         std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
 656         std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
 657         std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
 658         std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
 659         std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
 660
 661         // Note: due to the way that the CSDK works, all 3d arrays need to be cuboidal.
 662         // Since std::vector doesn't require this, items received on the other side end up
 663         // being backfilled.  This section removes the backfilling
 664         iarr2[1][1].pop_back();
 665         darr2[1][1].pop_back();
 666         barr2[0][1].pop_back();
 667         strarr2[1][1].pop_back();
 668         objarr2[1][1].pop_back();
 669         objarr2[2].pop_back();
 670
 671         EXPECT_EQ(iarr, iarr2);
 672         EXPECT_EQ(darr, darr2);
 673         EXPECT_EQ(barr, barr2);
 674         EXPECT_EQ(strarr, strarr2);
 675         EXPECT_EQ(objarr, objarr2);
 676         OCPayloadDestroy(cparsed);
 677     }
 678
 679     TEST(DiscoveryRTandIF, SingleItemNormal)
 680     {
 681         OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
 682         OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
 683         payload->sid = (uint8_t*)OICMalloc(16);
 684         payload->resources = resource;
 685
 686         EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem"));
 687         EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem"));
 688
 689         resource->uri = OICStrdup("/uri/thing");
 690
 691         uint8_t* cborData;
 692         size_t cborSize;
 693         OCPayload* cparsed;
 694
 695         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
 696         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
 697                     cborData, cborSize));
 698
 699         EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
 700         OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
 701
 702         EXPECT_EQ(NULL, parsedResource->next);
 703         EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
 704         EXPECT_EQ(NULL, parsedResource->types->next);
 705         EXPECT_EQ(NULL, parsedResource->interfaces->next);
 706         EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
 707
 708         OICFree(cborData);
 709         OCPayloadDestroy(cparsed);
 710         OCDiscoveryPayloadDestroy(payload);
 711     }
 712
 713     TEST(DiscoveryRTandIF, SingleItemFrontTrim)
 714     {
 715         OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
 716         payload->sid = (uint8_t*)OICMalloc(16);
 717         OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
 718         payload->resources = resource;
 719
 720         EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, "    rt.singleitem"));
 721         EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, "    if.singleitem"));
 722         resource->uri = OICStrdup("/uri/thing");
 723
 724         uint8_t* cborData;
 725         size_t cborSize;
 726         OCPayload* cparsed;
 727
 728         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
 729         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
 730                     cborData, cborSize));
 731
 732         EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
 733         OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
 734
 735         EXPECT_EQ(NULL, parsedResource->next);
 736
 737         EXPECT_EQ(NULL, parsedResource->types->next);
 738         EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
 739         EXPECT_EQ(NULL, parsedResource->interfaces->next);
 740         EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
 741
 742         OICFree(cborData);
 743         OCPayloadDestroy(cparsed);
 744         OCDiscoveryPayloadDestroy(payload);
 745     }
 746
 747     TEST(DiscoveryRTandIF, SingleItemBackTrim)
 748     {
 749         OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
 750         payload->sid = (uint8_t*)OICMalloc(16);
 751         OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
 752         payload->resources = resource;
 753
 754         OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem    ");
 755         OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem    ");
 756         resource->uri = OICStrdup("/uri/thing");
 757
 758         uint8_t* cborData;
 759         size_t cborSize;
 760         OCPayload* cparsed;
 761
 762         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
 763         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
 764                     cborData, cborSize));
 765
 766         EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
 767         OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
 768
 769         EXPECT_EQ(NULL, parsedResource->next);
 770
 771         EXPECT_EQ(NULL, parsedResource->types->next);
 772         EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
 773         EXPECT_EQ(NULL, parsedResource->interfaces->next);
 774         EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
 775
 776         OICFree(cborData);
 777         OCPayloadDestroy(cparsed);
 778         OCDiscoveryPayloadDestroy(payload);
 779     }
 780     TEST(DiscoveryRTandIF, SingleItemBothTrim)
 781     {
 782         OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
 783         payload->sid = (uint8_t*)OICMalloc(16);
 784         OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
 785         payload->resources = resource;
 786
 787         OCResourcePayloadAddStringLL(&resource->types, "    rt.singleitem    ");
 788         OCResourcePayloadAddStringLL(&resource->interfaces, "    if.singleitem     ");
 789         resource->uri = OICStrdup("/uri/thing");
 790
 791         uint8_t* cborData;
 792         size_t cborSize;
 793         OCPayload* cparsed;
 794
 795         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
 796         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
 797                     cborData, cborSize));
 798
 799         EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
 800         OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
 801
 802         EXPECT_EQ(NULL, parsedResource->next);
 803
 804         EXPECT_EQ(NULL, parsedResource->types->next);
 805         EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
 806         EXPECT_EQ(NULL, parsedResource->interfaces->next);
 807         EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
 808
 809         OICFree(cborData);
 810         OCPayloadDestroy(cparsed);
 811         OCDiscoveryPayloadDestroy(payload);
 812     }
 813     TEST(DiscoveryRTandIF, MultiItemsNormal)
 814     {
 815         OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
 816         payload->sid = (uint8_t*)OICMalloc(16);
 817         OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
 818         payload->resources = resource;
 819
 820         OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem");
 821         OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem");
 822         OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem");
 823         OCResourcePayloadAddStringLL(&resource->interfaces, "if.seconditem");
 824         resource->uri = OICStrdup("/uri/thing");
 825
 826         uint8_t* cborData;
 827         size_t cborSize;
 828         OCPayload* cparsed;
 829
 830         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
 831         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
 832                     cborData, cborSize));
 833
 834         EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
 835         OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
 836
 837         EXPECT_EQ(NULL, parsedResource->next);
 838
 839         EXPECT_EQ(NULL, parsedResource->types->next->next);
 840         EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
 841         EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
 842         EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
 843         EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
 844         EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
 845
 846         OICFree(cborData);
 847         OCPayloadDestroy(cparsed);
 848         OCDiscoveryPayloadDestroy(payload);
 849     }
 850     TEST(DiscoveryRTandIF, MultiItemExtraLeadSpaces)
 851     {
 852         OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
 853         payload->sid = (uint8_t*)OICMalloc(16);
 854         OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
 855         payload->resources = resource;
 856
 857         OCResourcePayloadAddStringLL(&resource->types, "  rt.firstitem");
 858         OCResourcePayloadAddStringLL(&resource->types, "  rt.seconditem");
 859         OCResourcePayloadAddStringLL(&resource->interfaces, "  if.firstitem");
 860         OCResourcePayloadAddStringLL(&resource->interfaces, "  if.seconditem");
 861         resource->uri = OICStrdup("/uri/thing");
 862
 863         uint8_t* cborData;
 864         size_t cborSize;
 865         OCPayload* cparsed;
 866
 867         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
 868         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
 869                     cborData, cborSize));
 870
 871         EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
 872         OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
 873
 874         EXPECT_EQ(NULL, parsedResource->next);
 875
 876         EXPECT_EQ(NULL, parsedResource->types->next->next);
 877         EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
 878         EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
 879         EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
 880         EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
 881         EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
 882
 883         OICFree(cborData);
 884         OCPayloadDestroy(cparsed);
 885         OCDiscoveryPayloadDestroy(payload);
 886     }
 887     TEST(DiscoveryRTandIF, MultiItemExtraTrailSpaces)
 888     {
 889         OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
 890         payload->sid = (uint8_t*)OICMalloc(16);
 891         OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
 892         payload->resources = resource;
 893
 894         OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem  ");
 895         OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem  ");
 896         OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem  ");
 897         OCResourcePayloadAddStringLL(&resource->interfaces, "if.seconditem  ");
 898         resource->uri = OICStrdup("/uri/thing");
 899
 900         uint8_t* cborData;
 901         size_t cborSize;
 902         OCPayload* cparsed;
 903
 904         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
 905         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
 906                     cborData, cborSize));
 907
 908         EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
 909         OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
 910
 911         EXPECT_EQ(NULL, parsedResource->next);
 912
 913         EXPECT_EQ(NULL, parsedResource->types->next->next);
 914         EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
 915         EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
 916         EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
 917         EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
 918         EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
 919
 920         OICFree(cborData);
 921         OCPayloadDestroy(cparsed);
 922         OCDiscoveryPayloadDestroy(payload);
 923     }
 924     TEST(DiscoveryRTandIF, MultiItemBothSpaces)
 925     {
 926         OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
 927         payload->sid = (uint8_t*)OICMalloc(16);
 928         OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
 929         payload->resources = resource;
 930
 931         OCResourcePayloadAddStringLL(&resource->types, "  rt.firstitem  ");
 932         OCResourcePayloadAddStringLL(&resource->types, "  rt.seconditem  ");
 933         OCResourcePayloadAddStringLL(&resource->interfaces, "  if.firstitem  ");
 934         OCResourcePayloadAddStringLL(&resource->interfaces, "  if.seconditem  ");
 935         resource->uri = OICStrdup("/uri/thing");
 936
 937         uint8_t* cborData;
 938         size_t cborSize;
 939         OCPayload* cparsed;
 940
 941         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
 942         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
 943                     cborData, cborSize));
 944
 945         EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
 946         OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
 947
 948         EXPECT_EQ(NULL, parsedResource->next);
 949
 950         EXPECT_EQ(NULL, parsedResource->types->next->next);
 951         EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
 952         EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
 953         EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
 954         EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
 955         EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
 956
 957         OICFree(cborData);
 958         OCPayloadDestroy(cparsed);
 959         OCDiscoveryPayloadDestroy(payload);
 960     }
 961     TEST(RepresentationEncodingRTandIF, SingleItemNormal)
 962     {
 963         OCRepPayload* payload = OCRepPayloadCreate();
 964         OCRepPayloadAddResourceType(payload, "rt.firstitem");
 965         OCRepPayloadAddInterface(payload, "if.firstitem");
 966
 967         uint8_t* cborData;
 968         size_t cborSize;
 969         OCPayload* cparsed;
 970
 971         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
 972         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
 973                     cborData, cborSize));
 974
 975         OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
 976
 977         EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
 978         EXPECT_EQ(NULL, parsedPayload->types->next);
 979         EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
 980         EXPECT_EQ(NULL, parsedPayload->interfaces->next);
 981
 982         OICFree(cborData);
 983         OCRepPayloadDestroy(payload);
 984         OCPayloadDestroy(cparsed);
 985     }
 986     TEST(RepresentationEncodingRTandIF, SingleItemFrontTrim)
 987     {
 988         OCRepPayload* payload = OCRepPayloadCreate();
 989         OCRepPayloadAddResourceType(payload, "  rt.firstitem");
 990         OCRepPayloadAddInterface(payload, "  if.firstitem");
 991
 992         uint8_t* cborData;
 993         size_t cborSize;
 994         OCPayload* cparsed;
 995
 996         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
 997         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
 998                     cborData, cborSize));
 999
1000         OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1001
1002         EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1003         EXPECT_EQ(NULL, parsedPayload->types->next);
1004         EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1005         EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1006
1007
1008         OICFree(cborData);
1009         OCRepPayloadDestroy(payload);
1010         OCPayloadDestroy(cparsed);
1011     }
1012     TEST(RepresentationEncodingRTandIF, SingleItemBackTrim)
1013     {
1014         OCRepPayload* payload = OCRepPayloadCreate();
1015         OCRepPayloadAddResourceType(payload, "rt.firstitem  ");
1016         OCRepPayloadAddInterface(payload, "if.firstitem  ");
1017
1018         uint8_t* cborData;
1019         size_t cborSize;
1020         OCPayload* cparsed;
1021
1022         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1023         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1024                     cborData, cborSize));
1025
1026         OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1027
1028         EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1029         EXPECT_EQ(NULL, parsedPayload->types->next);
1030         EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1031         EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1032
1033
1034         OICFree(cborData);
1035         OCRepPayloadDestroy(payload);
1036         OCPayloadDestroy(cparsed);
1037     }
1038     TEST(RepresentationEncodingRTandIF, SingleItemBothTrim)
1039     {
1040         OCRepPayload* payload = OCRepPayloadCreate();
1041         OCRepPayloadAddResourceType(payload, "  rt.firstitem  ");
1042         OCRepPayloadAddInterface(payload, "  if.firstitem  ");
1043
1044         uint8_t* cborData;
1045         size_t cborSize;
1046         OCPayload* cparsed;
1047
1048         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1049         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1050                     cborData, cborSize));
1051
1052         OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1053
1054         EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1055         EXPECT_EQ(NULL, parsedPayload->types->next);
1056         EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1057         EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1058
1059
1060         OICFree(cborData);
1061         OCRepPayloadDestroy(payload);
1062         OCPayloadDestroy(cparsed);
1063     }
1064     TEST(RepresentationEncodingRTandIF, MultiItemsNormal)
1065     {
1066         OCRepPayload* payload = OCRepPayloadCreate();
1067         OCRepPayloadAddResourceType(payload, "rt.firstitem");
1068         OCRepPayloadAddResourceType(payload, "rt.seconditem");
1069         OCRepPayloadAddInterface(payload, "if.firstitem");
1070         OCRepPayloadAddInterface(payload, "if.seconditem");
1071
1072         uint8_t* cborData;
1073         size_t cborSize;
1074         OCPayload* cparsed;
1075
1076         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1077         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1078                     cborData, cborSize));
1079
1080         OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1081
1082         EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1083         EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1084         EXPECT_EQ(NULL, parsedPayload->types->next->next);
1085         EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1086         EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1087         EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1088
1089
1090         OICFree(cborData);
1091         OCRepPayloadDestroy(payload);
1092         OCPayloadDestroy(cparsed);
1093     }
1094     TEST(RepresentationEncodingRTandIF, MultiItemExtraLeadSpaces)
1095     {
1096         OCRepPayload* payload = OCRepPayloadCreate();
1097         OCRepPayloadAddResourceType(payload, "  rt.firstitem");
1098         OCRepPayloadAddResourceType(payload, "  rt.seconditem");
1099         OCRepPayloadAddInterface(payload, "  if.firstitem");
1100         OCRepPayloadAddInterface(payload, "  if.seconditem");
1101
1102         uint8_t* cborData;
1103         size_t cborSize;
1104         OCPayload* cparsed;
1105
1106         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1107         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1108                     cborData, cborSize));
1109
1110         OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1111
1112         EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1113         EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1114         EXPECT_EQ(NULL, parsedPayload->types->next->next);
1115         EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1116         EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1117         EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1118
1119
1120         OICFree(cborData);
1121         OCRepPayloadDestroy(payload);
1122         OCPayloadDestroy(cparsed);
1123     }
1124     TEST(RepresentationEncodingRTandIF, MultiItemExtraTrailSpaces)
1125     {
1126         OCRepPayload* payload = OCRepPayloadCreate();
1127         OCRepPayloadAddResourceType(payload, "rt.firstitem  ");
1128         OCRepPayloadAddResourceType(payload, "rt.seconditem  ");
1129         OCRepPayloadAddInterface(payload, "if.firstitem  ");
1130         OCRepPayloadAddInterface(payload, "if.seconditem  ");
1131
1132         uint8_t* cborData;
1133         size_t cborSize;
1134         OCPayload* cparsed;
1135
1136         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1137         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1138                     cborData, cborSize));
1139
1140         OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1141
1142         EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1143         EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1144         EXPECT_EQ(NULL, parsedPayload->types->next->next);
1145         EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1146         EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1147         EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1148
1149
1150         OICFree(cborData);
1151         OCRepPayloadDestroy(payload);
1152         OCPayloadDestroy(cparsed);
1153     }
1154     TEST(RepresentationEncodingRTandIF, MultiItemExtraMiddleSpaces)
1155     {
1156         OCRepPayload* payload = OCRepPayloadCreate();
1157         OCRepPayloadAddResourceType(payload, "  rt.firstitem  ");
1158         OCRepPayloadAddResourceType(payload, "  rt.seconditem  ");
1159         OCRepPayloadAddInterface(payload, "  if.firstitem  ");
1160         OCRepPayloadAddInterface(payload, "  if.seconditem  ");
1161
1162         uint8_t* cborData;
1163         size_t cborSize;
1164         OCPayload* cparsed;
1165
1166         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1167         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1168                     cborData, cborSize));
1169
1170         OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1171
1172         EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1173         EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1174         EXPECT_EQ(NULL, parsedPayload->types->next->next);
1175         EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1176         EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1177         EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1178
1179
1180         OICFree(cborData);
1181         OCRepPayloadDestroy(payload);
1182         OCPayloadDestroy(cparsed);
1183     }
1184     TEST(RepresentationEncodingRTandIF, TestPayloadContents)
1185     {
1186         OC::OCRepresentation subRep1;
1187         std::vector<std::string> types;
1188         types.push_back("rt.firstitem");
1189         std::vector<std::string> interfaces;
1190         interfaces.push_back("if.firstitem");
1191         subRep1.setResourceTypes(types);
1192         subRep1.setResourceInterfaces(interfaces);
1193         subRep1.setNULL("NullAttr");
1194         subRep1.setValue("IntAttr", 77);
1195         subRep1.setValue("DoubleAttr", 3.333);
1196         subRep1.setValue("BoolAttr", true);
1197         subRep1.setValue("StringAttr", std::string("String attr"));
1198
1199         OC::MessageContainer mc1;
1200         mc1.addRepresentation(subRep1);
1201
1202         OCRepPayload *repPayload = mc1.getPayload();
1203         EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, repPayload->base.type);
1204
1205         uint8_t *cborData = NULL;
1206         size_t cborSize = 0;
1207         OCPayload *cparsed = NULL;
1208
1209         EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)repPayload, &cborData, &cborSize));
1210         EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1211                     cborData, cborSize));
1212
1213         OCRepPayload *parsedPayload = (OCRepPayload *)cparsed;
1214         EXPECT_EQ(NULL, parsedPayload->uri);
1215         EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1216         EXPECT_EQ(NULL, parsedPayload->types->next);
1217         EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1218         EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1219
1220         // To make sure rt and if are not duplicated.
1221         EXPECT_STREQ("BoolAttr", parsedPayload->values->name);
1222         EXPECT_EQ(true, parsedPayload->values->b);
1223         EXPECT_EQ(OCREP_PROP_BOOL, parsedPayload->values->type);
1224         parsedPayload->values = parsedPayload->values->next;
1225
1226         EXPECT_STREQ("DoubleAttr", parsedPayload->values->name);
1227         EXPECT_EQ(OCREP_PROP_DOUBLE, parsedPayload->values->type);
1228         EXPECT_EQ(3.3330000000000002, parsedPayload->values->d);
1229         parsedPayload->values = parsedPayload->values->next;
1230
1231         EXPECT_STREQ("IntAttr", parsedPayload->values->name);
1232         EXPECT_EQ(77, parsedPayload->values->i);
1233         EXPECT_EQ(OCREP_PROP_INT, parsedPayload->values->type);
1234         parsedPayload->values = parsedPayload->values->next;
1235
1236         EXPECT_STREQ("NullAttr", parsedPayload->values->name);
1237         EXPECT_EQ(OCREP_PROP_NULL, parsedPayload->values->type);
1238         parsedPayload->values = parsedPayload->values->next;
1239
1240         EXPECT_STREQ("StringAttr", parsedPayload->values->name);
1241         EXPECT_STREQ("String attr", parsedPayload->values->str);
1242         EXPECT_EQ(OCREP_PROP_STRING, parsedPayload->values->type);
1243         parsedPayload->values = parsedPayload->values->next;
1244
1245         EXPECT_EQ(NULL, parsedPayload->values);
1246
1247         OICFree(cborData);
1248         OCRepPayloadDestroy(repPayload);
1249         OCPayloadDestroy(cparsed);
1250     }
1251 }