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[] = "646F6F72-4465-7669-6365-555549443030";
53 static const char devicename1[] = "device name";
54 static const char specver1[] = "spec version";
55 static const char dmver1[] = "res.1.1.0,sh.1.1.0";
56 static OCStringLL *types = NULL;
58 TEST(DeviceDiscoveryEncoding, Normal)
60 OCResourcePayloadAddStringLL(&types, "oic.wk.d");
61 OCResourcePayloadAddStringLL(&types, "oic.d.tv");
63 OCDevicePayload* device = OCDevicePayloadCreate(
70 EXPECT_STREQ(sid1, device->sid);
71 EXPECT_STREQ(devicename1, device->deviceName);
72 EXPECT_STREQ(specver1, device->specVersion);
73 EXPECT_TRUE(device->dataModelVersions);
74 EXPECT_STREQ("res.1.1.0", device->dataModelVersions->value);
75 EXPECT_TRUE(device->dataModelVersions->next);
76 EXPECT_STREQ("sh.1.1.0", device->dataModelVersions->next->value);
77 EXPECT_EQ(PAYLOAD_TYPE_DEVICE, ((OCPayload*)device)->type);
78 EXPECT_STREQ("oic.wk.d", device->types->value);
79 EXPECT_STREQ("oic.d.tv", device->types->next->value);
83 OCPayload* parsedDevice;
84 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)device, &cborData, &cborSize));
85 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedDevice, PAYLOAD_TYPE_DEVICE,
89 EXPECT_STREQ(device->sid, ((OCDevicePayload*)parsedDevice)->sid);
90 EXPECT_STREQ(device->deviceName, ((OCDevicePayload*)parsedDevice)->deviceName);
91 EXPECT_STREQ(device->specVersion, ((OCDevicePayload*)parsedDevice)->specVersion);
92 EXPECT_STREQ(device->dataModelVersions->value, ((OCDevicePayload*)parsedDevice)->dataModelVersions->value);
93 EXPECT_STREQ("oic.wk.d", ((OCDevicePayload*)parsedDevice)->types->value);
94 EXPECT_STREQ("oic.d.tv", ((OCDevicePayload*)parsedDevice)->types->next->value);
95 EXPECT_EQ(device->base.type, ((OCDevicePayload*)parsedDevice)->base.type);
97 OCPayloadDestroy((OCPayload*)device);
99 OC::MessageContainer mc;
100 mc.setPayload(parsedDevice);
101 EXPECT_EQ(1u, mc.representations().size());
102 const OC::OCRepresentation& r = mc.representations()[0];
103 EXPECT_STREQ(sid1, r.getValue<std::string>(OC_RSRVD_DEVICE_ID).c_str());
104 EXPECT_STREQ(devicename1, r.getValue<std::string>(OC_RSRVD_DEVICE_NAME).c_str());
105 EXPECT_STREQ(specver1, r.getValue<std::string>(OC_RSRVD_SPEC_VERSION).c_str());
106 EXPECT_STREQ("res.1.1.0", r.getDataModelVersions()[0].c_str());
107 EXPECT_STREQ("sh.1.1.0", r.getDataModelVersions()[1].c_str());
109 OCPayloadDestroy(parsedDevice);
112 static const char uri1[] = "/testuri";
113 static char pfid1[] = "pfid";
114 static char mfgnm1[] = "mfgnm";
115 static char mfgurl1[] = "mfgurl";
116 static char modelnum1[] = "modelnum";
117 static char dom1[] = "dom";
118 static char pfver1[] = "pfver";
119 static char osver1[] = "osver";
120 static char hwver1[] = "hwver";
121 static char fwver1[] = "fwver";
122 static char url1[] = "url";
123 static char time1[] = "time";
126 TEST(PlatformDiscoveryEncoding, Normal)
128 OCPlatformInfo info {pfid1, mfgnm1, mfgurl1, modelnum1, dom1, pfver1, osver1, hwver1,
129 fwver1, url1, time1};
130 OCPlatformPayload* platform = OCPlatformPayloadCreate(&info);
131 EXPECT_EQ(PAYLOAD_TYPE_PLATFORM, ((OCPayload*)platform)->type);
132 EXPECT_STREQ(pfid1, platform->info.platformID);
133 EXPECT_STREQ(mfgnm1, platform->info.manufacturerName);
134 EXPECT_STREQ(mfgurl1, platform->info.manufacturerUrl);
135 EXPECT_STREQ(modelnum1, platform->info.modelNumber);
136 EXPECT_STREQ(dom1, platform->info.dateOfManufacture);
137 EXPECT_STREQ(pfver1, platform->info.platformVersion);
138 EXPECT_STREQ(osver1, platform->info.operatingSystemVersion);
139 EXPECT_STREQ(hwver1, platform->info.hardwareVersion);
140 EXPECT_STREQ(fwver1, platform->info.firmwareVersion);
141 EXPECT_STREQ(url1, platform->info.supportUrl);
142 EXPECT_STREQ(time1, platform->info.systemTime);
143 EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, platform->interfaces->value);
144 EXPECT_STREQ(OC_RSRVD_INTERFACE_READ, platform->interfaces->next->value);
145 EXPECT_STREQ(OC_RSRVD_RESOURCE_TYPE_PLATFORM, platform->rt->value);
149 OCPayload* parsedPlatform;
150 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)platform, &cborData, &cborSize));
151 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedPlatform, PAYLOAD_TYPE_PLATFORM,
152 cborData, cborSize));
155 EXPECT_EQ(platform->base.type, ((OCPlatformPayload*)parsedPlatform)->base.type);
156 OCPlatformPayload* platform2 = (OCPlatformPayload*)parsedPlatform;
157 EXPECT_STREQ(platform->info.platformID, platform2->info.platformID);
158 EXPECT_STREQ(platform->info.manufacturerName, platform->info.manufacturerName);
159 EXPECT_STREQ(platform->info.manufacturerUrl, platform->info.manufacturerUrl);
160 EXPECT_STREQ(platform->info.modelNumber, platform->info.modelNumber);
161 EXPECT_STREQ(platform->info.dateOfManufacture, platform->info.dateOfManufacture);
162 EXPECT_STREQ(platform->info.platformVersion, platform->info.platformVersion);
163 EXPECT_STREQ(platform->info.operatingSystemVersion, platform->info.operatingSystemVersion);
164 EXPECT_STREQ(platform->info.hardwareVersion, platform->info.hardwareVersion);
165 EXPECT_STREQ(platform->info.firmwareVersion, platform->info.firmwareVersion);
166 EXPECT_STREQ(platform->info.supportUrl, platform->info.supportUrl);
167 EXPECT_STREQ(platform->info.systemTime, platform2->info.systemTime);
168 EXPECT_STREQ(platform->interfaces->value, platform2->interfaces->value);
169 EXPECT_STREQ(platform->rt->value, platform2->rt->value);
171 OCPayloadDestroy((OCPayload*)platform);
173 OC::MessageContainer mc;
174 mc.setPayload(parsedPlatform);
175 EXPECT_EQ(1u, mc.representations().size());
176 const OC::OCRepresentation& r = mc.representations()[0];
177 EXPECT_STREQ(pfid1, r.getValue<std::string>(OC_RSRVD_PLATFORM_ID).c_str());
178 EXPECT_STREQ(mfgnm1, r.getValue<std::string>(OC_RSRVD_MFG_NAME).c_str());
179 EXPECT_STREQ(mfgurl1, r.getValue<std::string>(OC_RSRVD_MFG_URL).c_str());
180 EXPECT_STREQ(modelnum1, r.getValue<std::string>(OC_RSRVD_MODEL_NUM).c_str());
181 EXPECT_STREQ(dom1, r.getValue<std::string>(OC_RSRVD_MFG_DATE).c_str());
182 EXPECT_STREQ(pfver1, r.getValue<std::string>(OC_RSRVD_PLATFORM_VERSION).c_str());
183 EXPECT_STREQ(osver1, r.getValue<std::string>(OC_RSRVD_OS_VERSION).c_str());
184 EXPECT_STREQ(hwver1, r.getValue<std::string>(OC_RSRVD_HARDWARE_VERSION).c_str());
185 EXPECT_STREQ(fwver1, r.getValue<std::string>(OC_RSRVD_FIRMWARE_VERSION).c_str());
186 EXPECT_STREQ(url1, r.getValue<std::string>(OC_RSRVD_SUPPORT_URL).c_str());
187 EXPECT_STREQ(time1, r.getValue<std::string>(OC_RSRVD_SYSTEM_TIME).c_str());
189 OCPayloadDestroy(parsedPlatform);
191 TEST(PresencePayload, Normal)
194 uint32_t sequenceNumber = 0;
195 OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE;
196 OCPresencePayload *presence = OCPresencePayloadCreate(sequenceNumber, maxAge, trigger, uri1);
201 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)presence, &cborData, &cborSize));
202 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_PRESENCE,
203 cborData, cborSize));
204 OCPayloadDestroy((OCPayload*)presence);
207 OCPresencePayload* parsed = ((OCPresencePayload*)cparsed);
208 EXPECT_EQ(sequenceNumber, parsed->sequenceNumber);
209 EXPECT_EQ(maxAge, parsed->maxAge);
210 EXPECT_EQ(trigger, parsed->trigger);
211 EXPECT_STREQ(uri1, parsed->resourceType);
213 OCPayloadDestroy(cparsed);
215 // Representation Payloads
216 TEST(RepresentationEncoding, BaseAttributeTypes)
218 OC::OCRepresentation startRep;
219 startRep.setNULL("NullAttr");
220 startRep.setValue("IntAttr", 77);
221 startRep.setValue("DoubleAttr", 3.333);
222 startRep.setValue("BoolAttr", true);
223 startRep.setValue("StringAttr", std::string("String attr"));
224 OC::MessageContainer mc1;
225 mc1.addRepresentation(startRep);
227 OCRepPayload* cstart = mc1.getPayload();
228 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
233 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
234 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
235 cborData, cborSize));
236 OCPayloadDestroy((OCPayload*)cstart);
239 OC::MessageContainer mc2;
240 mc2.setPayload(cparsed);
241 EXPECT_EQ(1u, mc2.representations().size());
242 const OC::OCRepresentation& r = mc2.representations()[0];
244 EXPECT_TRUE(r.isNULL("NullAttr"));
245 EXPECT_EQ(77, r.getValue<int>("IntAttr"));
246 EXPECT_EQ(3.333, r.getValue<double>("DoubleAttr"));
247 EXPECT_EQ(true, r.getValue<bool>("BoolAttr"));
248 EXPECT_STREQ("String attr", r.getValue<std::string>("StringAttr").c_str());
250 OCPayloadDestroy(cparsed);
253 TEST(RepresentationEncoding, RepAttributeEmpty)
255 OC::OCRepresentation startRep;
256 std::vector<int> iarr {};
257 startRep["iarr"] = {};
259 OC::MessageContainer mc1;
260 mc1.addRepresentation(startRep);
262 OCRepPayload* cstart = mc1.getPayload();
263 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
265 uint8_t *cborData = NULL;
267 OCPayload *cparsed = NULL;
268 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
269 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
270 cborData, cborSize));
271 OCPayloadDestroy((OCPayload*)cstart);
274 OC::MessageContainer mc2;
275 mc2.setPayload(cparsed);
276 EXPECT_EQ(1u, mc2.representations().size());
277 const OC::OCRepresentation& r = mc2.representations()[0];
279 std::vector<int> iarr2 = r["iarr"];
281 EXPECT_EQ(iarr, iarr2);
282 OCPayloadDestroy(cparsed);
285 TEST(RepresentationEncoding, RepAttribute)
287 OC::OCRepresentation startRep;
288 OC::OCRepresentation subRep;
289 subRep.setNULL("NullAttr");
290 subRep.setValue("IntAttr", 77);
291 subRep.setValue("DoubleAttr", 3.333);
292 subRep.setValue("BoolAttr", true);
293 subRep.setValue("StringAttr", std::string("String attr"));
294 std::vector<uint8_t> bin_data {5,3,4,5,6,0,34,2,4,5,6,3};
295 subRep.setValue("BinaryAttr", bin_data);
296 startRep.setValue("Sub", subRep);
298 OC::MessageContainer mc1;
299 mc1.addRepresentation(startRep);
301 OCRepPayload* cstart = mc1.getPayload();
302 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
307 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
308 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
309 cborData, cborSize));
310 OCPayloadDestroy((OCPayload*)cstart);
313 OC::MessageContainer mc2;
314 mc2.setPayload(cparsed);
315 EXPECT_EQ(1u, mc2.representations().size());
316 const OC::OCRepresentation& r = mc2.representations()[0];
318 OC::OCRepresentation newSubRep = r["Sub"];
320 EXPECT_TRUE(newSubRep.isNULL("NullAttr"));
321 EXPECT_EQ(77, newSubRep.getValue<int>("IntAttr"));
322 EXPECT_EQ(3.333, newSubRep.getValue<double>("DoubleAttr"));
323 EXPECT_EQ(true, newSubRep.getValue<bool>("BoolAttr"));
324 EXPECT_STREQ("String attr", newSubRep.getValue<std::string>("StringAttr").c_str());
326 newSubRep.getValue<std::vector<uint8_t>>("BinaryAttr"));
327 OCPayloadDestroy(cparsed);
330 TEST(RepresentationEncoding, OneDVectors)
333 OC::OCRepresentation startRep;
335 OC::OCRepresentation subRep1;
336 OC::OCRepresentation subRep2;
337 OC::OCRepresentation subRep3;
338 subRep1.setNULL("NullAttr");
339 subRep1.setValue("IntAttr", 77);
340 subRep2.setValue("DoubleAttr", 3.333);
341 subRep2.setValue("BoolAttr", true);
342 subRep3.setValue("StringAttr", std::string("String attr"));
344 std::vector<int> iarr {1,2,3,4,5,6,7,8,9};
345 std::vector<double> darr {1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9};
346 std::vector<bool> barr {false, true, false, false, true, true};
347 std::vector<std::string> strarr {"item1", "item2", "item3", "item4"};
348 std::vector<OC::OCRepresentation> objarr {subRep1, subRep2, subRep3};
350 startRep["iarr"] = iarr;
351 startRep["darr"] = darr;
352 startRep["barr"] = barr;
353 startRep["strarr"] = strarr;
354 startRep["objarr"] = objarr;
357 OC::MessageContainer mc1;
358 mc1.addRepresentation(startRep);
360 OCRepPayload* cstart = mc1.getPayload();
361 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
366 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
367 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
368 cborData, cborSize));
369 OCPayloadDestroy((OCPayload*)cstart);
372 OC::MessageContainer mc2;
373 mc2.setPayload(cparsed);
374 EXPECT_EQ(1u, mc2.representations().size());
375 const OC::OCRepresentation& r = mc2.representations()[0];
378 std::vector<int> iarr2 = r["iarr"];
379 std::vector<double> darr2 = r["darr"];
380 std::vector<bool> barr2 = r["barr"];
381 std::vector<std::string> strarr2 = r["strarr"];
382 std::vector<OC::OCRepresentation> objarr2 = r["objarr"];
384 EXPECT_EQ(iarr, iarr2);
385 EXPECT_EQ(darr, darr2);
386 EXPECT_EQ(barr, barr2);
387 EXPECT_EQ(strarr, strarr2);
388 EXPECT_EQ(objarr, objarr2);
389 OCPayloadDestroy(cparsed);
392 TEST(RepresentationEncoding, TwoDVectors)
395 OC::OCRepresentation startRep;
397 OC::OCRepresentation subRep1;
398 OC::OCRepresentation subRep2;
399 OC::OCRepresentation subRep3;
400 subRep1.setNULL("NullAttr");
401 subRep1.setValue("IntAttr", 77);
402 subRep2.setValue("DoubleAttr", 3.333);
403 subRep2.setValue("BoolAttr", true);
404 subRep3.setValue("StringAttr", std::string("String attr"));
406 std::vector<std::vector<int>> iarr {{1,2,3},{4,5,6},{7,8,9}};
407 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{7.7,8.8,9.9}};
408 std::vector<std::vector<bool>> barr {{false, true}, {false, false}, {true, true}};
409 std::vector<std::vector<std::string>> strarr {{"item1", "item2"}, {"item3", "item4"}};
410 std::vector<std::vector<OC::OCRepresentation>> objarr
411 {{subRep1, subRep2, subRep3}, {subRep3, subRep2, subRep1}};
413 startRep["iarr"] = iarr;
414 startRep["darr"] = darr;
415 startRep["barr"] = barr;
416 startRep["strarr"] = strarr;
417 startRep["objarr"] = objarr;
420 OC::MessageContainer mc1;
421 mc1.addRepresentation(startRep);
423 OCRepPayload* cstart = mc1.getPayload();
424 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
429 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
430 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
431 cborData, cborSize));
432 OCPayloadDestroy((OCPayload*)cstart);
435 OC::MessageContainer mc2;
436 mc2.setPayload(cparsed);
437 EXPECT_EQ(1u, mc2.representations().size());
438 const OC::OCRepresentation& r = mc2.representations()[0];
441 std::vector<std::vector<int>> iarr2 = r["iarr"];
442 std::vector<std::vector<double>> darr2 = r["darr"];
443 std::vector<std::vector<bool>> barr2 = r["barr"];
444 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
445 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
447 EXPECT_EQ(iarr, iarr2);
448 EXPECT_EQ(darr, darr2);
449 EXPECT_EQ(barr, barr2);
450 EXPECT_EQ(strarr, strarr2);
451 EXPECT_EQ(objarr, objarr2);
452 OCPayloadDestroy(cparsed);
455 TEST(RepresentationEncoding, TwoDVectorsJagged)
458 OC::OCRepresentation startRep;
460 OC::OCRepresentation subRep1;
461 OC::OCRepresentation subRep2;
462 OC::OCRepresentation subRep3;
463 subRep1.setNULL("NullAttr");
464 subRep1.setValue("IntAttr", 77);
465 subRep2.setValue("DoubleAttr", 3.333);
466 subRep2.setValue("BoolAttr", true);
467 subRep3.setValue("StringAttr", std::string("String attr"));
469 std::vector<std::vector<int>> iarr {{1,2,3},{4,6},{7,8,9}};
470 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{8.8,9.9}};
471 std::vector<std::vector<bool>> barr {{false, true}, {false}, {true, true}};
472 std::vector<std::vector<std::string>> strarr {{"item1"}, {"item3", "item4"}};
473 std::vector<std::vector<OC::OCRepresentation>> objarr
474 {{subRep1, subRep3}, {subRep3, subRep2, subRep1}};
476 startRep["iarr"] = iarr;
477 startRep["darr"] = darr;
478 startRep["barr"] = barr;
479 startRep["strarr"] = strarr;
480 startRep["objarr"] = objarr;
483 OC::MessageContainer mc1;
484 mc1.addRepresentation(startRep);
486 OCRepPayload* cstart = mc1.getPayload();
487 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
492 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
493 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
494 cborData, cborSize));
495 OCPayloadDestroy((OCPayload*)cstart);
498 OC::MessageContainer mc2;
499 mc2.setPayload(cparsed);
500 EXPECT_EQ(1u, mc2.representations().size());
501 const OC::OCRepresentation& r = mc2.representations()[0];
504 std::vector<std::vector<int>> iarr2 = r["iarr"];
505 std::vector<std::vector<double>> darr2 = r["darr"];
506 std::vector<std::vector<bool>> barr2 = r["barr"];
507 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
508 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
510 // Note: due to the way that the CSDK works, all 2d arrays need to be rectangular.
511 // Since std::vector doesn't require this, items received on the other side end up
512 // being backfilled. This section removes the backfilling
516 strarr2[0].pop_back();
517 objarr2[0].pop_back();
519 EXPECT_EQ(iarr, iarr2);
520 EXPECT_EQ(darr, darr2);
521 EXPECT_EQ(barr, barr2);
522 EXPECT_EQ(strarr, strarr2);
523 EXPECT_EQ(objarr, objarr2);
524 OCPayloadDestroy(cparsed);
527 TEST(RepresentationEncoding, ThreeDVectors)
530 OC::OCRepresentation startRep;
532 OC::OCRepresentation subRep1;
533 OC::OCRepresentation subRep2;
534 OC::OCRepresentation subRep3;
535 subRep1.setNULL("NullAttr");
536 subRep1.setValue("IntAttr", 77);
537 subRep2.setValue("DoubleAttr", 3.333);
538 subRep2.setValue("BoolAttr", true);
539 subRep3.setValue("StringAttr", std::string("String attr"));
541 std::vector<std::vector<std::vector<int>>> iarr
542 {{{1,2,3},{4,5,6}},{{7,8,9},{10,11,12}},{{13,14,15},{16,17,18}}};
543 std::vector<std::vector<std::vector<double>>> darr
544 {{{1.1,2.2,3.3},{4.4,5.5,6.6}},
545 {{7.7,8.7,9.7},{10.7,11.7,12.7}},
546 {{13.7,14.7,15.7},{16.7,17.7,18.7}}};
547 std::vector<std::vector<std::vector<bool>>> barr
548 {{{false, true},{true, false}},{{false, true},{true, false}}};
549 std::vector<std::vector<std::vector<std::string>>> strarr
551 {{"item1", "item2"},{"item3", "item4"}},
552 {{"item5", "item6"},{"item7", "item8"}},
553 {{"item9", "item10"},{"item11", ""}}
555 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
557 {{subRep1, subRep2},{subRep3, subRep1}},
558 {{subRep2, subRep3},{subRep2, subRep1}},
559 {{subRep3, subRep2},{subRep1, subRep2}}
562 startRep["iarr"] = iarr;
563 startRep["darr"] = darr;
564 startRep["barr"] = barr;
565 startRep["strarr"] = strarr;
566 startRep["objarr"] = objarr;
569 OC::MessageContainer mc1;
570 mc1.addRepresentation(startRep);
572 OCRepPayload* cstart = mc1.getPayload();
573 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
578 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
579 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
580 cborData, cborSize));
581 OCPayloadDestroy((OCPayload*)cstart);
584 OC::MessageContainer mc2;
585 mc2.setPayload(cparsed);
586 EXPECT_EQ(1u, mc2.representations().size());
587 const OC::OCRepresentation& r = mc2.representations()[0];
590 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
591 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
592 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
593 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
594 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
596 EXPECT_EQ(iarr, iarr2);
597 EXPECT_EQ(darr, darr2);
598 EXPECT_EQ(barr, barr2);
599 EXPECT_EQ(strarr, strarr2);
600 EXPECT_EQ(objarr, objarr2);
601 OCPayloadDestroy(cparsed);
604 TEST(RepresentationEncoding, ThreeDVectorsJagged)
607 OC::OCRepresentation startRep;
609 OC::OCRepresentation subRep1;
610 OC::OCRepresentation subRep2;
611 OC::OCRepresentation subRep3;
612 subRep1.setNULL("NullAttr");
613 subRep1.setValue("IntAttr", 77);
614 subRep2.setValue("DoubleAttr", 3.333);
615 subRep2.setValue("BoolAttr", true);
616 subRep3.setValue("StringAttr", std::string("String attr"));
618 std::vector<std::vector<std::vector<int>>> iarr
622 {{13,14,15},{16,17,18}}
624 std::vector<std::vector<std::vector<double>>> darr
626 {{1.1,2.2,3.3},{4.4,5.5,6.6}},
627 {{7.7,8.7,9.7},{10.7,12.7}},
628 {{13.7,14.7,15.7},{16.7,17.7,18.7}}
630 std::vector<std::vector<std::vector<bool>>> barr
632 {{false, true},{true}},
633 {{false, true},{true, false}}
635 std::vector<std::vector<std::vector<std::string>>> strarr
637 {{"item1", "item2"},{"item3", "item4"}},
638 {{"item5", "item6"},{"item8"}},
639 {{"item9", "item10"},{"item11", ""}}
641 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
643 {{subRep1, subRep2},{subRep3, subRep1}},
644 {{subRep2, subRep3},{subRep2}},
648 startRep["iarr"] = iarr;
649 startRep["darr"] = darr;
650 startRep["barr"] = barr;
651 startRep["strarr"] = strarr;
652 startRep["objarr"] = objarr;
655 OC::MessageContainer mc1;
656 mc1.addRepresentation(startRep);
658 OCRepPayload* cstart = mc1.getPayload();
659 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
664 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
665 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
666 cborData, cborSize));
667 OCPayloadDestroy((OCPayload*)cstart);
670 OC::MessageContainer mc2;
671 mc2.setPayload(cparsed);
672 EXPECT_EQ(1u, mc2.representations().size());
673 const OC::OCRepresentation& r = mc2.representations()[0];
676 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
677 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
678 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
679 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
680 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
682 // Note: due to the way that the CSDK works, all 3d arrays need to be cuboidal.
683 // Since std::vector doesn't require this, items received on the other side end up
684 // being backfilled. This section removes the backfilling
685 iarr2[1][1].pop_back();
686 darr2[1][1].pop_back();
687 barr2[0][1].pop_back();
688 strarr2[1][1].pop_back();
689 objarr2[1][1].pop_back();
690 objarr2[2].pop_back();
692 EXPECT_EQ(iarr, iarr2);
693 EXPECT_EQ(darr, darr2);
694 EXPECT_EQ(barr, barr2);
695 EXPECT_EQ(strarr, strarr2);
696 EXPECT_EQ(objarr, objarr2);
697 OCPayloadDestroy(cparsed);
700 TEST(DiscoveryRTandIF, SingleItemNormal)
702 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
703 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
704 payload->sid = OICStrdup(sid1);
705 payload->resources = resource;
707 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem"));
708 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem"));
710 resource->uri = OICStrdup("/uri/thing");
716 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
717 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
718 cborData, cborSize));
720 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
721 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
723 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
724 EXPECT_EQ(NULL, parsedResource->next);
725 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
726 EXPECT_EQ(NULL, parsedResource->types->next);
727 EXPECT_EQ(NULL, parsedResource->interfaces->next);
728 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
731 OCPayloadDestroy(cparsed);
732 OCDiscoveryPayloadDestroy(payload);
735 TEST(DiscoveryRTandIF, SingleItemFrontTrim)
737 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
738 payload->sid = OICStrdup(sid1);
739 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
740 payload->resources = resource;
742 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, " rt.singleitem"));
743 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, " if.singleitem"));
744 resource->uri = OICStrdup("/uri/thing");
750 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
751 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
752 cborData, cborSize));
754 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
755 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
757 EXPECT_EQ(NULL, parsedResource->next);
758 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
759 EXPECT_EQ(NULL, parsedResource->types->next);
760 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
761 EXPECT_EQ(NULL, parsedResource->interfaces->next);
762 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
765 OCPayloadDestroy(cparsed);
766 OCDiscoveryPayloadDestroy(payload);
769 TEST(DiscoveryRTandIF, SingleItemBackTrim)
771 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
772 payload->sid = OICStrdup(sid1);
773 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
774 payload->resources = resource;
776 OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem ");
777 OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem ");
778 resource->uri = OICStrdup("/uri/thing");
784 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
785 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
786 cborData, cborSize));
788 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
789 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
791 EXPECT_EQ(NULL, parsedResource->next);
792 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
793 EXPECT_EQ(NULL, parsedResource->types->next);
794 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
795 EXPECT_EQ(NULL, parsedResource->interfaces->next);
796 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
799 OCPayloadDestroy(cparsed);
800 OCDiscoveryPayloadDestroy(payload);
802 TEST(DiscoveryRTandIF, SingleItemBothTrim)
804 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
805 payload->sid = OICStrdup(sid1);
806 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
807 payload->resources = resource;
809 OCResourcePayloadAddStringLL(&resource->types, " rt.singleitem ");
810 OCResourcePayloadAddStringLL(&resource->interfaces, " if.singleitem ");
811 resource->uri = OICStrdup("/uri/thing");
817 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
818 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
819 cborData, cborSize));
821 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
822 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
824 EXPECT_EQ(NULL, parsedResource->next);
825 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
826 EXPECT_EQ(NULL, parsedResource->types->next);
827 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
828 EXPECT_EQ(NULL, parsedResource->interfaces->next);
829 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
832 OCPayloadDestroy(cparsed);
833 OCDiscoveryPayloadDestroy(payload);
835 TEST(DiscoveryRTandIF, MultiItemsNormal)
837 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
838 payload->sid = OICStrdup(sid1);
839 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
840 payload->resources = resource;
842 OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem");
843 OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem");
844 OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem");
845 OCResourcePayloadAddStringLL(&resource->interfaces, "if.seconditem");
846 resource->uri = OICStrdup("/uri/thing");
852 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
853 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
854 cborData, cborSize));
856 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
857 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
859 EXPECT_EQ(NULL, parsedResource->next);
860 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
861 EXPECT_EQ(NULL, parsedResource->types->next->next);
862 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
863 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
864 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
865 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
866 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
869 OCPayloadDestroy(cparsed);
870 OCDiscoveryPayloadDestroy(payload);
872 TEST(DiscoveryRTandIF, MultiItemExtraLeadSpaces)
874 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
875 payload->sid = OICStrdup(sid1);
876 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
877 payload->resources = resource;
879 OCResourcePayloadAddStringLL(&resource->types, " rt.firstitem");
880 OCResourcePayloadAddStringLL(&resource->types, " rt.seconditem");
881 OCResourcePayloadAddStringLL(&resource->interfaces, " if.firstitem");
882 OCResourcePayloadAddStringLL(&resource->interfaces, " if.seconditem");
883 resource->uri = OICStrdup("/uri/thing");
889 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
890 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
891 cborData, cborSize));
893 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
894 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
896 EXPECT_EQ(NULL, parsedResource->next);
897 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
898 EXPECT_EQ(NULL, parsedResource->types->next->next);
899 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
900 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
901 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
902 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
903 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
906 OCPayloadDestroy(cparsed);
907 OCDiscoveryPayloadDestroy(payload);
909 TEST(DiscoveryRTandIF, MultiItemExtraTrailSpaces)
911 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
912 payload->sid = OICStrdup(sid1);
913 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
914 payload->resources = resource;
916 OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem ");
917 OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem ");
918 OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem ");
919 OCResourcePayloadAddStringLL(&resource->interfaces, "if.seconditem ");
920 resource->uri = OICStrdup("/uri/thing");
926 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
927 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
928 cborData, cborSize));
930 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
931 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
933 EXPECT_EQ(NULL, parsedResource->next);
934 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
935 EXPECT_EQ(NULL, parsedResource->types->next->next);
936 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
937 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
938 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
939 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
940 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
943 OCPayloadDestroy(cparsed);
944 OCDiscoveryPayloadDestroy(payload);
946 TEST(DiscoveryRTandIF, MultiItemBothSpaces)
948 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
949 payload->sid = OICStrdup(sid1);
950 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
951 payload->resources = resource;
953 OCResourcePayloadAddStringLL(&resource->types, " rt.firstitem ");
954 OCResourcePayloadAddStringLL(&resource->types, " rt.seconditem ");
955 OCResourcePayloadAddStringLL(&resource->interfaces, " if.firstitem ");
956 OCResourcePayloadAddStringLL(&resource->interfaces, " if.seconditem ");
957 resource->uri = OICStrdup("/uri/thing");
963 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
964 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
965 cborData, cborSize));
967 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
968 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
970 EXPECT_EQ(NULL, parsedResource->next);
971 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
972 EXPECT_EQ(NULL, parsedResource->types->next->next);
973 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
974 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
975 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
976 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
977 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
980 OCPayloadDestroy(cparsed);
981 OCDiscoveryPayloadDestroy(payload);
983 TEST(RepresentationEncodingRTandIF, SingleItemNormal)
985 OCRepPayload* payload = OCRepPayloadCreate();
986 OCRepPayloadAddResourceType(payload, "rt.firstitem");
987 OCRepPayloadAddInterface(payload, "if.firstitem");
993 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
994 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
995 cborData, cborSize));
997 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
999 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1000 EXPECT_EQ(NULL, parsedPayload->types->next);
1001 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1002 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1005 OCRepPayloadDestroy(payload);
1006 OCPayloadDestroy(cparsed);
1008 TEST(RepresentationEncodingRTandIF, SingleItemFrontTrim)
1010 OCRepPayload* payload = OCRepPayloadCreate();
1011 OCRepPayloadAddResourceType(payload, " rt.firstitem");
1012 OCRepPayloadAddInterface(payload, " if.firstitem");
1018 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1019 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1020 cborData, cborSize));
1022 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1024 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1025 EXPECT_EQ(NULL, parsedPayload->types->next);
1026 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1027 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1031 OCRepPayloadDestroy(payload);
1032 OCPayloadDestroy(cparsed);
1034 TEST(RepresentationEncodingRTandIF, SingleItemBackTrim)
1036 OCRepPayload* payload = OCRepPayloadCreate();
1037 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
1038 OCRepPayloadAddInterface(payload, "if.firstitem ");
1044 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1045 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1046 cborData, cborSize));
1048 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1050 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1051 EXPECT_EQ(NULL, parsedPayload->types->next);
1052 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1053 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1057 OCRepPayloadDestroy(payload);
1058 OCPayloadDestroy(cparsed);
1060 TEST(RepresentationEncodingRTandIF, SingleItemBothTrim)
1062 OCRepPayload* payload = OCRepPayloadCreate();
1063 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1064 OCRepPayloadAddInterface(payload, " if.firstitem ");
1070 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1071 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1072 cborData, cborSize));
1074 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1076 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1077 EXPECT_EQ(NULL, parsedPayload->types->next);
1078 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1079 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1083 OCRepPayloadDestroy(payload);
1084 OCPayloadDestroy(cparsed);
1086 TEST(RepresentationEncodingRTandIF, MultiItemsNormal)
1088 OCRepPayload* payload = OCRepPayloadCreate();
1089 OCRepPayloadAddResourceType(payload, "rt.firstitem");
1090 OCRepPayloadAddResourceType(payload, "rt.seconditem");
1091 OCRepPayloadAddInterface(payload, "if.firstitem");
1092 OCRepPayloadAddInterface(payload, "if.seconditem");
1098 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1099 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1100 cborData, cborSize));
1102 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1104 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1105 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1106 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1107 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1108 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1109 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1113 OCRepPayloadDestroy(payload);
1114 OCPayloadDestroy(cparsed);
1116 TEST(RepresentationEncodingRTandIF, MultiItemExtraLeadSpaces)
1118 OCRepPayload* payload = OCRepPayloadCreate();
1119 OCRepPayloadAddResourceType(payload, " rt.firstitem");
1120 OCRepPayloadAddResourceType(payload, " rt.seconditem");
1121 OCRepPayloadAddInterface(payload, " if.firstitem");
1122 OCRepPayloadAddInterface(payload, " if.seconditem");
1128 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1129 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1130 cborData, cborSize));
1132 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1134 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1135 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1136 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1137 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1138 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1139 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1143 OCRepPayloadDestroy(payload);
1144 OCPayloadDestroy(cparsed);
1146 TEST(RepresentationEncodingRTandIF, MultiItemExtraTrailSpaces)
1148 OCRepPayload* payload = OCRepPayloadCreate();
1149 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
1150 OCRepPayloadAddResourceType(payload, "rt.seconditem ");
1151 OCRepPayloadAddInterface(payload, "if.firstitem ");
1152 OCRepPayloadAddInterface(payload, "if.seconditem ");
1158 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1159 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1160 cborData, cborSize));
1162 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1164 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1165 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1166 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1167 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1168 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1169 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1173 OCRepPayloadDestroy(payload);
1174 OCPayloadDestroy(cparsed);
1176 TEST(RepresentationEncodingRTandIF, MultiItemExtraMiddleSpaces)
1178 OCRepPayload* payload = OCRepPayloadCreate();
1179 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1180 OCRepPayloadAddResourceType(payload, " rt.seconditem ");
1181 OCRepPayloadAddInterface(payload, " if.firstitem ");
1182 OCRepPayloadAddInterface(payload, " if.seconditem ");
1188 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1189 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1190 cborData, cborSize));
1192 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1194 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1195 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1196 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1197 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1198 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1199 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1203 OCRepPayloadDestroy(payload);
1204 OCPayloadDestroy(cparsed);
1206 TEST(RepresentationEncodingRTandIF, TestPayloadContents)
1208 OC::OCRepresentation subRep1;
1209 std::vector<std::string> types;
1210 types.push_back("rt.firstitem");
1211 std::vector<std::string> interfaces;
1212 interfaces.push_back("if.firstitem");
1213 subRep1.setResourceTypes(types);
1214 subRep1.setResourceInterfaces(interfaces);
1215 subRep1.setNULL("NullAttr");
1216 subRep1.setValue("IntAttr", 77);
1217 subRep1.setValue("DoubleAttr", 3.333);
1218 subRep1.setValue("BoolAttr", true);
1219 subRep1.setValue("StringAttr", std::string("String attr"));
1221 OC::MessageContainer mc1;
1222 mc1.addRepresentation(subRep1);
1224 OCRepPayload *repPayload = mc1.getPayload();
1225 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, repPayload->base.type);
1227 uint8_t *cborData = NULL;
1228 size_t cborSize = 0;
1229 OCPayload *cparsed = NULL;
1231 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)repPayload, &cborData, &cborSize));
1232 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1233 cborData, cborSize));
1235 OCRepPayload *parsedPayload = (OCRepPayload *)cparsed;
1236 EXPECT_EQ(NULL, parsedPayload->uri);
1237 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1238 EXPECT_EQ(NULL, parsedPayload->types->next);
1239 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1240 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1242 // To make sure rt and if are not duplicated.
1243 EXPECT_STREQ("BoolAttr", parsedPayload->values->name);
1244 EXPECT_EQ(true, parsedPayload->values->b);
1245 EXPECT_EQ(OCREP_PROP_BOOL, parsedPayload->values->type);
1246 parsedPayload->values = parsedPayload->values->next;
1248 EXPECT_STREQ("DoubleAttr", parsedPayload->values->name);
1249 EXPECT_EQ(OCREP_PROP_DOUBLE, parsedPayload->values->type);
1250 EXPECT_EQ(3.3330000000000002, parsedPayload->values->d);
1251 parsedPayload->values = parsedPayload->values->next;
1253 EXPECT_STREQ("IntAttr", parsedPayload->values->name);
1254 EXPECT_EQ(77, parsedPayload->values->i);
1255 EXPECT_EQ(OCREP_PROP_INT, parsedPayload->values->type);
1256 parsedPayload->values = parsedPayload->values->next;
1258 EXPECT_STREQ("NullAttr", parsedPayload->values->name);
1259 EXPECT_EQ(OCREP_PROP_NULL, parsedPayload->values->type);
1260 parsedPayload->values = parsedPayload->values->next;
1262 EXPECT_STREQ("StringAttr", parsedPayload->values->name);
1263 EXPECT_STREQ("String attr", parsedPayload->values->str);
1264 EXPECT_EQ(OCREP_PROP_STRING, parsedPayload->values->type);
1265 parsedPayload->values = parsedPayload->values->next;
1267 EXPECT_EQ(NULL, parsedPayload->values);
1270 OCRepPayloadDestroy(repPayload);
1271 OCPayloadDestroy(cparsed);