1 //******************************************************************
3 // Copyright 2015 Intel Mobile Communications GmbH All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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
11 // http://www.apache.org/licenses/LICENSE-2.0
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.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 #include <gtest/gtest.h>
23 #include <OCRepresentation.h>
25 #include <ocpayload.h>
26 #include <ocpayloadcbor.h>
27 #include <oic_malloc.h>
28 #include <oic_string.h>
32 bool operator==(const OC::NullType&, const OC::NullType&)
37 bool operator==(const OC::OCRepresentation& lhs, const OC::OCRepresentation& rhs)
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;
46 // these tests validate the OCRepresentation->OCPayload, OCPayload->CBOR,
47 // CBOR->OCPayload and OCPayload->OCRepresentation conversions
48 namespace OCRepresentationEncodingTest
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";
55 TEST(DeviceDiscoveryEncoding, Normal)
57 OCDevicePayload* device = OCDevicePayloadCreate(
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);
68 for (uint8_t i = 1; i <= sizeof(sid1); ++i)
70 EXPECT_EQ(i, sid1[i - 1]);
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,
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);
86 OCPayloadDestroy((OCPayload*)device);
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());
96 OCPayloadDestroy(parsedDevice);
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";
113 TEST(PlatformDiscoveryEncoding, Normal)
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);
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));
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);
153 OCPayloadDestroy((OCPayload*)platform);
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());
171 OCPayloadDestroy(parsedPlatform);
173 TEST(PresencePayload, Normal)
176 uint32_t sequenceNumber = 0;
177 OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE;
178 OCPresencePayload *presence = OCPresencePayloadCreate(sequenceNumber, maxAge, trigger, uri1);
183 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)presence, &cborData, &cborSize));
184 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_PRESENCE,
185 cborData, cborSize));
186 OCPayloadDestroy((OCPayload*)presence);
189 OCPresencePayload* parsed = ((OCPresencePayload*)cparsed);
190 EXPECT_EQ(sequenceNumber, parsed->sequenceNumber);
191 EXPECT_EQ(maxAge, parsed->maxAge);
192 EXPECT_EQ(trigger, parsed->trigger);
193 EXPECT_STREQ(uri1, parsed->resourceType);
195 OCPayloadDestroy(cparsed);
197 // Representation Payloads
198 TEST(RepresentationEncoding, BaseAttributeTypes)
200 OC::OCRepresentation startRep;
201 startRep.setNULL("NullAttr");
202 startRep.setValue("IntAttr", 77);
203 startRep.setValue("DoubleAttr", 3.333);
204 startRep.setValue("BoolAttr", true);
205 startRep.setValue("StringAttr", std::string("String attr"));
206 OC::MessageContainer mc1;
207 mc1.addRepresentation(startRep);
209 OCRepPayload* cstart = mc1.getPayload();
210 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
215 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
216 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
217 cborData, cborSize));
218 OCPayloadDestroy((OCPayload*)cstart);
221 OC::MessageContainer mc2;
222 mc2.setPayload(cparsed);
223 EXPECT_EQ(1u, mc2.representations().size());
224 const OC::OCRepresentation& r = mc2.representations()[0];
226 EXPECT_TRUE(r.isNULL("NullAttr"));
227 EXPECT_EQ(77, r.getValue<int>("IntAttr"));
228 EXPECT_EQ(3.333, r.getValue<double>("DoubleAttr"));
229 EXPECT_EQ(true, r.getValue<bool>("BoolAttr"));
230 EXPECT_STREQ("String attr", r.getValue<std::string>("StringAttr").c_str());
232 OCPayloadDestroy(cparsed);
235 TEST(RepresentationEncoding, RepAttribute)
237 OC::OCRepresentation startRep;
238 OC::OCRepresentation subRep;
239 subRep.setNULL("NullAttr");
240 subRep.setValue("IntAttr", 77);
241 subRep.setValue("DoubleAttr", 3.333);
242 subRep.setValue("BoolAttr", true);
243 subRep.setValue("StringAttr", std::string("String attr"));
244 startRep.setValue("Sub", subRep);
246 OC::MessageContainer mc1;
247 mc1.addRepresentation(startRep);
249 OCRepPayload* cstart = mc1.getPayload();
250 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
255 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
256 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
257 cborData, cborSize));
258 OCPayloadDestroy((OCPayload*)cstart);
261 OC::MessageContainer mc2;
262 mc2.setPayload(cparsed);
263 EXPECT_EQ(1u, mc2.representations().size());
264 const OC::OCRepresentation& r = mc2.representations()[0];
266 OC::OCRepresentation newSubRep = r["Sub"];
268 EXPECT_TRUE(newSubRep.isNULL("NullAttr"));
269 EXPECT_EQ(77, newSubRep.getValue<int>("IntAttr"));
270 EXPECT_EQ(3.333, newSubRep.getValue<double>("DoubleAttr"));
271 EXPECT_EQ(true, newSubRep.getValue<bool>("BoolAttr"));
272 EXPECT_STREQ("String attr", newSubRep.getValue<std::string>("StringAttr").c_str());
273 OCPayloadDestroy(cparsed);
276 TEST(RepresentationEncoding, OneDVectors)
279 OC::OCRepresentation startRep;
281 OC::OCRepresentation subRep1;
282 OC::OCRepresentation subRep2;
283 OC::OCRepresentation subRep3;
284 subRep1.setNULL("NullAttr");
285 subRep1.setValue("IntAttr", 77);
286 subRep2.setValue("DoubleAttr", 3.333);
287 subRep2.setValue("BoolAttr", true);
288 subRep3.setValue("StringAttr", std::string("String attr"));
290 std::vector<int> iarr {1,2,3,4,5,6,7,8,9};
291 std::vector<double> darr {1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9};
292 std::vector<bool> barr {false, true, false, false, true, true};
293 std::vector<std::string> strarr {"item1", "item2", "item3", "item4"};
294 std::vector<OC::OCRepresentation> objarr {subRep1, subRep2, subRep3};
296 startRep["iarr"] = iarr;
297 startRep["darr"] = darr;
298 startRep["barr"] = barr;
299 startRep["strarr"] = strarr;
300 startRep["objarr"] = objarr;
303 OC::MessageContainer mc1;
304 mc1.addRepresentation(startRep);
306 OCRepPayload* cstart = mc1.getPayload();
307 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
312 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
313 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
314 cborData, cborSize));
315 OCPayloadDestroy((OCPayload*)cstart);
318 OC::MessageContainer mc2;
319 mc2.setPayload(cparsed);
320 EXPECT_EQ(1u, mc2.representations().size());
321 const OC::OCRepresentation& r = mc2.representations()[0];
324 std::vector<int> iarr2 = r["iarr"];
325 std::vector<double> darr2 = r["darr"];
326 std::vector<bool> barr2 = r["barr"];
327 std::vector<std::string> strarr2 = r["strarr"];
328 std::vector<OC::OCRepresentation> objarr2 = r["objarr"];
330 EXPECT_EQ(iarr, iarr2);
331 EXPECT_EQ(darr, darr2);
332 EXPECT_EQ(barr, barr2);
333 EXPECT_EQ(strarr, strarr2);
334 EXPECT_EQ(objarr, objarr2);
335 OCPayloadDestroy(cparsed);
338 TEST(RepresentationEncoding, TwoDVectors)
341 OC::OCRepresentation startRep;
343 OC::OCRepresentation subRep1;
344 OC::OCRepresentation subRep2;
345 OC::OCRepresentation subRep3;
346 subRep1.setNULL("NullAttr");
347 subRep1.setValue("IntAttr", 77);
348 subRep2.setValue("DoubleAttr", 3.333);
349 subRep2.setValue("BoolAttr", true);
350 subRep3.setValue("StringAttr", std::string("String attr"));
352 std::vector<std::vector<int>> iarr {{1,2,3},{4,5,6},{7,8,9}};
353 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{7.7,8.8,9.9}};
354 std::vector<std::vector<bool>> barr {{false, true}, {false, false}, {true, true}};
355 std::vector<std::vector<std::string>> strarr {{"item1", "item2"}, {"item3", "item4"}};
356 std::vector<std::vector<OC::OCRepresentation>> objarr
357 {{subRep1, subRep2, subRep3}, {subRep3, subRep2, subRep1}};
359 startRep["iarr"] = iarr;
360 startRep["darr"] = darr;
361 startRep["barr"] = barr;
362 startRep["strarr"] = strarr;
363 startRep["objarr"] = objarr;
366 OC::MessageContainer mc1;
367 mc1.addRepresentation(startRep);
369 OCRepPayload* cstart = mc1.getPayload();
370 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
375 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
376 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
377 cborData, cborSize));
378 OCPayloadDestroy((OCPayload*)cstart);
381 OC::MessageContainer mc2;
382 mc2.setPayload(cparsed);
383 EXPECT_EQ(1u, mc2.representations().size());
384 const OC::OCRepresentation& r = mc2.representations()[0];
387 std::vector<std::vector<int>> iarr2 = r["iarr"];
388 std::vector<std::vector<double>> darr2 = r["darr"];
389 std::vector<std::vector<bool>> barr2 = r["barr"];
390 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
391 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
393 EXPECT_EQ(iarr, iarr2);
394 EXPECT_EQ(darr, darr2);
395 EXPECT_EQ(barr, barr2);
396 EXPECT_EQ(strarr, strarr2);
397 EXPECT_EQ(objarr, objarr2);
398 OCPayloadDestroy(cparsed);
401 TEST(RepresentationEncoding, TwoDVectorsJagged)
404 OC::OCRepresentation startRep;
406 OC::OCRepresentation subRep1;
407 OC::OCRepresentation subRep2;
408 OC::OCRepresentation subRep3;
409 subRep1.setNULL("NullAttr");
410 subRep1.setValue("IntAttr", 77);
411 subRep2.setValue("DoubleAttr", 3.333);
412 subRep2.setValue("BoolAttr", true);
413 subRep3.setValue("StringAttr", std::string("String attr"));
415 std::vector<std::vector<int>> iarr {{1,2,3},{4,6},{7,8,9}};
416 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{8.8,9.9}};
417 std::vector<std::vector<bool>> barr {{false, true}, {false}, {true, true}};
418 std::vector<std::vector<std::string>> strarr {{"item1"}, {"item3", "item4"}};
419 std::vector<std::vector<OC::OCRepresentation>> objarr
420 {{subRep1, subRep3}, {subRep3, subRep2, subRep1}};
422 startRep["iarr"] = iarr;
423 startRep["darr"] = darr;
424 startRep["barr"] = barr;
425 startRep["strarr"] = strarr;
426 startRep["objarr"] = objarr;
429 OC::MessageContainer mc1;
430 mc1.addRepresentation(startRep);
432 OCRepPayload* cstart = mc1.getPayload();
433 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
438 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
439 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
440 cborData, cborSize));
441 OCPayloadDestroy((OCPayload*)cstart);
444 OC::MessageContainer mc2;
445 mc2.setPayload(cparsed);
446 EXPECT_EQ(1u, mc2.representations().size());
447 const OC::OCRepresentation& r = mc2.representations()[0];
450 std::vector<std::vector<int>> iarr2 = r["iarr"];
451 std::vector<std::vector<double>> darr2 = r["darr"];
452 std::vector<std::vector<bool>> barr2 = r["barr"];
453 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
454 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
456 // Note: due to the way that the CSDK works, all 2d arrays need to be rectangular.
457 // Since std::vector doesn't require this, items received on the other side end up
458 // being backfilled. This section removes the backfilling
462 strarr2[0].pop_back();
463 objarr2[0].pop_back();
465 EXPECT_EQ(iarr, iarr2);
466 EXPECT_EQ(darr, darr2);
467 EXPECT_EQ(barr, barr2);
468 EXPECT_EQ(strarr, strarr2);
469 EXPECT_EQ(objarr, objarr2);
470 OCPayloadDestroy(cparsed);
473 TEST(RepresentationEncoding, ThreeDVectors)
476 OC::OCRepresentation startRep;
478 OC::OCRepresentation subRep1;
479 OC::OCRepresentation subRep2;
480 OC::OCRepresentation subRep3;
481 subRep1.setNULL("NullAttr");
482 subRep1.setValue("IntAttr", 77);
483 subRep2.setValue("DoubleAttr", 3.333);
484 subRep2.setValue("BoolAttr", true);
485 subRep3.setValue("StringAttr", std::string("String attr"));
487 std::vector<std::vector<std::vector<int>>> iarr
488 {{{1,2,3},{4,5,6}},{{7,8,9},{10,11,12}},{{13,14,15},{16,17,18}}};
489 std::vector<std::vector<std::vector<double>>> darr
490 {{{1.1,2.2,3.3},{4.4,5.5,6.6}},
491 {{7.7,8.7,9.7},{10.7,11.7,12.7}},
492 {{13.7,14.7,15.7},{16.7,17.7,18.7}}};
493 std::vector<std::vector<std::vector<bool>>> barr
494 {{{false, true},{true, false}},{{false, true},{true, false}}};
495 std::vector<std::vector<std::vector<std::string>>> strarr
497 {{"item1", "item2"},{"item3", "item4"}},
498 {{"item5", "item6"},{"item7", "item8"}},
499 {{"item9", "item10"},{"item11", ""}}
501 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
503 {{subRep1, subRep2},{subRep3, subRep1}},
504 {{subRep2, subRep3},{subRep2, subRep1}},
505 {{subRep3, subRep2},{subRep1, subRep2}}
508 startRep["iarr"] = iarr;
509 startRep["darr"] = darr;
510 startRep["barr"] = barr;
511 startRep["strarr"] = strarr;
512 startRep["objarr"] = objarr;
515 OC::MessageContainer mc1;
516 mc1.addRepresentation(startRep);
518 OCRepPayload* cstart = mc1.getPayload();
519 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
524 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
525 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
526 cborData, cborSize));
527 OCPayloadDestroy((OCPayload*)cstart);
530 OC::MessageContainer mc2;
531 mc2.setPayload(cparsed);
532 EXPECT_EQ(1u, mc2.representations().size());
533 const OC::OCRepresentation& r = mc2.representations()[0];
536 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
537 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
538 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
539 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
540 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
542 EXPECT_EQ(iarr, iarr2);
543 EXPECT_EQ(darr, darr2);
544 EXPECT_EQ(barr, barr2);
545 EXPECT_EQ(strarr, strarr2);
546 EXPECT_EQ(objarr, objarr2);
547 OCPayloadDestroy(cparsed);
550 TEST(RepresentationEncoding, ThreeDVectorsJagged)
553 OC::OCRepresentation startRep;
555 OC::OCRepresentation subRep1;
556 OC::OCRepresentation subRep2;
557 OC::OCRepresentation subRep3;
558 subRep1.setNULL("NullAttr");
559 subRep1.setValue("IntAttr", 77);
560 subRep2.setValue("DoubleAttr", 3.333);
561 subRep2.setValue("BoolAttr", true);
562 subRep3.setValue("StringAttr", std::string("String attr"));
564 std::vector<std::vector<std::vector<int>>> iarr
568 {{13,14,15},{16,17,18}}
570 std::vector<std::vector<std::vector<double>>> darr
572 {{1.1,2.2,3.3},{4.4,5.5,6.6}},
573 {{7.7,8.7,9.7},{10.7,12.7}},
574 {{13.7,14.7,15.7},{16.7,17.7,18.7}}
576 std::vector<std::vector<std::vector<bool>>> barr
578 {{false, true},{true}},
579 {{false, true},{true, false}}
581 std::vector<std::vector<std::vector<std::string>>> strarr
583 {{"item1", "item2"},{"item3", "item4"}},
584 {{"item5", "item6"},{"item8"}},
585 {{"item9", "item10"},{"item11", ""}}
587 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
589 {{subRep1, subRep2},{subRep3, subRep1}},
590 {{subRep2, subRep3},{subRep2}},
594 startRep["iarr"] = iarr;
595 startRep["darr"] = darr;
596 startRep["barr"] = barr;
597 startRep["strarr"] = strarr;
598 startRep["objarr"] = objarr;
601 OC::MessageContainer mc1;
602 mc1.addRepresentation(startRep);
604 OCRepPayload* cstart = mc1.getPayload();
605 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
610 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
611 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
612 cborData, cborSize));
613 OCPayloadDestroy((OCPayload*)cstart);
616 OC::MessageContainer mc2;
617 mc2.setPayload(cparsed);
618 EXPECT_EQ(1u, mc2.representations().size());
619 const OC::OCRepresentation& r = mc2.representations()[0];
622 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
623 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
624 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
625 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
626 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
628 // Note: due to the way that the CSDK works, all 3d arrays need to be cuboidal.
629 // Since std::vector doesn't require this, items received on the other side end up
630 // being backfilled. This section removes the backfilling
631 iarr2[1][1].pop_back();
632 darr2[1][1].pop_back();
633 barr2[0][1].pop_back();
634 strarr2[1][1].pop_back();
635 objarr2[1][1].pop_back();
636 objarr2[2].pop_back();
638 EXPECT_EQ(iarr, iarr2);
639 EXPECT_EQ(darr, darr2);
640 EXPECT_EQ(barr, barr2);
641 EXPECT_EQ(strarr, strarr2);
642 EXPECT_EQ(objarr, objarr2);
643 OCPayloadDestroy(cparsed);
646 TEST(DiscoveryRTandIF, SingleItemNormal)
648 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
649 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
650 payload->sid = (uint8_t*)OICMalloc(16);
651 payload->resources = resource;
653 OCResourcePayloadAddResourceType(resource, "rt.singleitem");
654 OCResourcePayloadAddInterface(resource, "if.singleitem");
655 resource->uri = OICStrdup("/uri/thing");
661 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
662 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
663 cborData, cborSize));
665 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
666 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
668 EXPECT_EQ(NULL, parsedResource->next);
670 EXPECT_EQ(NULL, parsedResource->types->next);
671 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
672 EXPECT_EQ(NULL, parsedResource->interfaces->next);
673 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
676 OCPayloadDestroy(cparsed);
677 OCDiscoveryPayloadDestroy(payload);
680 TEST(DiscoveryRTandIF, SingleItemFrontTrim)
682 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
683 payload->sid = (uint8_t*)OICMalloc(16);
684 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
685 payload->resources = resource;
687 OCResourcePayloadAddResourceType(resource, " rt.singleitem");
688 OCResourcePayloadAddInterface(resource, " if.singleitem");
689 resource->uri = OICStrdup("/uri/thing");
695 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
696 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
697 cborData, cborSize));
699 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
700 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
702 EXPECT_EQ(NULL, parsedResource->next);
704 EXPECT_EQ(NULL, parsedResource->types->next);
705 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
706 EXPECT_EQ(NULL, parsedResource->interfaces->next);
707 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
710 OCPayloadDestroy(cparsed);
711 OCDiscoveryPayloadDestroy(payload);
713 TEST(DiscoveryRTandIF, SingleItemBackTrim)
715 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
716 payload->sid = (uint8_t*)OICMalloc(16);
717 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
718 payload->resources = resource;
720 OCResourcePayloadAddResourceType(resource, "rt.singleitem ");
721 OCResourcePayloadAddInterface(resource, "if.singleitem ");
722 resource->uri = OICStrdup("/uri/thing");
728 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
729 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
730 cborData, cborSize));
732 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
733 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
735 EXPECT_EQ(NULL, parsedResource->next);
737 EXPECT_EQ(NULL, parsedResource->types->next);
738 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
739 EXPECT_EQ(NULL, parsedResource->interfaces->next);
740 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
743 OCPayloadDestroy(cparsed);
744 OCDiscoveryPayloadDestroy(payload);
746 TEST(DiscoveryRTandIF, SingleItemBothTrim)
748 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
749 payload->sid = (uint8_t*)OICMalloc(16);
750 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
751 payload->resources = resource;
753 OCResourcePayloadAddResourceType(resource, " rt.singleitem ");
754 OCResourcePayloadAddInterface(resource, " if.singleitem ");
755 resource->uri = OICStrdup("/uri/thing");
761 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
762 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
763 cborData, cborSize));
765 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
766 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
768 EXPECT_EQ(NULL, parsedResource->next);
770 EXPECT_EQ(NULL, parsedResource->types->next);
771 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
772 EXPECT_EQ(NULL, parsedResource->interfaces->next);
773 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
776 OCPayloadDestroy(cparsed);
777 OCDiscoveryPayloadDestroy(payload);
779 TEST(DiscoveryRTandIF, MultiItemsNormal)
781 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
782 payload->sid = (uint8_t*)OICMalloc(16);
783 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
784 payload->resources = resource;
786 OCResourcePayloadAddResourceType(resource, "rt.firstitem");
787 OCResourcePayloadAddResourceType(resource, "rt.seconditem");
788 OCResourcePayloadAddInterface(resource, "if.firstitem");
789 OCResourcePayloadAddInterface(resource, "if.seconditem");
790 resource->uri = OICStrdup("/uri/thing");
796 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
797 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
798 cborData, cborSize));
800 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
801 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
803 EXPECT_EQ(NULL, parsedResource->next);
805 EXPECT_EQ(NULL, parsedResource->types->next->next);
806 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
807 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
808 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
809 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
810 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
813 OCPayloadDestroy(cparsed);
814 OCDiscoveryPayloadDestroy(payload);
816 TEST(DiscoveryRTandIF, MultiItemExtraLeadSpaces)
818 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
819 payload->sid = (uint8_t*)OICMalloc(16);
820 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
821 payload->resources = resource;
823 OCResourcePayloadAddResourceType(resource, " rt.firstitem");
824 OCResourcePayloadAddResourceType(resource, " rt.seconditem");
825 OCResourcePayloadAddInterface(resource, " if.firstitem");
826 OCResourcePayloadAddInterface(resource, " if.seconditem");
827 resource->uri = OICStrdup("/uri/thing");
833 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
834 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
835 cborData, cborSize));
837 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
838 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
840 EXPECT_EQ(NULL, parsedResource->next);
842 EXPECT_EQ(NULL, parsedResource->types->next->next);
843 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
844 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
845 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
846 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
847 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
850 OCPayloadDestroy(cparsed);
851 OCDiscoveryPayloadDestroy(payload);
853 TEST(DiscoveryRTandIF, MultiItemExtraTrailSpaces)
855 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
856 payload->sid = (uint8_t*)OICMalloc(16);
857 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
858 payload->resources = resource;
860 OCResourcePayloadAddResourceType(resource, "rt.firstitem ");
861 OCResourcePayloadAddResourceType(resource, "rt.seconditem ");
862 OCResourcePayloadAddInterface(resource, "if.firstitem ");
863 OCResourcePayloadAddInterface(resource, "if.seconditem ");
864 resource->uri = OICStrdup("/uri/thing");
870 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
871 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
872 cborData, cborSize));
874 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
875 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
877 EXPECT_EQ(NULL, parsedResource->next);
879 EXPECT_EQ(NULL, parsedResource->types->next->next);
880 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
881 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
882 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
883 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
884 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
887 OCPayloadDestroy(cparsed);
888 OCDiscoveryPayloadDestroy(payload);
890 TEST(DiscoveryRTandIF, MultiItemBothSpaces)
892 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
893 payload->sid = (uint8_t*)OICMalloc(16);
894 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
895 payload->resources = resource;
897 OCResourcePayloadAddResourceType(resource, " rt.firstitem ");
898 OCResourcePayloadAddResourceType(resource, " rt.seconditem ");
899 OCResourcePayloadAddInterface(resource, " if.firstitem ");
900 OCResourcePayloadAddInterface(resource, " if.seconditem ");
901 resource->uri = OICStrdup("/uri/thing");
907 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
908 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
909 cborData, cborSize));
911 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
912 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
914 EXPECT_EQ(NULL, parsedResource->next);
916 EXPECT_EQ(NULL, parsedResource->types->next->next);
917 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
918 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
919 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
920 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
921 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
924 OCPayloadDestroy(cparsed);
925 OCDiscoveryPayloadDestroy(payload);
927 TEST(RepresentationEncodingRTandIF, SingleItemNormal)
929 OCRepPayload* payload = OCRepPayloadCreate();
930 OCRepPayloadAddResourceType(payload, "rt.firstitem");
931 OCRepPayloadAddInterface(payload, "if.firstitem");
937 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
938 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
939 cborData, cborSize));
941 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
943 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
944 EXPECT_EQ(NULL, parsedPayload->types->next);
945 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
946 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
950 OCRepPayloadDestroy(payload);
951 OCPayloadDestroy(cparsed);
953 TEST(RepresentationEncodingRTandIF, SingleItemFrontTrim)
955 OCRepPayload* payload = OCRepPayloadCreate();
956 OCRepPayloadAddResourceType(payload, " rt.firstitem");
957 OCRepPayloadAddInterface(payload, " if.firstitem");
963 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
964 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
965 cborData, cborSize));
967 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
969 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
970 EXPECT_EQ(NULL, parsedPayload->types->next);
971 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
972 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
976 OCRepPayloadDestroy(payload);
977 OCPayloadDestroy(cparsed);
979 TEST(RepresentationEncodingRTandIF, SingleItemBackTrim)
981 OCRepPayload* payload = OCRepPayloadCreate();
982 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
983 OCRepPayloadAddInterface(payload, "if.firstitem ");
989 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
990 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
991 cborData, cborSize));
993 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
995 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
996 EXPECT_EQ(NULL, parsedPayload->types->next);
997 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
998 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1002 OCRepPayloadDestroy(payload);
1003 OCPayloadDestroy(cparsed);
1005 TEST(RepresentationEncodingRTandIF, SingleItemBothTrim)
1007 OCRepPayload* payload = OCRepPayloadCreate();
1008 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1009 OCRepPayloadAddInterface(payload, " if.firstitem ");
1015 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1016 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1017 cborData, cborSize));
1019 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1021 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1022 EXPECT_EQ(NULL, parsedPayload->types->next);
1023 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1024 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1028 OCRepPayloadDestroy(payload);
1029 OCPayloadDestroy(cparsed);
1031 TEST(RepresentationEncodingRTandIF, MultiItemsNormal)
1033 OCRepPayload* payload = OCRepPayloadCreate();
1034 OCRepPayloadAddResourceType(payload, "rt.firstitem");
1035 OCRepPayloadAddResourceType(payload, "rt.seconditem");
1036 OCRepPayloadAddInterface(payload, "if.firstitem");
1037 OCRepPayloadAddInterface(payload, "if.seconditem");
1043 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1044 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1045 cborData, cborSize));
1047 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1049 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1050 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1051 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1052 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1053 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1054 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1058 OCRepPayloadDestroy(payload);
1059 OCPayloadDestroy(cparsed);
1061 TEST(RepresentationEncodingRTandIF, MultiItemExtraLeadSpaces)
1063 OCRepPayload* payload = OCRepPayloadCreate();
1064 OCRepPayloadAddResourceType(payload, " rt.firstitem");
1065 OCRepPayloadAddResourceType(payload, " rt.seconditem");
1066 OCRepPayloadAddInterface(payload, " if.firstitem");
1067 OCRepPayloadAddInterface(payload, " if.seconditem");
1073 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1074 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1075 cborData, cborSize));
1077 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1079 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1080 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1081 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1082 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1083 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1084 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1088 OCRepPayloadDestroy(payload);
1089 OCPayloadDestroy(cparsed);
1091 TEST(RepresentationEncodingRTandIF, MultiItemExtraTrailSpaces)
1093 OCRepPayload* payload = OCRepPayloadCreate();
1094 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
1095 OCRepPayloadAddResourceType(payload, "rt.seconditem ");
1096 OCRepPayloadAddInterface(payload, "if.firstitem ");
1097 OCRepPayloadAddInterface(payload, "if.seconditem ");
1103 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1104 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1105 cborData, cborSize));
1107 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1109 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1110 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1111 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1112 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1113 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1114 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1118 OCRepPayloadDestroy(payload);
1119 OCPayloadDestroy(cparsed);
1121 TEST(RepresentationEncodingRTandIF, MultiItemExtraMiddleSpaces)
1123 OCRepPayload* payload = OCRepPayloadCreate();
1124 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1125 OCRepPayloadAddResourceType(payload, " rt.seconditem ");
1126 OCRepPayloadAddInterface(payload, " if.firstitem ");
1127 OCRepPayloadAddInterface(payload, " if.seconditem ");
1133 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1134 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1135 cborData, cborSize));
1137 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1139 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1140 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1141 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1142 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1143 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1144 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1148 OCRepPayloadDestroy(payload);
1149 OCPayloadDestroy(cparsed);