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>
31 bool operator==(const OC::NullType&, const OC::NullType&)
36 bool operator==(const OC::OCRepresentation& lhs, const OC::OCRepresentation& rhs)
38 return lhs.getUri() == rhs.getUri() &&
39 lhs.getChildren() == rhs.getChildren() &&
40 lhs.getResourceInterfaces() == rhs.getResourceInterfaces() &&
41 lhs.getResourceTypes() == rhs.getResourceTypes() &&
42 lhs.m_values == rhs.m_values;
45 // these tests validate the OCRepresentation->OCPayload, OCPayload->CBOR,
46 // CBOR->OCPayload and OCPayload->OCRepresentation conversions
47 namespace OCRepresentationEncodingTest
50 static const char uri1[] = "/testuri";
51 static const uint8_t sid1[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
52 static const char devicename1[] = "device name";
53 static const char specver1[] = "spec version";
54 static const char dmver1[] = "data model version";
56 TEST(DeviceDiscoveryEncoding, Normal)
58 OCDevicePayload* device = OCDevicePayloadCreate(
65 EXPECT_STREQ(uri1, device->uri);
66 EXPECT_STREQ(devicename1, device->deviceName);
67 EXPECT_STREQ(specver1, device->specVersion);
68 EXPECT_STREQ(dmver1, device->dataModelVersion);
69 EXPECT_EQ(PAYLOAD_TYPE_DEVICE, ((OCPayload*)device)->type);
71 for (uint8_t i = 1; i <= sizeof(sid1); ++i)
73 EXPECT_EQ(i, sid1[i - 1]);
78 OCPayload* parsedDevice;
79 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)device, &cborData, &cborSize));
80 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedDevice, PAYLOAD_TYPE_DEVICE,
84 EXPECT_STREQ(device->uri, ((OCDevicePayload*)parsedDevice)->uri);
85 EXPECT_STREQ(device->deviceName, ((OCDevicePayload*)parsedDevice)->deviceName);
86 EXPECT_STREQ(device->specVersion, ((OCDevicePayload*)parsedDevice)->specVersion);
87 EXPECT_STREQ(device->dataModelVersion, ((OCDevicePayload*)parsedDevice)->dataModelVersion);
88 EXPECT_EQ(device->base.type, ((OCDevicePayload*)parsedDevice)->base.type);
90 OCPayloadDestroy((OCPayload*)device);
92 OC::MessageContainer mc;
93 mc.setPayload(parsedDevice);
94 EXPECT_EQ(1u, mc.representations().size());
95 const OC::OCRepresentation& r = mc.representations()[0];
96 EXPECT_STREQ(uri1, r.getUri().c_str());
97 EXPECT_STREQ(devicename1, r.getValue<std::string>(OC_RSRVD_DEVICE_NAME).c_str());
98 EXPECT_STREQ(specver1, r.getValue<std::string>(OC_RSRVD_SPEC_VERSION).c_str());
99 EXPECT_STREQ(dmver1, r.getValue<std::string>(OC_RSRVD_DATA_MODEL_VERSION).c_str());
102 OCPayloadDestroy(parsedDevice);
105 static char pfid1[] = "pfid";
106 static char mfgnm1[] = "mfgnm";
107 static char mfgurl1[] = "mfgurl";
108 static char modelnum1[] = "modelnum";
109 static char dom1[] = "dom";
110 static char pfver1[] = "pfver";
111 static char osver1[] = "osver";
112 static char hwver1[] = "hwver";
113 static char fwver1[] = "fwver";
114 static char url1[] = "url";
115 static char time1[] = "time";
118 TEST(PlatformDiscoveryEncoding, Normal)
120 OCPlatformInfo info {pfid1, mfgnm1, mfgurl1, modelnum1, dom1, pfver1, osver1, hwver1,
121 fwver1, url1, time1};
122 OCPlatformPayload* platform = OCPlatformPayloadCreate(uri1, &info);
123 EXPECT_EQ(PAYLOAD_TYPE_PLATFORM, ((OCPayload*)platform)->type);
124 EXPECT_STREQ(uri1, platform->uri);
125 EXPECT_STREQ(pfid1, platform->info.platformID);
126 EXPECT_STREQ(mfgnm1, platform->info.manufacturerName);
127 EXPECT_STREQ(mfgurl1, platform->info.manufacturerUrl);
128 EXPECT_STREQ(modelnum1, platform->info.modelNumber);
129 EXPECT_STREQ(dom1, platform->info.dateOfManufacture);
130 EXPECT_STREQ(pfver1, platform->info.platformVersion);
131 EXPECT_STREQ(osver1, platform->info.operatingSystemVersion);
132 EXPECT_STREQ(hwver1, platform->info.hardwareVersion);
133 EXPECT_STREQ(fwver1, platform->info.firmwareVersion);
134 EXPECT_STREQ(url1, platform->info.supportUrl);
135 EXPECT_STREQ(time1, platform->info.systemTime);
139 OCPayload* parsedPlatform;
140 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)platform, &cborData, &cborSize));
141 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedPlatform, PAYLOAD_TYPE_PLATFORM,
142 cborData, cborSize));
145 EXPECT_EQ(platform->base.type, ((OCPlatformPayload*)parsedPlatform)->base.type);
146 OCPlatformPayload* platform2 = (OCPlatformPayload*)parsedPlatform;
147 EXPECT_STREQ(platform->uri, platform2->uri);
148 EXPECT_STREQ(platform->info.platformID, platform2->info.platformID);
149 EXPECT_STREQ(platform->info.manufacturerName, platform->info.manufacturerName);
150 EXPECT_STREQ(platform->info.manufacturerUrl, platform->info.manufacturerUrl);
151 EXPECT_STREQ(platform->info.modelNumber, platform->info.modelNumber);
152 EXPECT_STREQ(platform->info.dateOfManufacture, platform->info.dateOfManufacture);
153 EXPECT_STREQ(platform->info.platformVersion, platform->info.platformVersion);
154 EXPECT_STREQ(platform->info.operatingSystemVersion, platform->info.operatingSystemVersion);
155 EXPECT_STREQ(platform->info.hardwareVersion, platform->info.hardwareVersion);
156 EXPECT_STREQ(platform->info.firmwareVersion, platform->info.firmwareVersion);
157 EXPECT_STREQ(platform->info.supportUrl, platform->info.supportUrl);
158 EXPECT_STREQ(platform->info.systemTime, platform2->info.systemTime);
160 OCPayloadDestroy((OCPayload*)platform);
162 OC::MessageContainer mc;
163 mc.setPayload(parsedPlatform);
164 EXPECT_EQ(1u, mc.representations().size());
165 const OC::OCRepresentation& r = mc.representations()[0];
166 EXPECT_STREQ(uri1, r.getUri().c_str());
167 EXPECT_STREQ(pfid1, r.getValue<std::string>(OC_RSRVD_PLATFORM_ID).c_str());
168 EXPECT_STREQ(mfgnm1, r.getValue<std::string>(OC_RSRVD_MFG_NAME).c_str());
169 EXPECT_STREQ(mfgurl1, r.getValue<std::string>(OC_RSRVD_MFG_URL).c_str());
170 EXPECT_STREQ(modelnum1, r.getValue<std::string>(OC_RSRVD_MODEL_NUM).c_str());
171 EXPECT_STREQ(dom1, r.getValue<std::string>(OC_RSRVD_MFG_DATE).c_str());
172 EXPECT_STREQ(pfver1, r.getValue<std::string>(OC_RSRVD_PLATFORM_VERSION).c_str());
173 EXPECT_STREQ(osver1, r.getValue<std::string>(OC_RSRVD_OS_VERSION).c_str());
174 EXPECT_STREQ(hwver1, r.getValue<std::string>(OC_RSRVD_HARDWARE_VERSION).c_str());
175 EXPECT_STREQ(fwver1, r.getValue<std::string>(OC_RSRVD_FIRMWARE_VERSION).c_str());
176 EXPECT_STREQ(url1, r.getValue<std::string>(OC_RSRVD_SUPPORT_URL).c_str());
177 EXPECT_STREQ(time1, r.getValue<std::string>(OC_RSRVD_SYSTEM_TIME).c_str());
179 OCPayloadDestroy(parsedPlatform);
182 // Representation Payloads
183 TEST(RepresentationEncoding, BaseAttributeTypes)
185 OC::OCRepresentation startRep;
186 startRep.setNULL("NullAttr");
187 startRep.setValue("IntAttr", 77);
188 startRep.setValue("DoubleAttr", 3.333);
189 startRep.setValue("BoolAttr", true);
190 startRep.setValue("StringAttr", std::string("String attr"));
191 OC::MessageContainer mc1;
192 mc1.addRepresentation(startRep);
194 OCRepPayload* cstart = mc1.getPayload();
195 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
200 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
201 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
202 cborData, cborSize));
203 OCPayloadDestroy((OCPayload*)cstart);
206 OC::MessageContainer mc2;
207 mc2.setPayload(cparsed);
208 EXPECT_EQ(1u, mc2.representations().size());
209 const OC::OCRepresentation& r = mc2.representations()[0];
211 EXPECT_TRUE(r.isNULL("NullAttr"));
212 EXPECT_EQ(77, r.getValue<int>("IntAttr"));
213 EXPECT_EQ(3.333, r.getValue<double>("DoubleAttr"));
214 EXPECT_EQ(true, r.getValue<bool>("BoolAttr"));
215 EXPECT_STREQ("String attr", r.getValue<std::string>("StringAttr").c_str());
217 OCPayloadDestroy(cparsed);
220 TEST(RepresentationEncoding, RepAttribute)
222 OC::OCRepresentation startRep;
223 OC::OCRepresentation subRep;
224 subRep.setNULL("NullAttr");
225 subRep.setValue("IntAttr", 77);
226 subRep.setValue("DoubleAttr", 3.333);
227 subRep.setValue("BoolAttr", true);
228 subRep.setValue("StringAttr", std::string("String attr"));
229 startRep.setValue("Sub", subRep);
231 OC::MessageContainer mc1;
232 mc1.addRepresentation(startRep);
234 OCRepPayload* cstart = mc1.getPayload();
235 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
240 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
241 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
242 cborData, cborSize));
243 OCPayloadDestroy((OCPayload*)cstart);
246 OC::MessageContainer mc2;
247 mc2.setPayload(cparsed);
248 EXPECT_EQ(1u, mc2.representations().size());
249 const OC::OCRepresentation& r = mc2.representations()[0];
251 OC::OCRepresentation newSubRep = r["Sub"];
253 EXPECT_TRUE(newSubRep.isNULL("NullAttr"));
254 EXPECT_EQ(77, newSubRep.getValue<int>("IntAttr"));
255 EXPECT_EQ(3.333, newSubRep.getValue<double>("DoubleAttr"));
256 EXPECT_EQ(true, newSubRep.getValue<bool>("BoolAttr"));
257 EXPECT_STREQ("String attr", newSubRep.getValue<std::string>("StringAttr").c_str());
258 OCPayloadDestroy(cparsed);
261 TEST(RepresentationEncoding, OneDVectors)
264 OC::OCRepresentation startRep;
266 OC::OCRepresentation subRep1;
267 OC::OCRepresentation subRep2;
268 OC::OCRepresentation subRep3;
269 subRep1.setNULL("NullAttr");
270 subRep1.setValue("IntAttr", 77);
271 subRep2.setValue("DoubleAttr", 3.333);
272 subRep2.setValue("BoolAttr", true);
273 subRep3.setValue("StringAttr", std::string("String attr"));
275 std::vector<int> iarr {1,2,3,4,5,6,7,8,9};
276 std::vector<double> darr {1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9};
277 std::vector<bool> barr {false, true, false, false, true, true};
278 std::vector<std::string> strarr {"item1", "item2", "item3", "item4"};
279 std::vector<OC::OCRepresentation> objarr {subRep1, subRep2, subRep3};
281 startRep["iarr"] = iarr;
282 startRep["darr"] = darr;
283 startRep["barr"] = barr;
284 startRep["strarr"] = strarr;
285 startRep["objarr"] = objarr;
288 OC::MessageContainer mc1;
289 mc1.addRepresentation(startRep);
291 OCRepPayload* cstart = mc1.getPayload();
292 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
297 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
298 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
299 cborData, cborSize));
300 OCPayloadDestroy((OCPayload*)cstart);
303 OC::MessageContainer mc2;
304 mc2.setPayload(cparsed);
305 EXPECT_EQ(1u, mc2.representations().size());
306 const OC::OCRepresentation& r = mc2.representations()[0];
309 std::vector<int> iarr2 = r["iarr"];
310 std::vector<double> darr2 = r["darr"];
311 std::vector<bool> barr2 = r["barr"];
312 std::vector<std::string> strarr2 = r["strarr"];
313 std::vector<OC::OCRepresentation> objarr2 = r["objarr"];
315 EXPECT_EQ(iarr, iarr2);
316 EXPECT_EQ(darr, darr2);
317 EXPECT_EQ(barr, barr2);
318 EXPECT_EQ(strarr, strarr2);
319 EXPECT_EQ(objarr, objarr2);
320 OCPayloadDestroy(cparsed);
323 TEST(RepresentationEncoding, TwoDVectors)
326 OC::OCRepresentation startRep;
328 OC::OCRepresentation subRep1;
329 OC::OCRepresentation subRep2;
330 OC::OCRepresentation subRep3;
331 subRep1.setNULL("NullAttr");
332 subRep1.setValue("IntAttr", 77);
333 subRep2.setValue("DoubleAttr", 3.333);
334 subRep2.setValue("BoolAttr", true);
335 subRep3.setValue("StringAttr", std::string("String attr"));
337 std::vector<std::vector<int>> iarr {{1,2,3},{4,5,6},{7,8,9}};
338 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{7.7,8.8,9.9}};
339 std::vector<std::vector<bool>> barr {{false, true}, {false, false}, {true, true}};
340 std::vector<std::vector<std::string>> strarr {{"item1", "item2"}, {"item3", "item4"}};
341 std::vector<std::vector<OC::OCRepresentation>> objarr
342 {{subRep1, subRep2, subRep3}, {subRep3, subRep2, subRep1}};
344 startRep["iarr"] = iarr;
345 startRep["darr"] = darr;
346 startRep["barr"] = barr;
347 startRep["strarr"] = strarr;
348 startRep["objarr"] = objarr;
351 OC::MessageContainer mc1;
352 mc1.addRepresentation(startRep);
354 OCRepPayload* cstart = mc1.getPayload();
355 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
360 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
361 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
362 cborData, cborSize));
363 OCPayloadDestroy((OCPayload*)cstart);
366 OC::MessageContainer mc2;
367 mc2.setPayload(cparsed);
368 EXPECT_EQ(1u, mc2.representations().size());
369 const OC::OCRepresentation& r = mc2.representations()[0];
372 std::vector<std::vector<int>> iarr2 = r["iarr"];
373 std::vector<std::vector<double>> darr2 = r["darr"];
374 std::vector<std::vector<bool>> barr2 = r["barr"];
375 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
376 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
378 EXPECT_EQ(iarr, iarr2);
379 EXPECT_EQ(darr, darr2);
380 EXPECT_EQ(barr, barr2);
381 EXPECT_EQ(strarr, strarr2);
382 EXPECT_EQ(objarr, objarr2);
383 OCPayloadDestroy(cparsed);
386 TEST(RepresentationEncoding, TwoDVectorsJagged)
389 OC::OCRepresentation startRep;
391 OC::OCRepresentation subRep1;
392 OC::OCRepresentation subRep2;
393 OC::OCRepresentation subRep3;
394 subRep1.setNULL("NullAttr");
395 subRep1.setValue("IntAttr", 77);
396 subRep2.setValue("DoubleAttr", 3.333);
397 subRep2.setValue("BoolAttr", true);
398 subRep3.setValue("StringAttr", std::string("String attr"));
400 std::vector<std::vector<int>> iarr {{1,2,3},{4,6},{7,8,9}};
401 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{8.8,9.9}};
402 std::vector<std::vector<bool>> barr {{false, true}, {false}, {true, true}};
403 std::vector<std::vector<std::string>> strarr {{"item1"}, {"item3", "item4"}};
404 std::vector<std::vector<OC::OCRepresentation>> objarr
405 {{subRep1, subRep3}, {subRep3, subRep2, subRep1}};
407 startRep["iarr"] = iarr;
408 startRep["darr"] = darr;
409 startRep["barr"] = barr;
410 startRep["strarr"] = strarr;
411 startRep["objarr"] = objarr;
414 OC::MessageContainer mc1;
415 mc1.addRepresentation(startRep);
417 OCRepPayload* cstart = mc1.getPayload();
418 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
423 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
424 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
425 cborData, cborSize));
426 OCPayloadDestroy((OCPayload*)cstart);
429 OC::MessageContainer mc2;
430 mc2.setPayload(cparsed);
431 EXPECT_EQ(1u, mc2.representations().size());
432 const OC::OCRepresentation& r = mc2.representations()[0];
435 std::vector<std::vector<int>> iarr2 = r["iarr"];
436 std::vector<std::vector<double>> darr2 = r["darr"];
437 std::vector<std::vector<bool>> barr2 = r["barr"];
438 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
439 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
441 // Note: due to the way that the CSDK works, all 2d arrays need to be rectangular.
442 // Since std::vector doesn't require this, items received on the other side end up
443 // being backfilled. This section removes the backfilling
447 strarr2[0].pop_back();
448 objarr2[0].pop_back();
450 EXPECT_EQ(iarr, iarr2);
451 EXPECT_EQ(darr, darr2);
452 EXPECT_EQ(barr, barr2);
453 EXPECT_EQ(strarr, strarr2);
454 EXPECT_EQ(objarr, objarr2);
455 OCPayloadDestroy(cparsed);
458 TEST(RepresentationEncoding, ThreeDVectors)
461 OC::OCRepresentation startRep;
463 OC::OCRepresentation subRep1;
464 OC::OCRepresentation subRep2;
465 OC::OCRepresentation subRep3;
466 subRep1.setNULL("NullAttr");
467 subRep1.setValue("IntAttr", 77);
468 subRep2.setValue("DoubleAttr", 3.333);
469 subRep2.setValue("BoolAttr", true);
470 subRep3.setValue("StringAttr", std::string("String attr"));
472 std::vector<std::vector<std::vector<int>>> iarr
473 {{{1,2,3},{4,5,6}},{{7,8,9},{10,11,12}},{{13,14,15},{16,17,18}}};
474 std::vector<std::vector<std::vector<double>>> darr
475 {{{1.1,2.2,3.3},{4.4,5.5,6.6}},
476 {{7.7,8.7,9.7},{10.7,11.7,12.7}},
477 {{13.7,14.7,15.7},{16.7,17.7,18.7}}};
478 std::vector<std::vector<std::vector<bool>>> barr
479 {{{false, true},{true, false}},{{false, true},{true, false}}};
480 std::vector<std::vector<std::vector<std::string>>> strarr
482 {{"item1", "item2"},{"item3", "item4"}},
483 {{"item5", "item6"},{"item7", "item8"}},
484 {{"item9", "item10"},{"item11", ""}}
486 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
488 {{subRep1, subRep2},{subRep3, subRep1}},
489 {{subRep2, subRep3},{subRep2, subRep1}},
490 {{subRep3, subRep2},{subRep1, subRep2}}
493 startRep["iarr"] = iarr;
494 startRep["darr"] = darr;
495 startRep["barr"] = barr;
496 startRep["strarr"] = strarr;
497 startRep["objarr"] = objarr;
500 OC::MessageContainer mc1;
501 mc1.addRepresentation(startRep);
503 OCRepPayload* cstart = mc1.getPayload();
504 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
509 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
510 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
511 cborData, cborSize));
512 OCPayloadDestroy((OCPayload*)cstart);
515 OC::MessageContainer mc2;
516 mc2.setPayload(cparsed);
517 EXPECT_EQ(1u, mc2.representations().size());
518 const OC::OCRepresentation& r = mc2.representations()[0];
521 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
522 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
523 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
524 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
525 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
527 EXPECT_EQ(iarr, iarr2);
528 EXPECT_EQ(darr, darr2);
529 EXPECT_EQ(barr, barr2);
530 EXPECT_EQ(strarr, strarr2);
531 EXPECT_EQ(objarr, objarr2);
532 OCPayloadDestroy(cparsed);
535 TEST(RepresentationEncoding, ThreeDVectorsJagged)
538 OC::OCRepresentation startRep;
540 OC::OCRepresentation subRep1;
541 OC::OCRepresentation subRep2;
542 OC::OCRepresentation subRep3;
543 subRep1.setNULL("NullAttr");
544 subRep1.setValue("IntAttr", 77);
545 subRep2.setValue("DoubleAttr", 3.333);
546 subRep2.setValue("BoolAttr", true);
547 subRep3.setValue("StringAttr", std::string("String attr"));
549 std::vector<std::vector<std::vector<int>>> iarr
553 {{13,14,15},{16,17,18}}
555 std::vector<std::vector<std::vector<double>>> darr
557 {{1.1,2.2,3.3},{4.4,5.5,6.6}},
558 {{7.7,8.7,9.7},{10.7,12.7}},
559 {{13.7,14.7,15.7},{16.7,17.7,18.7}}
561 std::vector<std::vector<std::vector<bool>>> barr
563 {{false, true},{true}},
564 {{false, true},{true, false}}
566 std::vector<std::vector<std::vector<std::string>>> strarr
568 {{"item1", "item2"},{"item3", "item4"}},
569 {{"item5", "item6"},{"item8"}},
570 {{"item9", "item10"},{"item11", ""}}
572 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
574 {{subRep1, subRep2},{subRep3, subRep1}},
575 {{subRep2, subRep3},{subRep2}},
579 startRep["iarr"] = iarr;
580 startRep["darr"] = darr;
581 startRep["barr"] = barr;
582 startRep["strarr"] = strarr;
583 startRep["objarr"] = objarr;
586 OC::MessageContainer mc1;
587 mc1.addRepresentation(startRep);
589 OCRepPayload* cstart = mc1.getPayload();
590 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
595 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
596 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
597 cborData, cborSize));
598 OCPayloadDestroy((OCPayload*)cstart);
601 OC::MessageContainer mc2;
602 mc2.setPayload(cparsed);
603 EXPECT_EQ(1u, mc2.representations().size());
604 const OC::OCRepresentation& r = mc2.representations()[0];
607 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
608 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
609 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
610 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
611 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
613 // Note: due to the way that the CSDK works, all 3d arrays need to be cuboidal.
614 // Since std::vector doesn't require this, items received on the other side end up
615 // being backfilled. This section removes the backfilling
616 iarr2[1][1].pop_back();
617 darr2[1][1].pop_back();
618 barr2[0][1].pop_back();
619 strarr2[1][1].pop_back();
620 objarr2[1][1].pop_back();
621 objarr2[2].pop_back();
623 EXPECT_EQ(iarr, iarr2);
624 EXPECT_EQ(darr, darr2);
625 EXPECT_EQ(barr, barr2);
626 EXPECT_EQ(strarr, strarr2);
627 EXPECT_EQ(objarr, objarr2);
628 OCPayloadDestroy(cparsed);