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