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>
26 #include <ocpayload.h>
27 #include <ocpayloadcbor.h>
28 #include <oic_malloc.h>
29 #include <oic_string.h>
30 #include "payload_logging.h"
34 bool operator==(const OC::NullType&, const OC::NullType&)
39 bool operator==(const OC::OCRepresentation& lhs, const OC::OCRepresentation& rhs)
41 return lhs.getUri() == rhs.getUri() &&
42 lhs.getChildren() == rhs.getChildren() &&
43 lhs.getResourceInterfaces() == rhs.getResourceInterfaces() &&
44 lhs.getResourceTypes() == rhs.getResourceTypes() &&
45 lhs.m_values == rhs.m_values;
48 // these tests validate the OCRepresentation->OCPayload, OCPayload->CBOR,
49 // CBOR->OCPayload and OCPayload->OCRepresentation conversions
50 namespace OCRepresentationEncodingTest
52 static const char *sid1 = OCGetServerInstanceIDString();
53 static const char devicename1[] = "device name";
54 static const char specver1[] = "spec version";
55 static const char dmver1[] = "data model version";
57 TEST(DeviceDiscoveryEncoding, Normal)
59 OCDevicePayload* device = OCDevicePayloadCreate(
64 EXPECT_STREQ(sid1, device->sid);
65 EXPECT_STREQ(devicename1, device->deviceName);
66 EXPECT_STREQ(specver1, device->specVersion);
67 EXPECT_STREQ(dmver1, device->dataModelVersion);
68 EXPECT_EQ(PAYLOAD_TYPE_DEVICE, ((OCPayload*)device)->type);
72 OCPayload* parsedDevice;
73 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)device, &cborData, &cborSize));
74 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedDevice, PAYLOAD_TYPE_DEVICE,
78 EXPECT_STREQ(device->sid, ((OCDevicePayload*)parsedDevice)->sid);
79 EXPECT_STREQ(device->deviceName, ((OCDevicePayload*)parsedDevice)->deviceName);
80 EXPECT_STREQ(device->specVersion, ((OCDevicePayload*)parsedDevice)->specVersion);
81 EXPECT_STREQ(device->dataModelVersion, ((OCDevicePayload*)parsedDevice)->dataModelVersion);
82 EXPECT_EQ(device->base.type, ((OCDevicePayload*)parsedDevice)->base.type);
84 OCPayloadDestroy((OCPayload*)device);
86 OC::MessageContainer mc;
87 mc.setPayload(parsedDevice);
88 EXPECT_EQ(1u, mc.representations().size());
89 const OC::OCRepresentation& r = mc.representations()[0];
90 EXPECT_STREQ(sid1, r.getValue<std::string>(OC_RSRVD_DEVICE_ID).c_str());
91 EXPECT_STREQ(devicename1, r.getValue<std::string>(OC_RSRVD_DEVICE_NAME).c_str());
92 EXPECT_STREQ(specver1, r.getValue<std::string>(OC_RSRVD_SPEC_VERSION).c_str());
93 EXPECT_STREQ(dmver1, r.getValue<std::string>(OC_RSRVD_DATA_MODEL_VERSION).c_str());
95 OCPayloadDestroy(parsedDevice);
98 static const char uri1[] = "/testuri";
99 static char pfid1[] = "pfid";
100 static char mfgnm1[] = "mfgnm";
101 static char mfgurl1[] = "mfgurl";
102 static char modelnum1[] = "modelnum";
103 static char dom1[] = "dom";
104 static char pfver1[] = "pfver";
105 static char osver1[] = "osver";
106 static char hwver1[] = "hwver";
107 static char fwver1[] = "fwver";
108 static char url1[] = "url";
109 static char time1[] = "time";
112 TEST(PlatformDiscoveryEncoding, Normal)
114 OCPlatformInfo info {pfid1, mfgnm1, mfgurl1, modelnum1, dom1, pfver1, osver1, hwver1,
115 fwver1, url1, time1};
116 OCPlatformPayload* platform = OCPlatformPayloadCreate(&info);
117 EXPECT_EQ(PAYLOAD_TYPE_PLATFORM, ((OCPayload*)platform)->type);
118 EXPECT_STREQ(pfid1, platform->info.platformID);
119 EXPECT_STREQ(mfgnm1, platform->info.manufacturerName);
120 EXPECT_STREQ(mfgurl1, platform->info.manufacturerUrl);
121 EXPECT_STREQ(modelnum1, platform->info.modelNumber);
122 EXPECT_STREQ(dom1, platform->info.dateOfManufacture);
123 EXPECT_STREQ(pfver1, platform->info.platformVersion);
124 EXPECT_STREQ(osver1, platform->info.operatingSystemVersion);
125 EXPECT_STREQ(hwver1, platform->info.hardwareVersion);
126 EXPECT_STREQ(fwver1, platform->info.firmwareVersion);
127 EXPECT_STREQ(url1, platform->info.supportUrl);
128 EXPECT_STREQ(time1, platform->info.systemTime);
129 EXPECT_STREQ(OC_RSRVD_INTERFACE_READ, platform->interfaces->value);
130 EXPECT_STREQ(OC_RSRVD_RESOURCE_TYPE_PLATFORM, platform->rt);
134 OCPayload* parsedPlatform;
135 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)platform, &cborData, &cborSize));
136 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedPlatform, PAYLOAD_TYPE_PLATFORM,
137 cborData, cborSize));
140 EXPECT_EQ(platform->base.type, ((OCPlatformPayload*)parsedPlatform)->base.type);
141 OCPlatformPayload* platform2 = (OCPlatformPayload*)parsedPlatform;
142 EXPECT_STREQ(platform->info.platformID, platform2->info.platformID);
143 EXPECT_STREQ(platform->info.manufacturerName, platform->info.manufacturerName);
144 EXPECT_STREQ(platform->info.manufacturerUrl, platform->info.manufacturerUrl);
145 EXPECT_STREQ(platform->info.modelNumber, platform->info.modelNumber);
146 EXPECT_STREQ(platform->info.dateOfManufacture, platform->info.dateOfManufacture);
147 EXPECT_STREQ(platform->info.platformVersion, platform->info.platformVersion);
148 EXPECT_STREQ(platform->info.operatingSystemVersion, platform->info.operatingSystemVersion);
149 EXPECT_STREQ(platform->info.hardwareVersion, platform->info.hardwareVersion);
150 EXPECT_STREQ(platform->info.firmwareVersion, platform->info.firmwareVersion);
151 EXPECT_STREQ(platform->info.supportUrl, platform->info.supportUrl);
152 EXPECT_STREQ(platform->info.systemTime, platform2->info.systemTime);
153 EXPECT_STREQ(platform->interfaces->value, platform2->interfaces->value);
154 EXPECT_STREQ(platform->rt, platform2->rt);
156 OCPayloadDestroy((OCPayload*)platform);
158 OC::MessageContainer mc;
159 mc.setPayload(parsedPlatform);
160 EXPECT_EQ(1u, mc.representations().size());
161 const OC::OCRepresentation& r = mc.representations()[0];
162 EXPECT_STREQ(pfid1, r.getValue<std::string>(OC_RSRVD_PLATFORM_ID).c_str());
163 EXPECT_STREQ(mfgnm1, r.getValue<std::string>(OC_RSRVD_MFG_NAME).c_str());
164 EXPECT_STREQ(mfgurl1, r.getValue<std::string>(OC_RSRVD_MFG_URL).c_str());
165 EXPECT_STREQ(modelnum1, r.getValue<std::string>(OC_RSRVD_MODEL_NUM).c_str());
166 EXPECT_STREQ(dom1, r.getValue<std::string>(OC_RSRVD_MFG_DATE).c_str());
167 EXPECT_STREQ(pfver1, r.getValue<std::string>(OC_RSRVD_PLATFORM_VERSION).c_str());
168 EXPECT_STREQ(osver1, r.getValue<std::string>(OC_RSRVD_OS_VERSION).c_str());
169 EXPECT_STREQ(hwver1, r.getValue<std::string>(OC_RSRVD_HARDWARE_VERSION).c_str());
170 EXPECT_STREQ(fwver1, r.getValue<std::string>(OC_RSRVD_FIRMWARE_VERSION).c_str());
171 EXPECT_STREQ(url1, r.getValue<std::string>(OC_RSRVD_SUPPORT_URL).c_str());
172 EXPECT_STREQ(time1, r.getValue<std::string>(OC_RSRVD_SYSTEM_TIME).c_str());
174 OCPayloadDestroy(parsedPlatform);
176 TEST(PresencePayload, Normal)
179 uint32_t sequenceNumber = 0;
180 OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE;
181 OCPresencePayload *presence = OCPresencePayloadCreate(sequenceNumber, maxAge, trigger, uri1);
186 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)presence, &cborData, &cborSize));
187 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_PRESENCE,
188 cborData, cborSize));
189 OCPayloadDestroy((OCPayload*)presence);
192 OCPresencePayload* parsed = ((OCPresencePayload*)cparsed);
193 EXPECT_EQ(sequenceNumber, parsed->sequenceNumber);
194 EXPECT_EQ(maxAge, parsed->maxAge);
195 EXPECT_EQ(trigger, parsed->trigger);
196 EXPECT_STREQ(uri1, parsed->resourceType);
198 OCPayloadDestroy(cparsed);
200 // Representation Payloads
201 TEST(RepresentationEncoding, BaseAttributeTypes)
203 OC::OCRepresentation startRep;
204 startRep.setNULL("NullAttr");
205 startRep.setValue("IntAttr", 77);
206 startRep.setValue("DoubleAttr", 3.333);
207 startRep.setValue("BoolAttr", true);
208 startRep.setValue("StringAttr", std::string("String attr"));
209 OC::MessageContainer mc1;
210 mc1.addRepresentation(startRep);
212 OCRepPayload* cstart = mc1.getPayload();
213 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
218 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
219 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
220 cborData, cborSize));
221 OCPayloadDestroy((OCPayload*)cstart);
224 OC::MessageContainer mc2;
225 mc2.setPayload(cparsed);
226 EXPECT_EQ(1u, mc2.representations().size());
227 const OC::OCRepresentation& r = mc2.representations()[0];
229 EXPECT_TRUE(r.isNULL("NullAttr"));
230 EXPECT_EQ(77, r.getValue<int>("IntAttr"));
231 EXPECT_EQ(3.333, r.getValue<double>("DoubleAttr"));
232 EXPECT_EQ(true, r.getValue<bool>("BoolAttr"));
233 EXPECT_STREQ("String attr", r.getValue<std::string>("StringAttr").c_str());
235 OCPayloadDestroy(cparsed);
238 TEST(RepresentationEncoding, RepAttributeEmpty)
240 OC::OCRepresentation startRep;
241 std::vector<int> iarr {};
242 startRep["iarr"] = {};
244 OC::MessageContainer mc1;
245 mc1.addRepresentation(startRep);
247 OCRepPayload* cstart = mc1.getPayload();
248 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
250 uint8_t *cborData = NULL;
252 OCPayload *cparsed = NULL;
253 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
254 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
255 cborData, cborSize));
256 OCPayloadDestroy((OCPayload*)cstart);
259 OC::MessageContainer mc2;
260 mc2.setPayload(cparsed);
261 EXPECT_EQ(1u, mc2.representations().size());
262 const OC::OCRepresentation& r = mc2.representations()[0];
264 std::vector<int> iarr2 = r["iarr"];
266 EXPECT_EQ(iarr, iarr2);
267 OCPayloadDestroy(cparsed);
270 TEST(RepresentationEncoding, RepAttribute)
272 OC::OCRepresentation startRep;
273 OC::OCRepresentation subRep;
274 subRep.setNULL("NullAttr");
275 subRep.setValue("IntAttr", 77);
276 subRep.setValue("DoubleAttr", 3.333);
277 subRep.setValue("BoolAttr", true);
278 subRep.setValue("StringAttr", std::string("String attr"));
279 startRep.setValue("Sub", subRep);
281 OC::MessageContainer mc1;
282 mc1.addRepresentation(startRep);
284 OCRepPayload* cstart = mc1.getPayload();
285 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
290 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
291 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
292 cborData, cborSize));
293 OCPayloadDestroy((OCPayload*)cstart);
296 OC::MessageContainer mc2;
297 mc2.setPayload(cparsed);
298 EXPECT_EQ(1u, mc2.representations().size());
299 const OC::OCRepresentation& r = mc2.representations()[0];
301 OC::OCRepresentation newSubRep = r["Sub"];
303 EXPECT_TRUE(newSubRep.isNULL("NullAttr"));
304 EXPECT_EQ(77, newSubRep.getValue<int>("IntAttr"));
305 EXPECT_EQ(3.333, newSubRep.getValue<double>("DoubleAttr"));
306 EXPECT_EQ(true, newSubRep.getValue<bool>("BoolAttr"));
307 EXPECT_STREQ("String attr", newSubRep.getValue<std::string>("StringAttr").c_str());
308 OCPayloadDestroy(cparsed);
311 TEST(RepresentationEncoding, OneDVectors)
314 OC::OCRepresentation startRep;
316 OC::OCRepresentation subRep1;
317 OC::OCRepresentation subRep2;
318 OC::OCRepresentation subRep3;
319 subRep1.setNULL("NullAttr");
320 subRep1.setValue("IntAttr", 77);
321 subRep2.setValue("DoubleAttr", 3.333);
322 subRep2.setValue("BoolAttr", true);
323 subRep3.setValue("StringAttr", std::string("String attr"));
325 std::vector<int> iarr {1,2,3,4,5,6,7,8,9};
326 std::vector<double> darr {1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9};
327 std::vector<bool> barr {false, true, false, false, true, true};
328 std::vector<std::string> strarr {"item1", "item2", "item3", "item4"};
329 std::vector<OC::OCRepresentation> objarr {subRep1, subRep2, subRep3};
331 startRep["iarr"] = iarr;
332 startRep["darr"] = darr;
333 startRep["barr"] = barr;
334 startRep["strarr"] = strarr;
335 startRep["objarr"] = objarr;
338 OC::MessageContainer mc1;
339 mc1.addRepresentation(startRep);
341 OCRepPayload* cstart = mc1.getPayload();
342 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
347 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
348 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
349 cborData, cborSize));
350 OCPayloadDestroy((OCPayload*)cstart);
353 OC::MessageContainer mc2;
354 mc2.setPayload(cparsed);
355 EXPECT_EQ(1u, mc2.representations().size());
356 const OC::OCRepresentation& r = mc2.representations()[0];
359 std::vector<int> iarr2 = r["iarr"];
360 std::vector<double> darr2 = r["darr"];
361 std::vector<bool> barr2 = r["barr"];
362 std::vector<std::string> strarr2 = r["strarr"];
363 std::vector<OC::OCRepresentation> objarr2 = r["objarr"];
365 EXPECT_EQ(iarr, iarr2);
366 EXPECT_EQ(darr, darr2);
367 EXPECT_EQ(barr, barr2);
368 EXPECT_EQ(strarr, strarr2);
369 EXPECT_EQ(objarr, objarr2);
370 OCPayloadDestroy(cparsed);
373 TEST(RepresentationEncoding, TwoDVectors)
376 OC::OCRepresentation startRep;
378 OC::OCRepresentation subRep1;
379 OC::OCRepresentation subRep2;
380 OC::OCRepresentation subRep3;
381 subRep1.setNULL("NullAttr");
382 subRep1.setValue("IntAttr", 77);
383 subRep2.setValue("DoubleAttr", 3.333);
384 subRep2.setValue("BoolAttr", true);
385 subRep3.setValue("StringAttr", std::string("String attr"));
387 std::vector<std::vector<int>> iarr {{1,2,3},{4,5,6},{7,8,9}};
388 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{7.7,8.8,9.9}};
389 std::vector<std::vector<bool>> barr {{false, true}, {false, false}, {true, true}};
390 std::vector<std::vector<std::string>> strarr {{"item1", "item2"}, {"item3", "item4"}};
391 std::vector<std::vector<OC::OCRepresentation>> objarr
392 {{subRep1, subRep2, subRep3}, {subRep3, subRep2, subRep1}};
394 startRep["iarr"] = iarr;
395 startRep["darr"] = darr;
396 startRep["barr"] = barr;
397 startRep["strarr"] = strarr;
398 startRep["objarr"] = objarr;
401 OC::MessageContainer mc1;
402 mc1.addRepresentation(startRep);
404 OCRepPayload* cstart = mc1.getPayload();
405 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
410 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
411 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
412 cborData, cborSize));
413 OCPayloadDestroy((OCPayload*)cstart);
416 OC::MessageContainer mc2;
417 mc2.setPayload(cparsed);
418 EXPECT_EQ(1u, mc2.representations().size());
419 const OC::OCRepresentation& r = mc2.representations()[0];
422 std::vector<std::vector<int>> iarr2 = r["iarr"];
423 std::vector<std::vector<double>> darr2 = r["darr"];
424 std::vector<std::vector<bool>> barr2 = r["barr"];
425 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
426 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
428 EXPECT_EQ(iarr, iarr2);
429 EXPECT_EQ(darr, darr2);
430 EXPECT_EQ(barr, barr2);
431 EXPECT_EQ(strarr, strarr2);
432 EXPECT_EQ(objarr, objarr2);
433 OCPayloadDestroy(cparsed);
436 TEST(RepresentationEncoding, TwoDVectorsJagged)
439 OC::OCRepresentation startRep;
441 OC::OCRepresentation subRep1;
442 OC::OCRepresentation subRep2;
443 OC::OCRepresentation subRep3;
444 subRep1.setNULL("NullAttr");
445 subRep1.setValue("IntAttr", 77);
446 subRep2.setValue("DoubleAttr", 3.333);
447 subRep2.setValue("BoolAttr", true);
448 subRep3.setValue("StringAttr", std::string("String attr"));
450 std::vector<std::vector<int>> iarr {{1,2,3},{4,6},{7,8,9}};
451 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{8.8,9.9}};
452 std::vector<std::vector<bool>> barr {{false, true}, {false}, {true, true}};
453 std::vector<std::vector<std::string>> strarr {{"item1"}, {"item3", "item4"}};
454 std::vector<std::vector<OC::OCRepresentation>> objarr
455 {{subRep1, subRep3}, {subRep3, subRep2, subRep1}};
457 startRep["iarr"] = iarr;
458 startRep["darr"] = darr;
459 startRep["barr"] = barr;
460 startRep["strarr"] = strarr;
461 startRep["objarr"] = objarr;
464 OC::MessageContainer mc1;
465 mc1.addRepresentation(startRep);
467 OCRepPayload* cstart = mc1.getPayload();
468 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
473 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
474 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
475 cborData, cborSize));
476 OCPayloadDestroy((OCPayload*)cstart);
479 OC::MessageContainer mc2;
480 mc2.setPayload(cparsed);
481 EXPECT_EQ(1u, mc2.representations().size());
482 const OC::OCRepresentation& r = mc2.representations()[0];
485 std::vector<std::vector<int>> iarr2 = r["iarr"];
486 std::vector<std::vector<double>> darr2 = r["darr"];
487 std::vector<std::vector<bool>> barr2 = r["barr"];
488 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
489 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
491 // Note: due to the way that the CSDK works, all 2d arrays need to be rectangular.
492 // Since std::vector doesn't require this, items received on the other side end up
493 // being backfilled. This section removes the backfilling
497 strarr2[0].pop_back();
498 objarr2[0].pop_back();
500 EXPECT_EQ(iarr, iarr2);
501 EXPECT_EQ(darr, darr2);
502 EXPECT_EQ(barr, barr2);
503 EXPECT_EQ(strarr, strarr2);
504 EXPECT_EQ(objarr, objarr2);
505 OCPayloadDestroy(cparsed);
508 TEST(RepresentationEncoding, ThreeDVectors)
511 OC::OCRepresentation startRep;
513 OC::OCRepresentation subRep1;
514 OC::OCRepresentation subRep2;
515 OC::OCRepresentation subRep3;
516 subRep1.setNULL("NullAttr");
517 subRep1.setValue("IntAttr", 77);
518 subRep2.setValue("DoubleAttr", 3.333);
519 subRep2.setValue("BoolAttr", true);
520 subRep3.setValue("StringAttr", std::string("String attr"));
522 std::vector<std::vector<std::vector<int>>> iarr
523 {{{1,2,3},{4,5,6}},{{7,8,9},{10,11,12}},{{13,14,15},{16,17,18}}};
524 std::vector<std::vector<std::vector<double>>> darr
525 {{{1.1,2.2,3.3},{4.4,5.5,6.6}},
526 {{7.7,8.7,9.7},{10.7,11.7,12.7}},
527 {{13.7,14.7,15.7},{16.7,17.7,18.7}}};
528 std::vector<std::vector<std::vector<bool>>> barr
529 {{{false, true},{true, false}},{{false, true},{true, false}}};
530 std::vector<std::vector<std::vector<std::string>>> strarr
532 {{"item1", "item2"},{"item3", "item4"}},
533 {{"item5", "item6"},{"item7", "item8"}},
534 {{"item9", "item10"},{"item11", ""}}
536 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
538 {{subRep1, subRep2},{subRep3, subRep1}},
539 {{subRep2, subRep3},{subRep2, subRep1}},
540 {{subRep3, subRep2},{subRep1, subRep2}}
543 startRep["iarr"] = iarr;
544 startRep["darr"] = darr;
545 startRep["barr"] = barr;
546 startRep["strarr"] = strarr;
547 startRep["objarr"] = objarr;
550 OC::MessageContainer mc1;
551 mc1.addRepresentation(startRep);
553 OCRepPayload* cstart = mc1.getPayload();
554 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
559 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
560 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
561 cborData, cborSize));
562 OCPayloadDestroy((OCPayload*)cstart);
565 OC::MessageContainer mc2;
566 mc2.setPayload(cparsed);
567 EXPECT_EQ(1u, mc2.representations().size());
568 const OC::OCRepresentation& r = mc2.representations()[0];
571 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
572 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
573 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
574 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
575 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
577 EXPECT_EQ(iarr, iarr2);
578 EXPECT_EQ(darr, darr2);
579 EXPECT_EQ(barr, barr2);
580 EXPECT_EQ(strarr, strarr2);
581 EXPECT_EQ(objarr, objarr2);
582 OCPayloadDestroy(cparsed);
585 TEST(RepresentationEncoding, ThreeDVectorsJagged)
588 OC::OCRepresentation startRep;
590 OC::OCRepresentation subRep1;
591 OC::OCRepresentation subRep2;
592 OC::OCRepresentation subRep3;
593 subRep1.setNULL("NullAttr");
594 subRep1.setValue("IntAttr", 77);
595 subRep2.setValue("DoubleAttr", 3.333);
596 subRep2.setValue("BoolAttr", true);
597 subRep3.setValue("StringAttr", std::string("String attr"));
599 std::vector<std::vector<std::vector<int>>> iarr
603 {{13,14,15},{16,17,18}}
605 std::vector<std::vector<std::vector<double>>> darr
607 {{1.1,2.2,3.3},{4.4,5.5,6.6}},
608 {{7.7,8.7,9.7},{10.7,12.7}},
609 {{13.7,14.7,15.7},{16.7,17.7,18.7}}
611 std::vector<std::vector<std::vector<bool>>> barr
613 {{false, true},{true}},
614 {{false, true},{true, false}}
616 std::vector<std::vector<std::vector<std::string>>> strarr
618 {{"item1", "item2"},{"item3", "item4"}},
619 {{"item5", "item6"},{"item8"}},
620 {{"item9", "item10"},{"item11", ""}}
622 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
624 {{subRep1, subRep2},{subRep3, subRep1}},
625 {{subRep2, subRep3},{subRep2}},
629 startRep["iarr"] = iarr;
630 startRep["darr"] = darr;
631 startRep["barr"] = barr;
632 startRep["strarr"] = strarr;
633 startRep["objarr"] = objarr;
636 OC::MessageContainer mc1;
637 mc1.addRepresentation(startRep);
639 OCRepPayload* cstart = mc1.getPayload();
640 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
645 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
646 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
647 cborData, cborSize));
648 OCPayloadDestroy((OCPayload*)cstart);
651 OC::MessageContainer mc2;
652 mc2.setPayload(cparsed);
653 EXPECT_EQ(1u, mc2.representations().size());
654 const OC::OCRepresentation& r = mc2.representations()[0];
657 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
658 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
659 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
660 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
661 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
663 // Note: due to the way that the CSDK works, all 3d arrays need to be cuboidal.
664 // Since std::vector doesn't require this, items received on the other side end up
665 // being backfilled. This section removes the backfilling
666 iarr2[1][1].pop_back();
667 darr2[1][1].pop_back();
668 barr2[0][1].pop_back();
669 strarr2[1][1].pop_back();
670 objarr2[1][1].pop_back();
671 objarr2[2].pop_back();
673 EXPECT_EQ(iarr, iarr2);
674 EXPECT_EQ(darr, darr2);
675 EXPECT_EQ(barr, barr2);
676 EXPECT_EQ(strarr, strarr2);
677 EXPECT_EQ(objarr, objarr2);
678 OCPayloadDestroy(cparsed);
681 TEST(DiscoveryRTandIF, SingleItemNormal)
683 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
684 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
685 payload->sid = OICStrdup(sid1);
686 payload->resources = resource;
688 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem"));
689 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem"));
691 resource->uri = OICStrdup("/uri/thing");
697 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
698 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
699 cborData, cborSize));
701 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
702 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
704 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
705 EXPECT_EQ(NULL, parsedResource->next);
706 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
707 EXPECT_EQ(NULL, parsedResource->types->next);
708 EXPECT_EQ(NULL, parsedResource->interfaces->next);
709 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
712 OCPayloadDestroy(cparsed);
713 OCDiscoveryPayloadDestroy(payload);
716 TEST(DiscoveryRTandIF, SingleItemFrontTrim)
718 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
719 payload->sid = OICStrdup(sid1);
720 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
721 payload->resources = resource;
723 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, " rt.singleitem"));
724 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, " if.singleitem"));
725 resource->uri = OICStrdup("/uri/thing");
731 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
732 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
733 cborData, cborSize));
735 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
736 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
738 EXPECT_EQ(NULL, parsedResource->next);
739 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
740 EXPECT_EQ(NULL, parsedResource->types->next);
741 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
742 EXPECT_EQ(NULL, parsedResource->interfaces->next);
743 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
746 OCPayloadDestroy(cparsed);
747 OCDiscoveryPayloadDestroy(payload);
750 TEST(DiscoveryRTandIF, SingleItemBackTrim)
752 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
753 payload->sid = OICStrdup(sid1);
754 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
755 payload->resources = resource;
757 OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem ");
758 OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem ");
759 resource->uri = OICStrdup("/uri/thing");
765 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
766 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
767 cborData, cborSize));
769 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
770 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
772 EXPECT_EQ(NULL, parsedResource->next);
773 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
774 EXPECT_EQ(NULL, parsedResource->types->next);
775 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
776 EXPECT_EQ(NULL, parsedResource->interfaces->next);
777 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
780 OCPayloadDestroy(cparsed);
781 OCDiscoveryPayloadDestroy(payload);
783 TEST(DiscoveryRTandIF, SingleItemBothTrim)
785 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
786 payload->sid = OICStrdup(sid1);
787 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
788 payload->resources = resource;
790 OCResourcePayloadAddStringLL(&resource->types, " rt.singleitem ");
791 OCResourcePayloadAddStringLL(&resource->interfaces, " if.singleitem ");
792 resource->uri = OICStrdup("/uri/thing");
798 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
799 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
800 cborData, cborSize));
802 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
803 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
805 EXPECT_EQ(NULL, parsedResource->next);
806 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
807 EXPECT_EQ(NULL, parsedResource->types->next);
808 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
809 EXPECT_EQ(NULL, parsedResource->interfaces->next);
810 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
813 OCPayloadDestroy(cparsed);
814 OCDiscoveryPayloadDestroy(payload);
816 TEST(DiscoveryRTandIF, MultiItemsNormal)
818 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
819 payload->sid = OICStrdup(sid1);
820 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
821 payload->resources = resource;
823 OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem");
824 OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem");
825 OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem");
826 OCResourcePayloadAddStringLL(&resource->interfaces, "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);
841 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
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, MultiItemExtraLeadSpaces)
855 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
856 payload->sid = OICStrdup(sid1);
857 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
858 payload->resources = resource;
860 OCResourcePayloadAddStringLL(&resource->types, " rt.firstitem");
861 OCResourcePayloadAddStringLL(&resource->types, " rt.seconditem");
862 OCResourcePayloadAddStringLL(&resource->interfaces, " if.firstitem");
863 OCResourcePayloadAddStringLL(&resource->interfaces, " 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);
878 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
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, MultiItemExtraTrailSpaces)
892 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
893 payload->sid = OICStrdup(sid1);
894 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
895 payload->resources = resource;
897 OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem ");
898 OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem ");
899 OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem ");
900 OCResourcePayloadAddStringLL(&resource->interfaces, "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);
915 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
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(DiscoveryRTandIF, MultiItemBothSpaces)
929 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
930 payload->sid = OICStrdup(sid1);
931 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
932 payload->resources = resource;
934 OCResourcePayloadAddStringLL(&resource->types, " rt.firstitem ");
935 OCResourcePayloadAddStringLL(&resource->types, " rt.seconditem ");
936 OCResourcePayloadAddStringLL(&resource->interfaces, " if.firstitem ");
937 OCResourcePayloadAddStringLL(&resource->interfaces, " if.seconditem ");
938 resource->uri = OICStrdup("/uri/thing");
944 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
945 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
946 cborData, cborSize));
948 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
949 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
951 EXPECT_EQ(NULL, parsedResource->next);
952 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
953 EXPECT_EQ(NULL, parsedResource->types->next->next);
954 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
955 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
956 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
957 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
958 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
961 OCPayloadDestroy(cparsed);
962 OCDiscoveryPayloadDestroy(payload);
964 TEST(RepresentationEncodingRTandIF, SingleItemNormal)
966 OCRepPayload* payload = OCRepPayloadCreate();
967 OCRepPayloadAddResourceType(payload, "rt.firstitem");
968 OCRepPayloadAddInterface(payload, "if.firstitem");
974 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
975 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
976 cborData, cborSize));
978 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
980 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
981 EXPECT_EQ(NULL, parsedPayload->types->next);
982 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
983 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
986 OCRepPayloadDestroy(payload);
987 OCPayloadDestroy(cparsed);
989 TEST(RepresentationEncodingRTandIF, SingleItemFrontTrim)
991 OCRepPayload* payload = OCRepPayloadCreate();
992 OCRepPayloadAddResourceType(payload, " rt.firstitem");
993 OCRepPayloadAddInterface(payload, " if.firstitem");
999 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1000 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1001 cborData, cborSize));
1003 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1005 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1006 EXPECT_EQ(NULL, parsedPayload->types->next);
1007 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1008 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1012 OCRepPayloadDestroy(payload);
1013 OCPayloadDestroy(cparsed);
1015 TEST(RepresentationEncodingRTandIF, SingleItemBackTrim)
1017 OCRepPayload* payload = OCRepPayloadCreate();
1018 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
1019 OCRepPayloadAddInterface(payload, "if.firstitem ");
1025 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1026 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1027 cborData, cborSize));
1029 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1031 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1032 EXPECT_EQ(NULL, parsedPayload->types->next);
1033 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1034 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1038 OCRepPayloadDestroy(payload);
1039 OCPayloadDestroy(cparsed);
1041 TEST(RepresentationEncodingRTandIF, SingleItemBothTrim)
1043 OCRepPayload* payload = OCRepPayloadCreate();
1044 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1045 OCRepPayloadAddInterface(payload, " if.firstitem ");
1051 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1052 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1053 cborData, cborSize));
1055 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1057 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1058 EXPECT_EQ(NULL, parsedPayload->types->next);
1059 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1060 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1064 OCRepPayloadDestroy(payload);
1065 OCPayloadDestroy(cparsed);
1067 TEST(RepresentationEncodingRTandIF, MultiItemsNormal)
1069 OCRepPayload* payload = OCRepPayloadCreate();
1070 OCRepPayloadAddResourceType(payload, "rt.firstitem");
1071 OCRepPayloadAddResourceType(payload, "rt.seconditem");
1072 OCRepPayloadAddInterface(payload, "if.firstitem");
1073 OCRepPayloadAddInterface(payload, "if.seconditem");
1079 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1080 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1081 cborData, cborSize));
1083 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1085 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1086 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1087 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1088 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1089 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1090 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1094 OCRepPayloadDestroy(payload);
1095 OCPayloadDestroy(cparsed);
1097 TEST(RepresentationEncodingRTandIF, MultiItemExtraLeadSpaces)
1099 OCRepPayload* payload = OCRepPayloadCreate();
1100 OCRepPayloadAddResourceType(payload, " rt.firstitem");
1101 OCRepPayloadAddResourceType(payload, " rt.seconditem");
1102 OCRepPayloadAddInterface(payload, " if.firstitem");
1103 OCRepPayloadAddInterface(payload, " if.seconditem");
1109 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1110 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1111 cborData, cborSize));
1113 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1115 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1116 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1117 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1118 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1119 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1120 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1124 OCRepPayloadDestroy(payload);
1125 OCPayloadDestroy(cparsed);
1127 TEST(RepresentationEncodingRTandIF, MultiItemExtraTrailSpaces)
1129 OCRepPayload* payload = OCRepPayloadCreate();
1130 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
1131 OCRepPayloadAddResourceType(payload, "rt.seconditem ");
1132 OCRepPayloadAddInterface(payload, "if.firstitem ");
1133 OCRepPayloadAddInterface(payload, "if.seconditem ");
1139 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1140 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1141 cborData, cborSize));
1143 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1145 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1146 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1147 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1148 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1149 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1150 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1154 OCRepPayloadDestroy(payload);
1155 OCPayloadDestroy(cparsed);
1157 TEST(RepresentationEncodingRTandIF, MultiItemExtraMiddleSpaces)
1159 OCRepPayload* payload = OCRepPayloadCreate();
1160 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1161 OCRepPayloadAddResourceType(payload, " rt.seconditem ");
1162 OCRepPayloadAddInterface(payload, " if.firstitem ");
1163 OCRepPayloadAddInterface(payload, " if.seconditem ");
1169 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1170 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1171 cborData, cborSize));
1173 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1175 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1176 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1177 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1178 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1179 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1180 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1184 OCRepPayloadDestroy(payload);
1185 OCPayloadDestroy(cparsed);
1187 TEST(RepresentationEncodingRTandIF, TestPayloadContents)
1189 OC::OCRepresentation subRep1;
1190 std::vector<std::string> types;
1191 types.push_back("rt.firstitem");
1192 std::vector<std::string> interfaces;
1193 interfaces.push_back("if.firstitem");
1194 subRep1.setResourceTypes(types);
1195 subRep1.setResourceInterfaces(interfaces);
1196 subRep1.setNULL("NullAttr");
1197 subRep1.setValue("IntAttr", 77);
1198 subRep1.setValue("DoubleAttr", 3.333);
1199 subRep1.setValue("BoolAttr", true);
1200 subRep1.setValue("StringAttr", std::string("String attr"));
1202 OC::MessageContainer mc1;
1203 mc1.addRepresentation(subRep1);
1205 OCRepPayload *repPayload = mc1.getPayload();
1206 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, repPayload->base.type);
1208 uint8_t *cborData = NULL;
1209 size_t cborSize = 0;
1210 OCPayload *cparsed = NULL;
1212 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)repPayload, &cborData, &cborSize));
1213 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1214 cborData, cborSize));
1216 OCRepPayload *parsedPayload = (OCRepPayload *)cparsed;
1217 EXPECT_EQ(NULL, parsedPayload->uri);
1218 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1219 EXPECT_EQ(NULL, parsedPayload->types->next);
1220 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1221 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1223 // To make sure rt and if are not duplicated.
1224 EXPECT_STREQ("BoolAttr", parsedPayload->values->name);
1225 EXPECT_EQ(true, parsedPayload->values->b);
1226 EXPECT_EQ(OCREP_PROP_BOOL, parsedPayload->values->type);
1227 parsedPayload->values = parsedPayload->values->next;
1229 EXPECT_STREQ("DoubleAttr", parsedPayload->values->name);
1230 EXPECT_EQ(OCREP_PROP_DOUBLE, parsedPayload->values->type);
1231 EXPECT_EQ(3.3330000000000002, parsedPayload->values->d);
1232 parsedPayload->values = parsedPayload->values->next;
1234 EXPECT_STREQ("IntAttr", parsedPayload->values->name);
1235 EXPECT_EQ(77, parsedPayload->values->i);
1236 EXPECT_EQ(OCREP_PROP_INT, parsedPayload->values->type);
1237 parsedPayload->values = parsedPayload->values->next;
1239 EXPECT_STREQ("NullAttr", parsedPayload->values->name);
1240 EXPECT_EQ(OCREP_PROP_NULL, parsedPayload->values->type);
1241 parsedPayload->values = parsedPayload->values->next;
1243 EXPECT_STREQ("StringAttr", parsedPayload->values->name);
1244 EXPECT_STREQ("String attr", parsedPayload->values->str);
1245 EXPECT_EQ(OCREP_PROP_STRING, parsedPayload->values->type);
1246 parsedPayload->values = parsedPayload->values->next;
1248 EXPECT_EQ(NULL, parsedPayload->values);
1251 OCRepPayloadDestroy(repPayload);
1252 OCPayloadDestroy(cparsed);