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>
29 #include "payload_logging.h"
33 bool operator==(const OC::NullType&, const OC::NullType&)
38 bool operator==(const OC::OCRepresentation& lhs, const OC::OCRepresentation& rhs)
40 return lhs.getUri() == rhs.getUri() &&
41 lhs.getChildren() == rhs.getChildren() &&
42 lhs.getResourceInterfaces() == rhs.getResourceInterfaces() &&
43 lhs.getResourceTypes() == rhs.getResourceTypes() &&
44 lhs.m_values == rhs.m_values;
47 // these tests validate the OCRepresentation->OCPayload, OCPayload->CBOR,
48 // CBOR->OCPayload and OCPayload->OCRepresentation conversions
49 namespace OCRepresentationEncodingTest
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(
64 EXPECT_STREQ(devicename1, device->deviceName);
65 EXPECT_STREQ(specver1, device->specVersion);
66 EXPECT_STREQ(dmver1, device->dataModelVersion);
67 EXPECT_EQ(PAYLOAD_TYPE_DEVICE, ((OCPayload*)device)->type);
69 for (uint8_t i = 1; i <= sizeof(sid1); ++i)
71 EXPECT_EQ(i, sid1[i - 1]);
76 OCPayload* parsedDevice;
77 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)device, &cborData, &cborSize));
78 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedDevice, PAYLOAD_TYPE_DEVICE,
82 EXPECT_STREQ(device->deviceName, ((OCDevicePayload*)parsedDevice)->deviceName);
83 EXPECT_STREQ(device->specVersion, ((OCDevicePayload*)parsedDevice)->specVersion);
84 EXPECT_STREQ(device->dataModelVersion, ((OCDevicePayload*)parsedDevice)->dataModelVersion);
85 EXPECT_EQ(device->base.type, ((OCDevicePayload*)parsedDevice)->base.type);
87 OCPayloadDestroy((OCPayload*)device);
89 OC::MessageContainer mc;
90 mc.setPayload(parsedDevice);
91 EXPECT_EQ(1u, mc.representations().size());
92 const OC::OCRepresentation& r = mc.representations()[0];
93 EXPECT_STREQ(devicename1, r.getValue<std::string>(OC_RSRVD_DEVICE_NAME).c_str());
94 EXPECT_STREQ(specver1, r.getValue<std::string>(OC_RSRVD_SPEC_VERSION).c_str());
95 EXPECT_STREQ(dmver1, r.getValue<std::string>(OC_RSRVD_DATA_MODEL_VERSION).c_str());
97 OCPayloadDestroy(parsedDevice);
100 static const char uri1[] = "/testuri";
101 static char pfid1[] = "pfid";
102 static char mfgnm1[] = "mfgnm";
103 static char mfgurl1[] = "mfgurl";
104 static char modelnum1[] = "modelnum";
105 static char dom1[] = "dom";
106 static char pfver1[] = "pfver";
107 static char osver1[] = "osver";
108 static char hwver1[] = "hwver";
109 static char fwver1[] = "fwver";
110 static char url1[] = "url";
111 static char time1[] = "time";
114 TEST(PlatformDiscoveryEncoding, Normal)
116 OCPlatformInfo info {pfid1, mfgnm1, mfgurl1, modelnum1, dom1, pfver1, osver1, hwver1,
117 fwver1, url1, time1};
118 OCPlatformPayload* platform = OCPlatformPayloadCreate(&info);
119 EXPECT_EQ(PAYLOAD_TYPE_PLATFORM, ((OCPayload*)platform)->type);
120 EXPECT_STREQ(pfid1, platform->info.platformID);
121 EXPECT_STREQ(mfgnm1, platform->info.manufacturerName);
122 EXPECT_STREQ(mfgurl1, platform->info.manufacturerUrl);
123 EXPECT_STREQ(modelnum1, platform->info.modelNumber);
124 EXPECT_STREQ(dom1, platform->info.dateOfManufacture);
125 EXPECT_STREQ(pfver1, platform->info.platformVersion);
126 EXPECT_STREQ(osver1, platform->info.operatingSystemVersion);
127 EXPECT_STREQ(hwver1, platform->info.hardwareVersion);
128 EXPECT_STREQ(fwver1, platform->info.firmwareVersion);
129 EXPECT_STREQ(url1, platform->info.supportUrl);
130 EXPECT_STREQ(time1, platform->info.systemTime);
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);
154 OCPayloadDestroy((OCPayload*)platform);
156 OC::MessageContainer mc;
157 mc.setPayload(parsedPlatform);
158 EXPECT_EQ(1u, mc.representations().size());
159 const OC::OCRepresentation& r = mc.representations()[0];
160 EXPECT_STREQ(pfid1, r.getValue<std::string>(OC_RSRVD_PLATFORM_ID).c_str());
161 EXPECT_STREQ(mfgnm1, r.getValue<std::string>(OC_RSRVD_MFG_NAME).c_str());
162 EXPECT_STREQ(mfgurl1, r.getValue<std::string>(OC_RSRVD_MFG_URL).c_str());
163 EXPECT_STREQ(modelnum1, r.getValue<std::string>(OC_RSRVD_MODEL_NUM).c_str());
164 EXPECT_STREQ(dom1, r.getValue<std::string>(OC_RSRVD_MFG_DATE).c_str());
165 EXPECT_STREQ(pfver1, r.getValue<std::string>(OC_RSRVD_PLATFORM_VERSION).c_str());
166 EXPECT_STREQ(osver1, r.getValue<std::string>(OC_RSRVD_OS_VERSION).c_str());
167 EXPECT_STREQ(hwver1, r.getValue<std::string>(OC_RSRVD_HARDWARE_VERSION).c_str());
168 EXPECT_STREQ(fwver1, r.getValue<std::string>(OC_RSRVD_FIRMWARE_VERSION).c_str());
169 EXPECT_STREQ(url1, r.getValue<std::string>(OC_RSRVD_SUPPORT_URL).c_str());
170 EXPECT_STREQ(time1, r.getValue<std::string>(OC_RSRVD_SYSTEM_TIME).c_str());
172 OCPayloadDestroy(parsedPlatform);
174 TEST(PresencePayload, Normal)
177 uint32_t sequenceNumber = 0;
178 OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE;
179 OCPresencePayload *presence = OCPresencePayloadCreate(sequenceNumber, maxAge, trigger, uri1);
184 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)presence, &cborData, &cborSize));
185 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_PRESENCE,
186 cborData, cborSize));
187 OCPayloadDestroy((OCPayload*)presence);
190 OCPresencePayload* parsed = ((OCPresencePayload*)cparsed);
191 EXPECT_EQ(sequenceNumber, parsed->sequenceNumber);
192 EXPECT_EQ(maxAge, parsed->maxAge);
193 EXPECT_EQ(trigger, parsed->trigger);
194 EXPECT_STREQ(uri1, parsed->resourceType);
196 OCPayloadDestroy(cparsed);
198 // Representation Payloads
199 TEST(RepresentationEncoding, BaseAttributeTypes)
201 OC::OCRepresentation startRep;
202 startRep.setNULL("NullAttr");
203 startRep.setValue("IntAttr", 77);
204 startRep.setValue("DoubleAttr", 3.333);
205 startRep.setValue("BoolAttr", true);
206 startRep.setValue("StringAttr", std::string("String attr"));
207 OC::MessageContainer mc1;
208 mc1.addRepresentation(startRep);
210 OCRepPayload* cstart = mc1.getPayload();
211 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
216 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
217 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
218 cborData, cborSize));
219 OCPayloadDestroy((OCPayload*)cstart);
222 OC::MessageContainer mc2;
223 mc2.setPayload(cparsed);
224 EXPECT_EQ(1u, mc2.representations().size());
225 const OC::OCRepresentation& r = mc2.representations()[0];
227 EXPECT_TRUE(r.isNULL("NullAttr"));
228 EXPECT_EQ(77, r.getValue<int>("IntAttr"));
229 EXPECT_EQ(3.333, r.getValue<double>("DoubleAttr"));
230 EXPECT_EQ(true, r.getValue<bool>("BoolAttr"));
231 EXPECT_STREQ("String attr", r.getValue<std::string>("StringAttr").c_str());
233 OCPayloadDestroy(cparsed);
236 TEST(RepresentationEncoding, RepAttributeEmpty)
238 OC::OCRepresentation startRep;
239 std::vector<int> iarr {};
240 startRep["iarr"] = {};
242 OC::MessageContainer mc1;
243 mc1.addRepresentation(startRep);
245 OCRepPayload* cstart = mc1.getPayload();
246 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
248 uint8_t *cborData = NULL;
250 OCPayload *cparsed = NULL;
251 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
252 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
253 cborData, cborSize));
254 OCPayloadDestroy((OCPayload*)cstart);
257 OC::MessageContainer mc2;
258 mc2.setPayload(cparsed);
259 EXPECT_EQ(1u, mc2.representations().size());
260 const OC::OCRepresentation& r = mc2.representations()[0];
262 std::vector<int> iarr2 = r["iarr"];
264 EXPECT_EQ(iarr, iarr2);
265 OCPayloadDestroy(cparsed);
268 TEST(RepresentationEncoding, RepAttribute)
270 OC::OCRepresentation startRep;
271 OC::OCRepresentation subRep;
272 subRep.setNULL("NullAttr");
273 subRep.setValue("IntAttr", 77);
274 subRep.setValue("DoubleAttr", 3.333);
275 subRep.setValue("BoolAttr", true);
276 subRep.setValue("StringAttr", std::string("String attr"));
277 startRep.setValue("Sub", subRep);
279 OC::MessageContainer mc1;
280 mc1.addRepresentation(startRep);
282 OCRepPayload* cstart = mc1.getPayload();
283 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
288 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
289 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
290 cborData, cborSize));
291 OCPayloadDestroy((OCPayload*)cstart);
294 OC::MessageContainer mc2;
295 mc2.setPayload(cparsed);
296 EXPECT_EQ(1u, mc2.representations().size());
297 const OC::OCRepresentation& r = mc2.representations()[0];
299 OC::OCRepresentation newSubRep = r["Sub"];
301 EXPECT_TRUE(newSubRep.isNULL("NullAttr"));
302 EXPECT_EQ(77, newSubRep.getValue<int>("IntAttr"));
303 EXPECT_EQ(3.333, newSubRep.getValue<double>("DoubleAttr"));
304 EXPECT_EQ(true, newSubRep.getValue<bool>("BoolAttr"));
305 EXPECT_STREQ("String attr", newSubRep.getValue<std::string>("StringAttr").c_str());
306 OCPayloadDestroy(cparsed);
309 TEST(RepresentationEncoding, OneDVectors)
312 OC::OCRepresentation startRep;
314 OC::OCRepresentation subRep1;
315 OC::OCRepresentation subRep2;
316 OC::OCRepresentation subRep3;
317 subRep1.setNULL("NullAttr");
318 subRep1.setValue("IntAttr", 77);
319 subRep2.setValue("DoubleAttr", 3.333);
320 subRep2.setValue("BoolAttr", true);
321 subRep3.setValue("StringAttr", std::string("String attr"));
323 std::vector<int> iarr {1,2,3,4,5,6,7,8,9};
324 std::vector<double> darr {1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9};
325 std::vector<bool> barr {false, true, false, false, true, true};
326 std::vector<std::string> strarr {"item1", "item2", "item3", "item4"};
327 std::vector<OC::OCRepresentation> objarr {subRep1, subRep2, subRep3};
329 startRep["iarr"] = iarr;
330 startRep["darr"] = darr;
331 startRep["barr"] = barr;
332 startRep["strarr"] = strarr;
333 startRep["objarr"] = objarr;
336 OC::MessageContainer mc1;
337 mc1.addRepresentation(startRep);
339 OCRepPayload* cstart = mc1.getPayload();
340 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
345 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
346 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
347 cborData, cborSize));
348 OCPayloadDestroy((OCPayload*)cstart);
351 OC::MessageContainer mc2;
352 mc2.setPayload(cparsed);
353 EXPECT_EQ(1u, mc2.representations().size());
354 const OC::OCRepresentation& r = mc2.representations()[0];
357 std::vector<int> iarr2 = r["iarr"];
358 std::vector<double> darr2 = r["darr"];
359 std::vector<bool> barr2 = r["barr"];
360 std::vector<std::string> strarr2 = r["strarr"];
361 std::vector<OC::OCRepresentation> objarr2 = r["objarr"];
363 EXPECT_EQ(iarr, iarr2);
364 EXPECT_EQ(darr, darr2);
365 EXPECT_EQ(barr, barr2);
366 EXPECT_EQ(strarr, strarr2);
367 EXPECT_EQ(objarr, objarr2);
368 OCPayloadDestroy(cparsed);
371 TEST(RepresentationEncoding, TwoDVectors)
374 OC::OCRepresentation startRep;
376 OC::OCRepresentation subRep1;
377 OC::OCRepresentation subRep2;
378 OC::OCRepresentation subRep3;
379 subRep1.setNULL("NullAttr");
380 subRep1.setValue("IntAttr", 77);
381 subRep2.setValue("DoubleAttr", 3.333);
382 subRep2.setValue("BoolAttr", true);
383 subRep3.setValue("StringAttr", std::string("String attr"));
385 std::vector<std::vector<int>> iarr {{1,2,3},{4,5,6},{7,8,9}};
386 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{7.7,8.8,9.9}};
387 std::vector<std::vector<bool>> barr {{false, true}, {false, false}, {true, true}};
388 std::vector<std::vector<std::string>> strarr {{"item1", "item2"}, {"item3", "item4"}};
389 std::vector<std::vector<OC::OCRepresentation>> objarr
390 {{subRep1, subRep2, subRep3}, {subRep3, subRep2, subRep1}};
392 startRep["iarr"] = iarr;
393 startRep["darr"] = darr;
394 startRep["barr"] = barr;
395 startRep["strarr"] = strarr;
396 startRep["objarr"] = objarr;
399 OC::MessageContainer mc1;
400 mc1.addRepresentation(startRep);
402 OCRepPayload* cstart = mc1.getPayload();
403 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
408 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
409 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
410 cborData, cborSize));
411 OCPayloadDestroy((OCPayload*)cstart);
414 OC::MessageContainer mc2;
415 mc2.setPayload(cparsed);
416 EXPECT_EQ(1u, mc2.representations().size());
417 const OC::OCRepresentation& r = mc2.representations()[0];
420 std::vector<std::vector<int>> iarr2 = r["iarr"];
421 std::vector<std::vector<double>> darr2 = r["darr"];
422 std::vector<std::vector<bool>> barr2 = r["barr"];
423 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
424 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
426 EXPECT_EQ(iarr, iarr2);
427 EXPECT_EQ(darr, darr2);
428 EXPECT_EQ(barr, barr2);
429 EXPECT_EQ(strarr, strarr2);
430 EXPECT_EQ(objarr, objarr2);
431 OCPayloadDestroy(cparsed);
434 TEST(RepresentationEncoding, TwoDVectorsJagged)
437 OC::OCRepresentation startRep;
439 OC::OCRepresentation subRep1;
440 OC::OCRepresentation subRep2;
441 OC::OCRepresentation subRep3;
442 subRep1.setNULL("NullAttr");
443 subRep1.setValue("IntAttr", 77);
444 subRep2.setValue("DoubleAttr", 3.333);
445 subRep2.setValue("BoolAttr", true);
446 subRep3.setValue("StringAttr", std::string("String attr"));
448 std::vector<std::vector<int>> iarr {{1,2,3},{4,6},{7,8,9}};
449 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{8.8,9.9}};
450 std::vector<std::vector<bool>> barr {{false, true}, {false}, {true, true}};
451 std::vector<std::vector<std::string>> strarr {{"item1"}, {"item3", "item4"}};
452 std::vector<std::vector<OC::OCRepresentation>> objarr
453 {{subRep1, subRep3}, {subRep3, subRep2, subRep1}};
455 startRep["iarr"] = iarr;
456 startRep["darr"] = darr;
457 startRep["barr"] = barr;
458 startRep["strarr"] = strarr;
459 startRep["objarr"] = objarr;
462 OC::MessageContainer mc1;
463 mc1.addRepresentation(startRep);
465 OCRepPayload* cstart = mc1.getPayload();
466 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
471 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
472 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
473 cborData, cborSize));
474 OCPayloadDestroy((OCPayload*)cstart);
477 OC::MessageContainer mc2;
478 mc2.setPayload(cparsed);
479 EXPECT_EQ(1u, mc2.representations().size());
480 const OC::OCRepresentation& r = mc2.representations()[0];
483 std::vector<std::vector<int>> iarr2 = r["iarr"];
484 std::vector<std::vector<double>> darr2 = r["darr"];
485 std::vector<std::vector<bool>> barr2 = r["barr"];
486 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
487 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
489 // Note: due to the way that the CSDK works, all 2d arrays need to be rectangular.
490 // Since std::vector doesn't require this, items received on the other side end up
491 // being backfilled. This section removes the backfilling
495 strarr2[0].pop_back();
496 objarr2[0].pop_back();
498 EXPECT_EQ(iarr, iarr2);
499 EXPECT_EQ(darr, darr2);
500 EXPECT_EQ(barr, barr2);
501 EXPECT_EQ(strarr, strarr2);
502 EXPECT_EQ(objarr, objarr2);
503 OCPayloadDestroy(cparsed);
506 TEST(RepresentationEncoding, ThreeDVectors)
509 OC::OCRepresentation startRep;
511 OC::OCRepresentation subRep1;
512 OC::OCRepresentation subRep2;
513 OC::OCRepresentation subRep3;
514 subRep1.setNULL("NullAttr");
515 subRep1.setValue("IntAttr", 77);
516 subRep2.setValue("DoubleAttr", 3.333);
517 subRep2.setValue("BoolAttr", true);
518 subRep3.setValue("StringAttr", std::string("String attr"));
520 std::vector<std::vector<std::vector<int>>> iarr
521 {{{1,2,3},{4,5,6}},{{7,8,9},{10,11,12}},{{13,14,15},{16,17,18}}};
522 std::vector<std::vector<std::vector<double>>> darr
523 {{{1.1,2.2,3.3},{4.4,5.5,6.6}},
524 {{7.7,8.7,9.7},{10.7,11.7,12.7}},
525 {{13.7,14.7,15.7},{16.7,17.7,18.7}}};
526 std::vector<std::vector<std::vector<bool>>> barr
527 {{{false, true},{true, false}},{{false, true},{true, false}}};
528 std::vector<std::vector<std::vector<std::string>>> strarr
530 {{"item1", "item2"},{"item3", "item4"}},
531 {{"item5", "item6"},{"item7", "item8"}},
532 {{"item9", "item10"},{"item11", ""}}
534 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
536 {{subRep1, subRep2},{subRep3, subRep1}},
537 {{subRep2, subRep3},{subRep2, subRep1}},
538 {{subRep3, subRep2},{subRep1, subRep2}}
541 startRep["iarr"] = iarr;
542 startRep["darr"] = darr;
543 startRep["barr"] = barr;
544 startRep["strarr"] = strarr;
545 startRep["objarr"] = objarr;
548 OC::MessageContainer mc1;
549 mc1.addRepresentation(startRep);
551 OCRepPayload* cstart = mc1.getPayload();
552 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
557 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
558 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
559 cborData, cborSize));
560 OCPayloadDestroy((OCPayload*)cstart);
563 OC::MessageContainer mc2;
564 mc2.setPayload(cparsed);
565 EXPECT_EQ(1u, mc2.representations().size());
566 const OC::OCRepresentation& r = mc2.representations()[0];
569 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
570 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
571 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
572 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
573 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
575 EXPECT_EQ(iarr, iarr2);
576 EXPECT_EQ(darr, darr2);
577 EXPECT_EQ(barr, barr2);
578 EXPECT_EQ(strarr, strarr2);
579 EXPECT_EQ(objarr, objarr2);
580 OCPayloadDestroy(cparsed);
583 TEST(RepresentationEncoding, ThreeDVectorsJagged)
586 OC::OCRepresentation startRep;
588 OC::OCRepresentation subRep1;
589 OC::OCRepresentation subRep2;
590 OC::OCRepresentation subRep3;
591 subRep1.setNULL("NullAttr");
592 subRep1.setValue("IntAttr", 77);
593 subRep2.setValue("DoubleAttr", 3.333);
594 subRep2.setValue("BoolAttr", true);
595 subRep3.setValue("StringAttr", std::string("String attr"));
597 std::vector<std::vector<std::vector<int>>> iarr
601 {{13,14,15},{16,17,18}}
603 std::vector<std::vector<std::vector<double>>> darr
605 {{1.1,2.2,3.3},{4.4,5.5,6.6}},
606 {{7.7,8.7,9.7},{10.7,12.7}},
607 {{13.7,14.7,15.7},{16.7,17.7,18.7}}
609 std::vector<std::vector<std::vector<bool>>> barr
611 {{false, true},{true}},
612 {{false, true},{true, false}}
614 std::vector<std::vector<std::vector<std::string>>> strarr
616 {{"item1", "item2"},{"item3", "item4"}},
617 {{"item5", "item6"},{"item8"}},
618 {{"item9", "item10"},{"item11", ""}}
620 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
622 {{subRep1, subRep2},{subRep3, subRep1}},
623 {{subRep2, subRep3},{subRep2}},
627 startRep["iarr"] = iarr;
628 startRep["darr"] = darr;
629 startRep["barr"] = barr;
630 startRep["strarr"] = strarr;
631 startRep["objarr"] = objarr;
634 OC::MessageContainer mc1;
635 mc1.addRepresentation(startRep);
637 OCRepPayload* cstart = mc1.getPayload();
638 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
643 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
644 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
645 cborData, cborSize));
646 OCPayloadDestroy((OCPayload*)cstart);
649 OC::MessageContainer mc2;
650 mc2.setPayload(cparsed);
651 EXPECT_EQ(1u, mc2.representations().size());
652 const OC::OCRepresentation& r = mc2.representations()[0];
655 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
656 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
657 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
658 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
659 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
661 // Note: due to the way that the CSDK works, all 3d arrays need to be cuboidal.
662 // Since std::vector doesn't require this, items received on the other side end up
663 // being backfilled. This section removes the backfilling
664 iarr2[1][1].pop_back();
665 darr2[1][1].pop_back();
666 barr2[0][1].pop_back();
667 strarr2[1][1].pop_back();
668 objarr2[1][1].pop_back();
669 objarr2[2].pop_back();
671 EXPECT_EQ(iarr, iarr2);
672 EXPECT_EQ(darr, darr2);
673 EXPECT_EQ(barr, barr2);
674 EXPECT_EQ(strarr, strarr2);
675 EXPECT_EQ(objarr, objarr2);
676 OCPayloadDestroy(cparsed);
679 TEST(DiscoveryRTandIF, SingleItemNormal)
681 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
682 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
683 payload->sid = (uint8_t*)OICMalloc(16);
684 payload->resources = resource;
686 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem"));
687 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, "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);
703 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
704 EXPECT_EQ(NULL, parsedResource->types->next);
705 EXPECT_EQ(NULL, parsedResource->interfaces->next);
706 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
709 OCPayloadDestroy(cparsed);
710 OCDiscoveryPayloadDestroy(payload);
713 TEST(DiscoveryRTandIF, SingleItemFrontTrim)
715 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
716 payload->sid = (uint8_t*)OICMalloc(16);
717 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
718 payload->resources = resource;
720 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, " rt.singleitem"));
721 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, " 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);
747 TEST(DiscoveryRTandIF, SingleItemBackTrim)
749 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
750 payload->sid = (uint8_t*)OICMalloc(16);
751 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
752 payload->resources = resource;
754 OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem ");
755 OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem ");
756 resource->uri = OICStrdup("/uri/thing");
762 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
763 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
764 cborData, cborSize));
766 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
767 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
769 EXPECT_EQ(NULL, parsedResource->next);
771 EXPECT_EQ(NULL, parsedResource->types->next);
772 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
773 EXPECT_EQ(NULL, parsedResource->interfaces->next);
774 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
777 OCPayloadDestroy(cparsed);
778 OCDiscoveryPayloadDestroy(payload);
780 TEST(DiscoveryRTandIF, SingleItemBothTrim)
782 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
783 payload->sid = (uint8_t*)OICMalloc(16);
784 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
785 payload->resources = resource;
787 OCResourcePayloadAddStringLL(&resource->types, " rt.singleitem ");
788 OCResourcePayloadAddStringLL(&resource->interfaces, " if.singleitem ");
789 resource->uri = OICStrdup("/uri/thing");
795 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
796 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
797 cborData, cborSize));
799 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
800 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
802 EXPECT_EQ(NULL, parsedResource->next);
804 EXPECT_EQ(NULL, parsedResource->types->next);
805 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
806 EXPECT_EQ(NULL, parsedResource->interfaces->next);
807 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
810 OCPayloadDestroy(cparsed);
811 OCDiscoveryPayloadDestroy(payload);
813 TEST(DiscoveryRTandIF, MultiItemsNormal)
815 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
816 payload->sid = (uint8_t*)OICMalloc(16);
817 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
818 payload->resources = resource;
820 OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem");
821 OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem");
822 OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem");
823 OCResourcePayloadAddStringLL(&resource->interfaces, "if.seconditem");
824 resource->uri = OICStrdup("/uri/thing");
830 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
831 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
832 cborData, cborSize));
834 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
835 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
837 EXPECT_EQ(NULL, parsedResource->next);
839 EXPECT_EQ(NULL, parsedResource->types->next->next);
840 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
841 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
842 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
843 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
844 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
847 OCPayloadDestroy(cparsed);
848 OCDiscoveryPayloadDestroy(payload);
850 TEST(DiscoveryRTandIF, MultiItemExtraLeadSpaces)
852 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
853 payload->sid = (uint8_t*)OICMalloc(16);
854 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
855 payload->resources = resource;
857 OCResourcePayloadAddStringLL(&resource->types, " rt.firstitem");
858 OCResourcePayloadAddStringLL(&resource->types, " rt.seconditem");
859 OCResourcePayloadAddStringLL(&resource->interfaces, " if.firstitem");
860 OCResourcePayloadAddStringLL(&resource->interfaces, " if.seconditem");
861 resource->uri = OICStrdup("/uri/thing");
867 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
868 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
869 cborData, cborSize));
871 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
872 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
874 EXPECT_EQ(NULL, parsedResource->next);
876 EXPECT_EQ(NULL, parsedResource->types->next->next);
877 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
878 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
879 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
880 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
881 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
884 OCPayloadDestroy(cparsed);
885 OCDiscoveryPayloadDestroy(payload);
887 TEST(DiscoveryRTandIF, MultiItemExtraTrailSpaces)
889 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
890 payload->sid = (uint8_t*)OICMalloc(16);
891 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
892 payload->resources = resource;
894 OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem ");
895 OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem ");
896 OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem ");
897 OCResourcePayloadAddStringLL(&resource->interfaces, "if.seconditem ");
898 resource->uri = OICStrdup("/uri/thing");
904 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
905 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
906 cborData, cborSize));
908 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
909 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
911 EXPECT_EQ(NULL, parsedResource->next);
913 EXPECT_EQ(NULL, parsedResource->types->next->next);
914 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
915 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
916 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
917 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
918 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
921 OCPayloadDestroy(cparsed);
922 OCDiscoveryPayloadDestroy(payload);
924 TEST(DiscoveryRTandIF, MultiItemBothSpaces)
926 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
927 payload->sid = (uint8_t*)OICMalloc(16);
928 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
929 payload->resources = resource;
931 OCResourcePayloadAddStringLL(&resource->types, " rt.firstitem ");
932 OCResourcePayloadAddStringLL(&resource->types, " rt.seconditem ");
933 OCResourcePayloadAddStringLL(&resource->interfaces, " if.firstitem ");
934 OCResourcePayloadAddStringLL(&resource->interfaces, " if.seconditem ");
935 resource->uri = OICStrdup("/uri/thing");
941 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
942 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
943 cborData, cborSize));
945 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
946 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
948 EXPECT_EQ(NULL, parsedResource->next);
950 EXPECT_EQ(NULL, parsedResource->types->next->next);
951 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
952 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
953 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
954 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
955 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
958 OCPayloadDestroy(cparsed);
959 OCDiscoveryPayloadDestroy(payload);
961 TEST(RepresentationEncodingRTandIF, SingleItemNormal)
963 OCRepPayload* payload = OCRepPayloadCreate();
964 OCRepPayloadAddResourceType(payload, "rt.firstitem");
965 OCRepPayloadAddInterface(payload, "if.firstitem");
971 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
972 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
973 cborData, cborSize));
975 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
977 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
978 EXPECT_EQ(NULL, parsedPayload->types->next);
979 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
980 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
983 OCRepPayloadDestroy(payload);
984 OCPayloadDestroy(cparsed);
986 TEST(RepresentationEncodingRTandIF, SingleItemFrontTrim)
988 OCRepPayload* payload = OCRepPayloadCreate();
989 OCRepPayloadAddResourceType(payload, " rt.firstitem");
990 OCRepPayloadAddInterface(payload, " if.firstitem");
996 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
997 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
998 cborData, cborSize));
1000 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1002 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1003 EXPECT_EQ(NULL, parsedPayload->types->next);
1004 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1005 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1009 OCRepPayloadDestroy(payload);
1010 OCPayloadDestroy(cparsed);
1012 TEST(RepresentationEncodingRTandIF, SingleItemBackTrim)
1014 OCRepPayload* payload = OCRepPayloadCreate();
1015 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
1016 OCRepPayloadAddInterface(payload, "if.firstitem ");
1022 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1023 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1024 cborData, cborSize));
1026 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1028 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1029 EXPECT_EQ(NULL, parsedPayload->types->next);
1030 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1031 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1035 OCRepPayloadDestroy(payload);
1036 OCPayloadDestroy(cparsed);
1038 TEST(RepresentationEncodingRTandIF, SingleItemBothTrim)
1040 OCRepPayload* payload = OCRepPayloadCreate();
1041 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1042 OCRepPayloadAddInterface(payload, " if.firstitem ");
1048 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1049 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1050 cborData, cborSize));
1052 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1054 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1055 EXPECT_EQ(NULL, parsedPayload->types->next);
1056 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1057 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1061 OCRepPayloadDestroy(payload);
1062 OCPayloadDestroy(cparsed);
1064 TEST(RepresentationEncodingRTandIF, MultiItemsNormal)
1066 OCRepPayload* payload = OCRepPayloadCreate();
1067 OCRepPayloadAddResourceType(payload, "rt.firstitem");
1068 OCRepPayloadAddResourceType(payload, "rt.seconditem");
1069 OCRepPayloadAddInterface(payload, "if.firstitem");
1070 OCRepPayloadAddInterface(payload, "if.seconditem");
1076 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1077 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1078 cborData, cborSize));
1080 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1082 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1083 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1084 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1085 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1086 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1087 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1091 OCRepPayloadDestroy(payload);
1092 OCPayloadDestroy(cparsed);
1094 TEST(RepresentationEncodingRTandIF, MultiItemExtraLeadSpaces)
1096 OCRepPayload* payload = OCRepPayloadCreate();
1097 OCRepPayloadAddResourceType(payload, " rt.firstitem");
1098 OCRepPayloadAddResourceType(payload, " rt.seconditem");
1099 OCRepPayloadAddInterface(payload, " if.firstitem");
1100 OCRepPayloadAddInterface(payload, " if.seconditem");
1106 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1107 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1108 cborData, cborSize));
1110 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1112 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1113 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1114 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1115 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1116 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1117 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1121 OCRepPayloadDestroy(payload);
1122 OCPayloadDestroy(cparsed);
1124 TEST(RepresentationEncodingRTandIF, MultiItemExtraTrailSpaces)
1126 OCRepPayload* payload = OCRepPayloadCreate();
1127 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
1128 OCRepPayloadAddResourceType(payload, "rt.seconditem ");
1129 OCRepPayloadAddInterface(payload, "if.firstitem ");
1130 OCRepPayloadAddInterface(payload, "if.seconditem ");
1136 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1137 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1138 cborData, cborSize));
1140 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1142 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1143 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1144 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1145 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1146 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1147 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1151 OCRepPayloadDestroy(payload);
1152 OCPayloadDestroy(cparsed);
1154 TEST(RepresentationEncodingRTandIF, MultiItemExtraMiddleSpaces)
1156 OCRepPayload* payload = OCRepPayloadCreate();
1157 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1158 OCRepPayloadAddResourceType(payload, " rt.seconditem ");
1159 OCRepPayloadAddInterface(payload, " if.firstitem ");
1160 OCRepPayloadAddInterface(payload, " if.seconditem ");
1166 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1167 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1168 cborData, cborSize));
1170 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1172 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1173 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1174 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1175 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1176 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1177 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1181 OCRepPayloadDestroy(payload);
1182 OCPayloadDestroy(cparsed);
1184 TEST(RepresentationEncodingRTandIF, TestPayloadContents)
1186 OC::OCRepresentation subRep1;
1187 std::vector<std::string> types;
1188 types.push_back("rt.firstitem");
1189 std::vector<std::string> interfaces;
1190 interfaces.push_back("if.firstitem");
1191 subRep1.setResourceTypes(types);
1192 subRep1.setResourceInterfaces(interfaces);
1193 subRep1.setNULL("NullAttr");
1194 subRep1.setValue("IntAttr", 77);
1195 subRep1.setValue("DoubleAttr", 3.333);
1196 subRep1.setValue("BoolAttr", true);
1197 subRep1.setValue("StringAttr", std::string("String attr"));
1199 OC::MessageContainer mc1;
1200 mc1.addRepresentation(subRep1);
1202 OCRepPayload *repPayload = mc1.getPayload();
1203 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, repPayload->base.type);
1205 uint8_t *cborData = NULL;
1206 size_t cborSize = 0;
1207 OCPayload *cparsed = NULL;
1209 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)repPayload, &cborData, &cborSize));
1210 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1211 cborData, cborSize));
1213 OCRepPayload *parsedPayload = (OCRepPayload *)cparsed;
1214 EXPECT_EQ(NULL, parsedPayload->uri);
1215 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1216 EXPECT_EQ(NULL, parsedPayload->types->next);
1217 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1218 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1220 // To make sure rt and if are not duplicated.
1221 EXPECT_STREQ("BoolAttr", parsedPayload->values->name);
1222 EXPECT_EQ(true, parsedPayload->values->b);
1223 EXPECT_EQ(OCREP_PROP_BOOL, parsedPayload->values->type);
1224 parsedPayload->values = parsedPayload->values->next;
1226 EXPECT_STREQ("DoubleAttr", parsedPayload->values->name);
1227 EXPECT_EQ(OCREP_PROP_DOUBLE, parsedPayload->values->type);
1228 EXPECT_EQ(3.3330000000000002, parsedPayload->values->d);
1229 parsedPayload->values = parsedPayload->values->next;
1231 EXPECT_STREQ("IntAttr", parsedPayload->values->name);
1232 EXPECT_EQ(77, parsedPayload->values->i);
1233 EXPECT_EQ(OCREP_PROP_INT, parsedPayload->values->type);
1234 parsedPayload->values = parsedPayload->values->next;
1236 EXPECT_STREQ("NullAttr", parsedPayload->values->name);
1237 EXPECT_EQ(OCREP_PROP_NULL, parsedPayload->values->type);
1238 parsedPayload->values = parsedPayload->values->next;
1240 EXPECT_STREQ("StringAttr", parsedPayload->values->name);
1241 EXPECT_STREQ("String attr", parsedPayload->values->str);
1242 EXPECT_EQ(OCREP_PROP_STRING, parsedPayload->values->type);
1243 parsedPayload->values = parsedPayload->values->next;
1245 EXPECT_EQ(NULL, parsedPayload->values);
1248 OCRepPayloadDestroy(repPayload);
1249 OCPayloadDestroy(cparsed);