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";
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_FALSE(device->dataModelVersions->next);
76 EXPECT_EQ(PAYLOAD_TYPE_DEVICE, ((OCPayload *)device)->type);
77 EXPECT_STREQ("oic.wk.d", device->types->value);
78 EXPECT_STREQ("oic.d.tv", device->types->next->value);
82 OCPayload* parsedDevice;
83 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)device, &cborData, &cborSize));
84 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedDevice, PAYLOAD_TYPE_DEVICE,
88 EXPECT_STREQ(device->sid, ((OCDevicePayload*)parsedDevice)->sid);
89 EXPECT_STREQ(device->deviceName, ((OCDevicePayload*)parsedDevice)->deviceName);
90 EXPECT_STREQ(device->specVersion, ((OCDevicePayload*)parsedDevice)->specVersion);
91 EXPECT_STREQ(device->dataModelVersions->value, ((OCDevicePayload*)parsedDevice)->dataModelVersions->value);
92 EXPECT_STREQ("oic.wk.d", ((OCDevicePayload*)parsedDevice)->types->value);
93 EXPECT_STREQ("oic.d.tv", ((OCDevicePayload*)parsedDevice)->types->next->value);
94 EXPECT_EQ(device->base.type, ((OCDevicePayload*)parsedDevice)->base.type);
96 OCPayloadDestroy((OCPayload*)device);
98 OC::MessageContainer mc1;
99 mc1.setPayload(parsedDevice);
100 EXPECT_EQ(1u, mc1.representations().size());
101 const OC::OCRepresentation &r1 = mc1.representations()[0];
102 EXPECT_STREQ(sid1, r1.getValue<std::string>(OC_RSRVD_DEVICE_ID).c_str());
103 EXPECT_STREQ(devicename1, r1.getValue<std::string>(OC_RSRVD_DEVICE_NAME).c_str());
104 EXPECT_STREQ(specver1, r1.getValue<std::string>(OC_RSRVD_SPEC_VERSION).c_str());
105 EXPECT_STREQ("res.1.1.0", r1.getDataModelVersions()[0].c_str());
107 OCPayloadDestroy(parsedDevice);
109 static const char dmver2[] = "res.1.1.0,sh.1.1.0";
110 device = OCDevicePayloadCreate(
117 EXPECT_STREQ("res.1.1.0", device->dataModelVersions->value);
118 EXPECT_TRUE(device->dataModelVersions->next);
119 EXPECT_STREQ("sh.1.1.0", device->dataModelVersions->next->value);
120 EXPECT_FALSE(device->dataModelVersions->next->next);
121 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload *)device, &cborData, &cborSize));
122 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedDevice, PAYLOAD_TYPE_DEVICE,
123 cborData, cborSize));
125 EXPECT_STREQ(device->dataModelVersions->value,
126 ((OCDevicePayload *)parsedDevice)->dataModelVersions->value);
127 EXPECT_STREQ(device->dataModelVersions->next->value,
128 ((OCDevicePayload *)parsedDevice)->dataModelVersions->next->value);
129 OCPayloadDestroy((OCPayload *)device);
130 OC::MessageContainer mc2;
131 mc2.setPayload(parsedDevice);
132 EXPECT_EQ(1u, mc2.representations().size());
133 const OC::OCRepresentation r2 = mc2.representations()[0];
134 EXPECT_STREQ("res.1.1.0", r2.getDataModelVersions()[0].c_str());
135 EXPECT_STREQ("sh.1.1.0", r2.getDataModelVersions()[1].c_str());
137 OCPayloadDestroy(parsedDevice);
140 static const char uri1[] = "/testuri";
141 static char pfid1[] = "pfid";
142 static char mfgnm1[] = "mfgnm";
143 static char mfgurl1[] = "mfgurl";
144 static char modelnum1[] = "modelnum";
145 static char dom1[] = "dom";
146 static char pfver1[] = "pfver";
147 static char osver1[] = "osver";
148 static char hwver1[] = "hwver";
149 static char fwver1[] = "fwver";
150 static char url1[] = "url";
151 static char time1[] = "time";
154 TEST(PlatformDiscoveryEncoding, Normal)
156 OCPlatformInfo info {pfid1, mfgnm1, mfgurl1, modelnum1, dom1, pfver1, osver1, hwver1,
157 fwver1, url1, time1};
158 OCPlatformPayload* platform = OCPlatformPayloadCreate(&info);
159 EXPECT_EQ(PAYLOAD_TYPE_PLATFORM, ((OCPayload*)platform)->type);
160 EXPECT_STREQ(pfid1, platform->info.platformID);
161 EXPECT_STREQ(mfgnm1, platform->info.manufacturerName);
162 EXPECT_STREQ(mfgurl1, platform->info.manufacturerUrl);
163 EXPECT_STREQ(modelnum1, platform->info.modelNumber);
164 EXPECT_STREQ(dom1, platform->info.dateOfManufacture);
165 EXPECT_STREQ(pfver1, platform->info.platformVersion);
166 EXPECT_STREQ(osver1, platform->info.operatingSystemVersion);
167 EXPECT_STREQ(hwver1, platform->info.hardwareVersion);
168 EXPECT_STREQ(fwver1, platform->info.firmwareVersion);
169 EXPECT_STREQ(url1, platform->info.supportUrl);
170 EXPECT_STREQ(time1, platform->info.systemTime);
171 EXPECT_STREQ(OC_RSRVD_INTERFACE_DEFAULT, platform->interfaces->value);
172 EXPECT_STREQ(OC_RSRVD_INTERFACE_READ, platform->interfaces->next->value);
173 EXPECT_STREQ(OC_RSRVD_RESOURCE_TYPE_PLATFORM, platform->rt->value);
177 OCPayload* parsedPlatform;
178 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)platform, &cborData, &cborSize));
179 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedPlatform, PAYLOAD_TYPE_PLATFORM,
180 cborData, cborSize));
183 EXPECT_EQ(platform->base.type, ((OCPlatformPayload*)parsedPlatform)->base.type);
184 OCPlatformPayload* platform2 = (OCPlatformPayload*)parsedPlatform;
185 EXPECT_STREQ(platform->info.platformID, platform2->info.platformID);
186 EXPECT_STREQ(platform->info.manufacturerName, platform->info.manufacturerName);
187 EXPECT_STREQ(platform->info.manufacturerUrl, platform->info.manufacturerUrl);
188 EXPECT_STREQ(platform->info.modelNumber, platform->info.modelNumber);
189 EXPECT_STREQ(platform->info.dateOfManufacture, platform->info.dateOfManufacture);
190 EXPECT_STREQ(platform->info.platformVersion, platform->info.platformVersion);
191 EXPECT_STREQ(platform->info.operatingSystemVersion, platform->info.operatingSystemVersion);
192 EXPECT_STREQ(platform->info.hardwareVersion, platform->info.hardwareVersion);
193 EXPECT_STREQ(platform->info.firmwareVersion, platform->info.firmwareVersion);
194 EXPECT_STREQ(platform->info.supportUrl, platform->info.supportUrl);
195 EXPECT_STREQ(platform->info.systemTime, platform2->info.systemTime);
196 EXPECT_STREQ(platform->interfaces->value, platform2->interfaces->value);
197 EXPECT_STREQ(platform->rt->value, platform2->rt->value);
199 OCPayloadDestroy((OCPayload*)platform);
201 OC::MessageContainer mc;
202 mc.setPayload(parsedPlatform);
203 EXPECT_EQ(1u, mc.representations().size());
204 const OC::OCRepresentation& r = mc.representations()[0];
205 EXPECT_STREQ(pfid1, r.getValue<std::string>(OC_RSRVD_PLATFORM_ID).c_str());
206 EXPECT_STREQ(mfgnm1, r.getValue<std::string>(OC_RSRVD_MFG_NAME).c_str());
207 EXPECT_STREQ(mfgurl1, r.getValue<std::string>(OC_RSRVD_MFG_URL).c_str());
208 EXPECT_STREQ(modelnum1, r.getValue<std::string>(OC_RSRVD_MODEL_NUM).c_str());
209 EXPECT_STREQ(dom1, r.getValue<std::string>(OC_RSRVD_MFG_DATE).c_str());
210 EXPECT_STREQ(pfver1, r.getValue<std::string>(OC_RSRVD_PLATFORM_VERSION).c_str());
211 EXPECT_STREQ(osver1, r.getValue<std::string>(OC_RSRVD_OS_VERSION).c_str());
212 EXPECT_STREQ(hwver1, r.getValue<std::string>(OC_RSRVD_HARDWARE_VERSION).c_str());
213 EXPECT_STREQ(fwver1, r.getValue<std::string>(OC_RSRVD_FIRMWARE_VERSION).c_str());
214 EXPECT_STREQ(url1, r.getValue<std::string>(OC_RSRVD_SUPPORT_URL).c_str());
215 EXPECT_STREQ(time1, r.getValue<std::string>(OC_RSRVD_SYSTEM_TIME).c_str());
217 OCPayloadDestroy(parsedPlatform);
219 TEST(PresencePayload, Normal)
222 uint32_t sequenceNumber = 0;
223 OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE;
224 OCPresencePayload *presence = OCPresencePayloadCreate(sequenceNumber, maxAge, trigger, uri1);
229 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)presence, &cborData, &cborSize));
230 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_PRESENCE,
231 cborData, cborSize));
232 OCPayloadDestroy((OCPayload*)presence);
235 OCPresencePayload* parsed = ((OCPresencePayload*)cparsed);
236 EXPECT_EQ(sequenceNumber, parsed->sequenceNumber);
237 EXPECT_EQ(maxAge, parsed->maxAge);
238 EXPECT_EQ(trigger, parsed->trigger);
239 EXPECT_STREQ(uri1, parsed->resourceType);
241 OCPayloadDestroy(cparsed);
243 // Representation Payloads
244 TEST(RepresentationEncoding, BaseAttributeTypes)
246 OC::OCRepresentation startRep;
247 startRep.setNULL("NullAttr");
248 startRep.setValue("IntAttr", 77);
249 startRep.setValue("DoubleAttr", 3.333);
250 startRep.setValue("BoolAttr", true);
251 startRep.setValue("StringAttr", std::string("String attr"));
252 OC::MessageContainer mc1;
253 mc1.addRepresentation(startRep);
255 OCRepPayload* cstart = mc1.getPayload();
256 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
261 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
262 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
263 cborData, cborSize));
264 OCPayloadDestroy((OCPayload*)cstart);
267 OC::MessageContainer mc2;
268 mc2.setPayload(cparsed);
269 EXPECT_EQ(1u, mc2.representations().size());
270 const OC::OCRepresentation& r = mc2.representations()[0];
272 EXPECT_TRUE(r.isNULL("NullAttr"));
273 EXPECT_EQ(77, r.getValue<int>("IntAttr"));
274 EXPECT_EQ(3.333, r.getValue<double>("DoubleAttr"));
275 EXPECT_EQ(true, r.getValue<bool>("BoolAttr"));
276 EXPECT_STREQ("String attr", r.getValue<std::string>("StringAttr").c_str());
278 OCPayloadDestroy(cparsed);
281 TEST(RepresentationEncoding, RepAttributeEmpty)
283 OC::OCRepresentation startRep;
284 std::vector<int> iarr {};
285 startRep["iarr"] = {};
287 OC::MessageContainer mc1;
288 mc1.addRepresentation(startRep);
290 OCRepPayload* cstart = mc1.getPayload();
291 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
293 uint8_t *cborData = NULL;
295 OCPayload *cparsed = NULL;
296 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
297 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
298 cborData, cborSize));
299 OCPayloadDestroy((OCPayload*)cstart);
302 OC::MessageContainer mc2;
303 mc2.setPayload(cparsed);
304 EXPECT_EQ(1u, mc2.representations().size());
305 const OC::OCRepresentation& r = mc2.representations()[0];
307 std::vector<int> iarr2 = r["iarr"];
309 EXPECT_EQ(iarr, iarr2);
310 OCPayloadDestroy(cparsed);
313 TEST(RepresentationEncoding, RepAttribute)
315 OC::OCRepresentation startRep;
316 OC::OCRepresentation subRep;
317 subRep.setNULL("NullAttr");
318 subRep.setValue("IntAttr", 77);
319 subRep.setValue("DoubleAttr", 3.333);
320 subRep.setValue("BoolAttr", true);
321 subRep.setValue("StringAttr", std::string("String attr"));
322 std::vector<uint8_t> bin_data {5,3,4,5,6,0,34,2,4,5,6,3};
323 subRep.setValue("BinaryAttr", bin_data);
324 startRep.setValue("Sub", subRep);
326 OC::MessageContainer mc1;
327 mc1.addRepresentation(startRep);
329 OCRepPayload* cstart = mc1.getPayload();
330 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
335 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
336 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
337 cborData, cborSize));
338 OCPayloadDestroy((OCPayload*)cstart);
341 OC::MessageContainer mc2;
342 mc2.setPayload(cparsed);
343 EXPECT_EQ(1u, mc2.representations().size());
344 const OC::OCRepresentation& r = mc2.representations()[0];
346 OC::OCRepresentation newSubRep = r["Sub"];
348 EXPECT_TRUE(newSubRep.isNULL("NullAttr"));
349 EXPECT_EQ(77, newSubRep.getValue<int>("IntAttr"));
350 EXPECT_EQ(3.333, newSubRep.getValue<double>("DoubleAttr"));
351 EXPECT_EQ(true, newSubRep.getValue<bool>("BoolAttr"));
352 EXPECT_STREQ("String attr", newSubRep.getValue<std::string>("StringAttr").c_str());
354 newSubRep.getValue<std::vector<uint8_t>>("BinaryAttr"));
355 OCPayloadDestroy(cparsed);
358 TEST(RepresentationEncoding, OneDVectors)
361 OC::OCRepresentation startRep;
363 OC::OCRepresentation subRep1;
364 OC::OCRepresentation subRep2;
365 OC::OCRepresentation subRep3;
366 subRep1.setNULL("NullAttr");
367 subRep1.setValue("IntAttr", 77);
368 subRep2.setValue("DoubleAttr", 3.333);
369 subRep2.setValue("BoolAttr", true);
370 subRep3.setValue("StringAttr", std::string("String attr"));
372 std::vector<int> iarr {1,2,3,4,5,6,7,8,9};
373 std::vector<double> darr {1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9};
374 std::vector<bool> barr {false, true, false, false, true, true};
375 std::vector<std::string> strarr {"item1", "item2", "item3", "item4"};
376 std::vector<OC::OCRepresentation> objarr {subRep1, subRep2, subRep3};
378 startRep["iarr"] = iarr;
379 startRep["darr"] = darr;
380 startRep["barr"] = barr;
381 startRep["strarr"] = strarr;
382 startRep["objarr"] = objarr;
385 OC::MessageContainer mc1;
386 mc1.addRepresentation(startRep);
388 OCRepPayload* cstart = mc1.getPayload();
389 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
394 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
395 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
396 cborData, cborSize));
397 OCPayloadDestroy((OCPayload*)cstart);
400 OC::MessageContainer mc2;
401 mc2.setPayload(cparsed);
402 EXPECT_EQ(1u, mc2.representations().size());
403 const OC::OCRepresentation& r = mc2.representations()[0];
406 std::vector<int> iarr2 = r["iarr"];
407 std::vector<double> darr2 = r["darr"];
408 std::vector<bool> barr2 = r["barr"];
409 std::vector<std::string> strarr2 = r["strarr"];
410 std::vector<OC::OCRepresentation> objarr2 = r["objarr"];
412 EXPECT_EQ(iarr, iarr2);
413 EXPECT_EQ(darr, darr2);
414 EXPECT_EQ(barr, barr2);
415 EXPECT_EQ(strarr, strarr2);
416 EXPECT_EQ(objarr, objarr2);
417 OCPayloadDestroy(cparsed);
420 TEST(RepresentationEncoding, TwoDVectors)
423 OC::OCRepresentation startRep;
425 OC::OCRepresentation subRep1;
426 OC::OCRepresentation subRep2;
427 OC::OCRepresentation subRep3;
428 subRep1.setNULL("NullAttr");
429 subRep1.setValue("IntAttr", 77);
430 subRep2.setValue("DoubleAttr", 3.333);
431 subRep2.setValue("BoolAttr", true);
432 subRep3.setValue("StringAttr", std::string("String attr"));
434 std::vector<std::vector<int>> iarr {{1,2,3},{4,5,6},{7,8,9}};
435 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{7.7,8.8,9.9}};
436 std::vector<std::vector<bool>> barr {{false, true}, {false, false}, {true, true}};
437 std::vector<std::vector<std::string>> strarr {{"item1", "item2"}, {"item3", "item4"}};
438 std::vector<std::vector<OC::OCRepresentation>> objarr
439 {{subRep1, subRep2, subRep3}, {subRep3, subRep2, subRep1}};
441 startRep["iarr"] = iarr;
442 startRep["darr"] = darr;
443 startRep["barr"] = barr;
444 startRep["strarr"] = strarr;
445 startRep["objarr"] = objarr;
448 OC::MessageContainer mc1;
449 mc1.addRepresentation(startRep);
451 OCRepPayload* cstart = mc1.getPayload();
452 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
457 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
458 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
459 cborData, cborSize));
460 OCPayloadDestroy((OCPayload*)cstart);
463 OC::MessageContainer mc2;
464 mc2.setPayload(cparsed);
465 EXPECT_EQ(1u, mc2.representations().size());
466 const OC::OCRepresentation& r = mc2.representations()[0];
469 std::vector<std::vector<int>> iarr2 = r["iarr"];
470 std::vector<std::vector<double>> darr2 = r["darr"];
471 std::vector<std::vector<bool>> barr2 = r["barr"];
472 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
473 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
475 EXPECT_EQ(iarr, iarr2);
476 EXPECT_EQ(darr, darr2);
477 EXPECT_EQ(barr, barr2);
478 EXPECT_EQ(strarr, strarr2);
479 EXPECT_EQ(objarr, objarr2);
480 OCPayloadDestroy(cparsed);
483 TEST(RepresentationEncoding, TwoDVectorsJagged)
486 OC::OCRepresentation startRep;
488 OC::OCRepresentation subRep1;
489 OC::OCRepresentation subRep2;
490 OC::OCRepresentation subRep3;
491 subRep1.setNULL("NullAttr");
492 subRep1.setValue("IntAttr", 77);
493 subRep2.setValue("DoubleAttr", 3.333);
494 subRep2.setValue("BoolAttr", true);
495 subRep3.setValue("StringAttr", std::string("String attr"));
497 std::vector<std::vector<int>> iarr {{1,2,3},{4,6},{7,8,9}};
498 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{8.8,9.9}};
499 std::vector<std::vector<bool>> barr {{false, true}, {false}, {true, true}};
500 std::vector<std::vector<std::string>> strarr {{"item1"}, {"item3", "item4"}};
501 std::vector<std::vector<OC::OCRepresentation>> objarr
502 {{subRep1, subRep3}, {subRep3, subRep2, subRep1}};
504 startRep["iarr"] = iarr;
505 startRep["darr"] = darr;
506 startRep["barr"] = barr;
507 startRep["strarr"] = strarr;
508 startRep["objarr"] = objarr;
511 OC::MessageContainer mc1;
512 mc1.addRepresentation(startRep);
514 OCRepPayload* cstart = mc1.getPayload();
515 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
520 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
521 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
522 cborData, cborSize));
523 OCPayloadDestroy((OCPayload*)cstart);
526 OC::MessageContainer mc2;
527 mc2.setPayload(cparsed);
528 EXPECT_EQ(1u, mc2.representations().size());
529 const OC::OCRepresentation& r = mc2.representations()[0];
532 std::vector<std::vector<int>> iarr2 = r["iarr"];
533 std::vector<std::vector<double>> darr2 = r["darr"];
534 std::vector<std::vector<bool>> barr2 = r["barr"];
535 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
536 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
538 // Note: due to the way that the CSDK works, all 2d arrays need to be rectangular.
539 // Since std::vector doesn't require this, items received on the other side end up
540 // being backfilled. This section removes the backfilling
544 strarr2[0].pop_back();
545 objarr2[0].pop_back();
547 EXPECT_EQ(iarr, iarr2);
548 EXPECT_EQ(darr, darr2);
549 EXPECT_EQ(barr, barr2);
550 EXPECT_EQ(strarr, strarr2);
551 EXPECT_EQ(objarr, objarr2);
552 OCPayloadDestroy(cparsed);
555 TEST(RepresentationEncoding, ThreeDVectors)
558 OC::OCRepresentation startRep;
560 OC::OCRepresentation subRep1;
561 OC::OCRepresentation subRep2;
562 OC::OCRepresentation subRep3;
563 subRep1.setNULL("NullAttr");
564 subRep1.setValue("IntAttr", 77);
565 subRep2.setValue("DoubleAttr", 3.333);
566 subRep2.setValue("BoolAttr", true);
567 subRep3.setValue("StringAttr", std::string("String attr"));
569 std::vector<std::vector<std::vector<int>>> iarr
570 {{{1,2,3},{4,5,6}},{{7,8,9},{10,11,12}},{{13,14,15},{16,17,18}}};
571 std::vector<std::vector<std::vector<double>>> darr
572 {{{1.1,2.2,3.3},{4.4,5.5,6.6}},
573 {{7.7,8.7,9.7},{10.7,11.7,12.7}},
574 {{13.7,14.7,15.7},{16.7,17.7,18.7}}};
575 std::vector<std::vector<std::vector<bool>>> barr
576 {{{false, true},{true, false}},{{false, true},{true, false}}};
577 std::vector<std::vector<std::vector<std::string>>> strarr
579 {{"item1", "item2"},{"item3", "item4"}},
580 {{"item5", "item6"},{"item7", "item8"}},
581 {{"item9", "item10"},{"item11", ""}}
583 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
585 {{subRep1, subRep2},{subRep3, subRep1}},
586 {{subRep2, subRep3},{subRep2, subRep1}},
587 {{subRep3, subRep2},{subRep1, subRep2}}
590 startRep["iarr"] = iarr;
591 startRep["darr"] = darr;
592 startRep["barr"] = barr;
593 startRep["strarr"] = strarr;
594 startRep["objarr"] = objarr;
597 OC::MessageContainer mc1;
598 mc1.addRepresentation(startRep);
600 OCRepPayload* cstart = mc1.getPayload();
601 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
606 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
607 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
608 cborData, cborSize));
609 OCPayloadDestroy((OCPayload*)cstart);
612 OC::MessageContainer mc2;
613 mc2.setPayload(cparsed);
614 EXPECT_EQ(1u, mc2.representations().size());
615 const OC::OCRepresentation& r = mc2.representations()[0];
618 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
619 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
620 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
621 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
622 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
624 EXPECT_EQ(iarr, iarr2);
625 EXPECT_EQ(darr, darr2);
626 EXPECT_EQ(barr, barr2);
627 EXPECT_EQ(strarr, strarr2);
628 EXPECT_EQ(objarr, objarr2);
629 OCPayloadDestroy(cparsed);
632 TEST(RepresentationEncoding, ThreeDVectorsJagged)
635 OC::OCRepresentation startRep;
637 OC::OCRepresentation subRep1;
638 OC::OCRepresentation subRep2;
639 OC::OCRepresentation subRep3;
640 subRep1.setNULL("NullAttr");
641 subRep1.setValue("IntAttr", 77);
642 subRep2.setValue("DoubleAttr", 3.333);
643 subRep2.setValue("BoolAttr", true);
644 subRep3.setValue("StringAttr", std::string("String attr"));
646 std::vector<std::vector<std::vector<int>>> iarr
650 {{13,14,15},{16,17,18}}
652 std::vector<std::vector<std::vector<double>>> darr
654 {{1.1,2.2,3.3},{4.4,5.5,6.6}},
655 {{7.7,8.7,9.7},{10.7,12.7}},
656 {{13.7,14.7,15.7},{16.7,17.7,18.7}}
658 std::vector<std::vector<std::vector<bool>>> barr
660 {{false, true},{true}},
661 {{false, true},{true, false}}
663 std::vector<std::vector<std::vector<std::string>>> strarr
665 {{"item1", "item2"},{"item3", "item4"}},
666 {{"item5", "item6"},{"item8"}},
667 {{"item9", "item10"},{"item11", ""}}
669 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
671 {{subRep1, subRep2},{subRep3, subRep1}},
672 {{subRep2, subRep3},{subRep2}},
676 startRep["iarr"] = iarr;
677 startRep["darr"] = darr;
678 startRep["barr"] = barr;
679 startRep["strarr"] = strarr;
680 startRep["objarr"] = objarr;
683 OC::MessageContainer mc1;
684 mc1.addRepresentation(startRep);
686 OCRepPayload* cstart = mc1.getPayload();
687 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
692 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
693 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
694 cborData, cborSize));
695 OCPayloadDestroy((OCPayload*)cstart);
698 OC::MessageContainer mc2;
699 mc2.setPayload(cparsed);
700 EXPECT_EQ(1u, mc2.representations().size());
701 const OC::OCRepresentation& r = mc2.representations()[0];
704 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
705 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
706 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
707 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
708 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
710 // Note: due to the way that the CSDK works, all 3d arrays need to be cuboidal.
711 // Since std::vector doesn't require this, items received on the other side end up
712 // being backfilled. This section removes the backfilling
713 iarr2[1][1].pop_back();
714 darr2[1][1].pop_back();
715 barr2[0][1].pop_back();
716 strarr2[1][1].pop_back();
717 objarr2[1][1].pop_back();
718 objarr2[2].pop_back();
720 EXPECT_EQ(iarr, iarr2);
721 EXPECT_EQ(darr, darr2);
722 EXPECT_EQ(barr, barr2);
723 EXPECT_EQ(strarr, strarr2);
724 EXPECT_EQ(objarr, objarr2);
725 OCPayloadDestroy(cparsed);
728 TEST(DiscoveryRTandIF, SingleItemNormal)
730 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
731 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
732 payload->sid = OICStrdup(sid1);
733 payload->resources = resource;
735 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem"));
736 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem"));
738 resource->uri = OICStrdup("/uri/thing");
744 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
745 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
746 cborData, cborSize));
748 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
749 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
751 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
752 EXPECT_EQ(NULL, parsedResource->next);
753 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
754 EXPECT_EQ(NULL, parsedResource->types->next);
755 EXPECT_EQ(NULL, parsedResource->interfaces->next);
756 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
759 OCPayloadDestroy(cparsed);
760 OCDiscoveryPayloadDestroy(payload);
763 TEST(DiscoveryRTandIF, SingleItemFrontTrim)
765 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
766 payload->sid = OICStrdup(sid1);
767 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
768 payload->resources = resource;
770 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, " rt.singleitem"));
771 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, " if.singleitem"));
772 resource->uri = OICStrdup("/uri/thing");
778 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
779 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
780 cborData, cborSize));
782 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
783 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
785 EXPECT_EQ(NULL, parsedResource->next);
786 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
787 EXPECT_EQ(NULL, parsedResource->types->next);
788 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
789 EXPECT_EQ(NULL, parsedResource->interfaces->next);
790 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
793 OCPayloadDestroy(cparsed);
794 OCDiscoveryPayloadDestroy(payload);
797 TEST(DiscoveryRTandIF, SingleItemBackTrim)
799 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
800 payload->sid = OICStrdup(sid1);
801 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
802 payload->resources = resource;
804 OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem ");
805 OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem ");
806 resource->uri = OICStrdup("/uri/thing");
812 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
813 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
814 cborData, cborSize));
816 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
817 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
819 EXPECT_EQ(NULL, parsedResource->next);
820 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
821 EXPECT_EQ(NULL, parsedResource->types->next);
822 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
823 EXPECT_EQ(NULL, parsedResource->interfaces->next);
824 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
827 OCPayloadDestroy(cparsed);
828 OCDiscoveryPayloadDestroy(payload);
830 TEST(DiscoveryRTandIF, SingleItemBothTrim)
832 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
833 payload->sid = OICStrdup(sid1);
834 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
835 payload->resources = resource;
837 OCResourcePayloadAddStringLL(&resource->types, " rt.singleitem ");
838 OCResourcePayloadAddStringLL(&resource->interfaces, " if.singleitem ");
839 resource->uri = OICStrdup("/uri/thing");
845 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
846 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
847 cborData, cborSize));
849 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
850 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
852 EXPECT_EQ(NULL, parsedResource->next);
853 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
854 EXPECT_EQ(NULL, parsedResource->types->next);
855 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
856 EXPECT_EQ(NULL, parsedResource->interfaces->next);
857 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
860 OCPayloadDestroy(cparsed);
861 OCDiscoveryPayloadDestroy(payload);
863 TEST(DiscoveryRTandIF, MultiItemsNormal)
865 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
866 payload->sid = OICStrdup(sid1);
867 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
868 payload->resources = resource;
870 OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem");
871 OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem");
872 OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem");
873 OCResourcePayloadAddStringLL(&resource->interfaces, "if.seconditem");
874 resource->uri = OICStrdup("/uri/thing");
880 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
881 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
882 cborData, cborSize));
884 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
885 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
887 EXPECT_EQ(NULL, parsedResource->next);
888 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
889 EXPECT_EQ(NULL, parsedResource->types->next->next);
890 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
891 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
892 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
893 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
894 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
897 OCPayloadDestroy(cparsed);
898 OCDiscoveryPayloadDestroy(payload);
900 TEST(DiscoveryRTandIF, MultiItemExtraLeadSpaces)
902 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
903 payload->sid = OICStrdup(sid1);
904 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
905 payload->resources = resource;
907 OCResourcePayloadAddStringLL(&resource->types, " rt.firstitem");
908 OCResourcePayloadAddStringLL(&resource->types, " rt.seconditem");
909 OCResourcePayloadAddStringLL(&resource->interfaces, " if.firstitem");
910 OCResourcePayloadAddStringLL(&resource->interfaces, " if.seconditem");
911 resource->uri = OICStrdup("/uri/thing");
917 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
918 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
919 cborData, cborSize));
921 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
922 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
924 EXPECT_EQ(NULL, parsedResource->next);
925 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
926 EXPECT_EQ(NULL, parsedResource->types->next->next);
927 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
928 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
929 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
930 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
931 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
934 OCPayloadDestroy(cparsed);
935 OCDiscoveryPayloadDestroy(payload);
937 TEST(DiscoveryRTandIF, MultiItemExtraTrailSpaces)
939 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
940 payload->sid = OICStrdup(sid1);
941 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
942 payload->resources = resource;
944 OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem ");
945 OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem ");
946 OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem ");
947 OCResourcePayloadAddStringLL(&resource->interfaces, "if.seconditem ");
948 resource->uri = OICStrdup("/uri/thing");
954 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
955 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
956 cborData, cborSize));
958 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
959 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
961 EXPECT_EQ(NULL, parsedResource->next);
962 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
963 EXPECT_EQ(NULL, parsedResource->types->next->next);
964 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
965 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
966 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
967 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
968 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
971 OCPayloadDestroy(cparsed);
972 OCDiscoveryPayloadDestroy(payload);
974 TEST(DiscoveryRTandIF, MultiItemBothSpaces)
976 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
977 payload->sid = OICStrdup(sid1);
978 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
979 payload->resources = resource;
981 OCResourcePayloadAddStringLL(&resource->types, " rt.firstitem ");
982 OCResourcePayloadAddStringLL(&resource->types, " rt.seconditem ");
983 OCResourcePayloadAddStringLL(&resource->interfaces, " if.firstitem ");
984 OCResourcePayloadAddStringLL(&resource->interfaces, " if.seconditem ");
985 resource->uri = OICStrdup("/uri/thing");
991 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
992 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
993 cborData, cborSize));
995 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
996 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
998 EXPECT_EQ(NULL, parsedResource->next);
999 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1000 EXPECT_EQ(NULL, parsedResource->types->next->next);
1001 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
1002 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
1003 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
1004 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
1005 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
1008 OCPayloadDestroy(cparsed);
1009 OCDiscoveryPayloadDestroy(payload);
1011 TEST(RepresentationEncodingRTandIF, SingleItemNormal)
1013 OCRepPayload* payload = OCRepPayloadCreate();
1014 OCRepPayloadAddResourceType(payload, "rt.firstitem");
1015 OCRepPayloadAddInterface(payload, "if.firstitem");
1021 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1022 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1023 cborData, cborSize));
1025 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1027 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1028 EXPECT_EQ(NULL, parsedPayload->types->next);
1029 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1030 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1033 OCRepPayloadDestroy(payload);
1034 OCPayloadDestroy(cparsed);
1036 TEST(RepresentationEncodingRTandIF, SingleItemFrontTrim)
1038 OCRepPayload* payload = OCRepPayloadCreate();
1039 OCRepPayloadAddResourceType(payload, " rt.firstitem");
1040 OCRepPayloadAddInterface(payload, " if.firstitem");
1046 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1047 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1048 cborData, cborSize));
1050 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1052 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1053 EXPECT_EQ(NULL, parsedPayload->types->next);
1054 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1055 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1059 OCRepPayloadDestroy(payload);
1060 OCPayloadDestroy(cparsed);
1062 TEST(RepresentationEncodingRTandIF, SingleItemBackTrim)
1064 OCRepPayload* payload = OCRepPayloadCreate();
1065 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
1066 OCRepPayloadAddInterface(payload, "if.firstitem ");
1072 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1073 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1074 cborData, cborSize));
1076 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1078 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1079 EXPECT_EQ(NULL, parsedPayload->types->next);
1080 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1081 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1085 OCRepPayloadDestroy(payload);
1086 OCPayloadDestroy(cparsed);
1088 TEST(RepresentationEncodingRTandIF, SingleItemBothTrim)
1090 OCRepPayload* payload = OCRepPayloadCreate();
1091 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1092 OCRepPayloadAddInterface(payload, " if.firstitem ");
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_EQ(NULL, parsedPayload->types->next);
1106 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1107 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1111 OCRepPayloadDestroy(payload);
1112 OCPayloadDestroy(cparsed);
1114 TEST(RepresentationEncodingRTandIF, MultiItemsNormal)
1116 OCRepPayload* payload = OCRepPayloadCreate();
1117 OCRepPayloadAddResourceType(payload, "rt.firstitem");
1118 OCRepPayloadAddResourceType(payload, "rt.seconditem");
1119 OCRepPayloadAddInterface(payload, "if.firstitem");
1120 OCRepPayloadAddInterface(payload, "if.seconditem");
1126 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1127 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1128 cborData, cborSize));
1130 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1132 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1133 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1134 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1135 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1136 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1137 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1141 OCRepPayloadDestroy(payload);
1142 OCPayloadDestroy(cparsed);
1144 TEST(RepresentationEncodingRTandIF, MultiItemExtraLeadSpaces)
1146 OCRepPayload* payload = OCRepPayloadCreate();
1147 OCRepPayloadAddResourceType(payload, " rt.firstitem");
1148 OCRepPayloadAddResourceType(payload, " rt.seconditem");
1149 OCRepPayloadAddInterface(payload, " if.firstitem");
1150 OCRepPayloadAddInterface(payload, " if.seconditem");
1156 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1157 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1158 cborData, cborSize));
1160 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1162 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1163 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1164 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1165 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1166 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1167 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1171 OCRepPayloadDestroy(payload);
1172 OCPayloadDestroy(cparsed);
1174 TEST(RepresentationEncodingRTandIF, MultiItemExtraTrailSpaces)
1176 OCRepPayload* payload = OCRepPayloadCreate();
1177 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
1178 OCRepPayloadAddResourceType(payload, "rt.seconditem ");
1179 OCRepPayloadAddInterface(payload, "if.firstitem ");
1180 OCRepPayloadAddInterface(payload, "if.seconditem ");
1186 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1187 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1188 cborData, cborSize));
1190 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1192 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1193 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1194 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1195 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1196 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1197 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1201 OCRepPayloadDestroy(payload);
1202 OCPayloadDestroy(cparsed);
1204 TEST(RepresentationEncodingRTandIF, MultiItemExtraMiddleSpaces)
1206 OCRepPayload* payload = OCRepPayloadCreate();
1207 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1208 OCRepPayloadAddResourceType(payload, " rt.seconditem ");
1209 OCRepPayloadAddInterface(payload, " if.firstitem ");
1210 OCRepPayloadAddInterface(payload, " if.seconditem ");
1216 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1217 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1218 cborData, cborSize));
1220 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1222 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1223 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1224 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1225 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1226 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1227 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1231 OCRepPayloadDestroy(payload);
1232 OCPayloadDestroy(cparsed);
1234 TEST(RepresentationEncodingRTandIF, TestPayloadContents)
1236 OC::OCRepresentation subRep1;
1237 std::vector<std::string> types;
1238 types.push_back("rt.firstitem");
1239 std::vector<std::string> interfaces;
1240 interfaces.push_back("if.firstitem");
1241 subRep1.setResourceTypes(types);
1242 subRep1.setResourceInterfaces(interfaces);
1243 subRep1.setNULL("NullAttr");
1244 subRep1.setValue("IntAttr", 77);
1245 subRep1.setValue("DoubleAttr", 3.333);
1246 subRep1.setValue("BoolAttr", true);
1247 subRep1.setValue("StringAttr", std::string("String attr"));
1249 OC::MessageContainer mc1;
1250 mc1.addRepresentation(subRep1);
1252 OCRepPayload *repPayload = mc1.getPayload();
1253 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, repPayload->base.type);
1255 uint8_t *cborData = NULL;
1256 size_t cborSize = 0;
1257 OCPayload *cparsed = NULL;
1259 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)repPayload, &cborData, &cborSize));
1260 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1261 cborData, cborSize));
1263 OCRepPayload *parsedPayload = (OCRepPayload *)cparsed;
1264 EXPECT_EQ(NULL, parsedPayload->uri);
1265 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1266 EXPECT_EQ(NULL, parsedPayload->types->next);
1267 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1268 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1270 // To make sure rt and if are not duplicated.
1271 EXPECT_STREQ("BoolAttr", parsedPayload->values->name);
1272 EXPECT_EQ(true, parsedPayload->values->b);
1273 EXPECT_EQ(OCREP_PROP_BOOL, parsedPayload->values->type);
1274 parsedPayload->values = parsedPayload->values->next;
1276 EXPECT_STREQ("DoubleAttr", parsedPayload->values->name);
1277 EXPECT_EQ(OCREP_PROP_DOUBLE, parsedPayload->values->type);
1278 EXPECT_EQ(3.3330000000000002, parsedPayload->values->d);
1279 parsedPayload->values = parsedPayload->values->next;
1281 EXPECT_STREQ("IntAttr", parsedPayload->values->name);
1282 EXPECT_EQ(77, parsedPayload->values->i);
1283 EXPECT_EQ(OCREP_PROP_INT, parsedPayload->values->type);
1284 parsedPayload->values = parsedPayload->values->next;
1286 EXPECT_STREQ("NullAttr", parsedPayload->values->name);
1287 EXPECT_EQ(OCREP_PROP_NULL, parsedPayload->values->type);
1288 parsedPayload->values = parsedPayload->values->next;
1290 EXPECT_STREQ("StringAttr", parsedPayload->values->name);
1291 EXPECT_STREQ("String attr", parsedPayload->values->str);
1292 EXPECT_EQ(OCREP_PROP_STRING, parsedPayload->values->type);
1293 parsedPayload->values = parsedPayload->values->next;
1295 EXPECT_EQ(NULL, parsedPayload->values);
1298 OCRepPayloadDestroy(repPayload);
1299 OCPayloadDestroy(cparsed);