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