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>
32 bool operator==(const OC::NullType&, const OC::NullType&)
37 bool operator==(const OC::OCRepresentation& lhs, const OC::OCRepresentation& rhs)
39 return lhs.getUri() == rhs.getUri() &&
40 lhs.getChildren() == rhs.getChildren() &&
41 lhs.getResourceInterfaces() == rhs.getResourceInterfaces() &&
42 lhs.getResourceTypes() == rhs.getResourceTypes() &&
43 lhs.m_values == rhs.m_values;
46 // these tests validate the OCRepresentation->OCPayload, OCPayload->CBOR,
47 // CBOR->OCPayload and OCPayload->OCRepresentation conversions
48 namespace OCRepresentationEncodingTest
51 static const char uri1[] = "/testuri";
52 static const uint8_t sid1[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
53 static const char devicename1[] = "device name";
54 static const char specver1[] = "spec version";
55 static const char dmver1[] = "data model version";
57 TEST(DeviceDiscoveryEncoding, Normal)
59 OCDevicePayload* device = OCDevicePayloadCreate(
66 EXPECT_STREQ(uri1, device->uri);
67 EXPECT_STREQ(devicename1, device->deviceName);
68 EXPECT_STREQ(specver1, device->specVersion);
69 EXPECT_STREQ(dmver1, device->dataModelVersion);
70 EXPECT_EQ(PAYLOAD_TYPE_DEVICE, ((OCPayload*)device)->type);
72 for (uint8_t i = 1; i <= sizeof(sid1); ++i)
74 EXPECT_EQ(i, sid1[i - 1]);
79 OCPayload* parsedDevice;
80 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)device, &cborData, &cborSize));
81 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedDevice, PAYLOAD_TYPE_DEVICE,
85 EXPECT_STREQ(device->uri, ((OCDevicePayload*)parsedDevice)->uri);
86 EXPECT_STREQ(device->deviceName, ((OCDevicePayload*)parsedDevice)->deviceName);
87 EXPECT_STREQ(device->specVersion, ((OCDevicePayload*)parsedDevice)->specVersion);
88 EXPECT_STREQ(device->dataModelVersion, ((OCDevicePayload*)parsedDevice)->dataModelVersion);
89 EXPECT_EQ(device->base.type, ((OCDevicePayload*)parsedDevice)->base.type);
91 OCPayloadDestroy((OCPayload*)device);
93 OC::MessageContainer mc;
94 mc.setPayload(parsedDevice);
95 EXPECT_EQ(1u, mc.representations().size());
96 const OC::OCRepresentation& r = mc.representations()[0];
97 EXPECT_STREQ(uri1, r.getUri().c_str());
98 EXPECT_STREQ(devicename1, r.getValue<std::string>(OC_RSRVD_DEVICE_NAME).c_str());
99 EXPECT_STREQ(specver1, r.getValue<std::string>(OC_RSRVD_SPEC_VERSION).c_str());
100 EXPECT_STREQ(dmver1, r.getValue<std::string>(OC_RSRVD_DATA_MODEL_VERSION).c_str());
103 OCPayloadDestroy(parsedDevice);
106 static char pfid1[] = "pfid";
107 static char mfgnm1[] = "mfgnm";
108 static char mfgurl1[] = "mfgurl";
109 static char modelnum1[] = "modelnum";
110 static char dom1[] = "dom";
111 static char pfver1[] = "pfver";
112 static char osver1[] = "osver";
113 static char hwver1[] = "hwver";
114 static char fwver1[] = "fwver";
115 static char url1[] = "url";
116 static char time1[] = "time";
119 TEST(PlatformDiscoveryEncoding, Normal)
121 OCPlatformInfo info {pfid1, mfgnm1, mfgurl1, modelnum1, dom1, pfver1, osver1, hwver1,
122 fwver1, url1, time1};
123 OCPlatformPayload* platform = OCPlatformPayloadCreate(uri1, &info);
124 EXPECT_EQ(PAYLOAD_TYPE_PLATFORM, ((OCPayload*)platform)->type);
125 EXPECT_STREQ(uri1, platform->uri);
126 EXPECT_STREQ(pfid1, platform->info.platformID);
127 EXPECT_STREQ(mfgnm1, platform->info.manufacturerName);
128 EXPECT_STREQ(mfgurl1, platform->info.manufacturerUrl);
129 EXPECT_STREQ(modelnum1, platform->info.modelNumber);
130 EXPECT_STREQ(dom1, platform->info.dateOfManufacture);
131 EXPECT_STREQ(pfver1, platform->info.platformVersion);
132 EXPECT_STREQ(osver1, platform->info.operatingSystemVersion);
133 EXPECT_STREQ(hwver1, platform->info.hardwareVersion);
134 EXPECT_STREQ(fwver1, platform->info.firmwareVersion);
135 EXPECT_STREQ(url1, platform->info.supportUrl);
136 EXPECT_STREQ(time1, platform->info.systemTime);
140 OCPayload* parsedPlatform;
141 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)platform, &cborData, &cborSize));
142 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedPlatform, PAYLOAD_TYPE_PLATFORM,
143 cborData, cborSize));
146 EXPECT_EQ(platform->base.type, ((OCPlatformPayload*)parsedPlatform)->base.type);
147 OCPlatformPayload* platform2 = (OCPlatformPayload*)parsedPlatform;
148 EXPECT_STREQ(platform->uri, platform2->uri);
149 EXPECT_STREQ(platform->info.platformID, platform2->info.platformID);
150 EXPECT_STREQ(platform->info.manufacturerName, platform->info.manufacturerName);
151 EXPECT_STREQ(platform->info.manufacturerUrl, platform->info.manufacturerUrl);
152 EXPECT_STREQ(platform->info.modelNumber, platform->info.modelNumber);
153 EXPECT_STREQ(platform->info.dateOfManufacture, platform->info.dateOfManufacture);
154 EXPECT_STREQ(platform->info.platformVersion, platform->info.platformVersion);
155 EXPECT_STREQ(platform->info.operatingSystemVersion, platform->info.operatingSystemVersion);
156 EXPECT_STREQ(platform->info.hardwareVersion, platform->info.hardwareVersion);
157 EXPECT_STREQ(platform->info.firmwareVersion, platform->info.firmwareVersion);
158 EXPECT_STREQ(platform->info.supportUrl, platform->info.supportUrl);
159 EXPECT_STREQ(platform->info.systemTime, platform2->info.systemTime);
161 OCPayloadDestroy((OCPayload*)platform);
163 OC::MessageContainer mc;
164 mc.setPayload(parsedPlatform);
165 EXPECT_EQ(1u, mc.representations().size());
166 const OC::OCRepresentation& r = mc.representations()[0];
167 EXPECT_STREQ(uri1, r.getUri().c_str());
168 EXPECT_STREQ(pfid1, r.getValue<std::string>(OC_RSRVD_PLATFORM_ID).c_str());
169 EXPECT_STREQ(mfgnm1, r.getValue<std::string>(OC_RSRVD_MFG_NAME).c_str());
170 EXPECT_STREQ(mfgurl1, r.getValue<std::string>(OC_RSRVD_MFG_URL).c_str());
171 EXPECT_STREQ(modelnum1, r.getValue<std::string>(OC_RSRVD_MODEL_NUM).c_str());
172 EXPECT_STREQ(dom1, r.getValue<std::string>(OC_RSRVD_MFG_DATE).c_str());
173 EXPECT_STREQ(pfver1, r.getValue<std::string>(OC_RSRVD_PLATFORM_VERSION).c_str());
174 EXPECT_STREQ(osver1, r.getValue<std::string>(OC_RSRVD_OS_VERSION).c_str());
175 EXPECT_STREQ(hwver1, r.getValue<std::string>(OC_RSRVD_HARDWARE_VERSION).c_str());
176 EXPECT_STREQ(fwver1, r.getValue<std::string>(OC_RSRVD_FIRMWARE_VERSION).c_str());
177 EXPECT_STREQ(url1, r.getValue<std::string>(OC_RSRVD_SUPPORT_URL).c_str());
178 EXPECT_STREQ(time1, r.getValue<std::string>(OC_RSRVD_SYSTEM_TIME).c_str());
180 OCPayloadDestroy(parsedPlatform);
183 // Representation Payloads
184 TEST(RepresentationEncoding, BaseAttributeTypes)
186 OC::OCRepresentation startRep;
187 startRep.setNULL("NullAttr");
188 startRep.setValue("IntAttr", 77);
189 startRep.setValue("DoubleAttr", 3.333);
190 startRep.setValue("BoolAttr", true);
191 startRep.setValue("StringAttr", std::string("String attr"));
192 OC::MessageContainer mc1;
193 mc1.addRepresentation(startRep);
195 OCRepPayload* cstart = mc1.getPayload();
196 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
201 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
202 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
203 cborData, cborSize));
204 OCPayloadDestroy((OCPayload*)cstart);
207 OC::MessageContainer mc2;
208 mc2.setPayload(cparsed);
209 EXPECT_EQ(1u, mc2.representations().size());
210 const OC::OCRepresentation& r = mc2.representations()[0];
212 EXPECT_TRUE(r.isNULL("NullAttr"));
213 EXPECT_EQ(77, r.getValue<int>("IntAttr"));
214 EXPECT_EQ(3.333, r.getValue<double>("DoubleAttr"));
215 EXPECT_EQ(true, r.getValue<bool>("BoolAttr"));
216 EXPECT_STREQ("String attr", r.getValue<std::string>("StringAttr").c_str());
218 OCPayloadDestroy(cparsed);
221 TEST(RepresentationEncoding, RepAttribute)
223 OC::OCRepresentation startRep;
224 OC::OCRepresentation subRep;
225 subRep.setNULL("NullAttr");
226 subRep.setValue("IntAttr", 77);
227 subRep.setValue("DoubleAttr", 3.333);
228 subRep.setValue("BoolAttr", true);
229 subRep.setValue("StringAttr", std::string("String attr"));
230 startRep.setValue("Sub", subRep);
232 OC::MessageContainer mc1;
233 mc1.addRepresentation(startRep);
235 OCRepPayload* cstart = mc1.getPayload();
236 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
241 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
242 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
243 cborData, cborSize));
244 OCPayloadDestroy((OCPayload*)cstart);
247 OC::MessageContainer mc2;
248 mc2.setPayload(cparsed);
249 EXPECT_EQ(1u, mc2.representations().size());
250 const OC::OCRepresentation& r = mc2.representations()[0];
252 OC::OCRepresentation newSubRep = r["Sub"];
254 EXPECT_TRUE(newSubRep.isNULL("NullAttr"));
255 EXPECT_EQ(77, newSubRep.getValue<int>("IntAttr"));
256 EXPECT_EQ(3.333, newSubRep.getValue<double>("DoubleAttr"));
257 EXPECT_EQ(true, newSubRep.getValue<bool>("BoolAttr"));
258 EXPECT_STREQ("String attr", newSubRep.getValue<std::string>("StringAttr").c_str());
259 OCPayloadDestroy(cparsed);
262 TEST(RepresentationEncoding, OneDVectors)
265 OC::OCRepresentation startRep;
267 OC::OCRepresentation subRep1;
268 OC::OCRepresentation subRep2;
269 OC::OCRepresentation subRep3;
270 subRep1.setNULL("NullAttr");
271 subRep1.setValue("IntAttr", 77);
272 subRep2.setValue("DoubleAttr", 3.333);
273 subRep2.setValue("BoolAttr", true);
274 subRep3.setValue("StringAttr", std::string("String attr"));
276 std::vector<int> iarr {1,2,3,4,5,6,7,8,9};
277 std::vector<double> darr {1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9};
278 std::vector<bool> barr {false, true, false, false, true, true};
279 std::vector<std::string> strarr {"item1", "item2", "item3", "item4"};
280 std::vector<OC::OCRepresentation> objarr {subRep1, subRep2, subRep3};
282 startRep["iarr"] = iarr;
283 startRep["darr"] = darr;
284 startRep["barr"] = barr;
285 startRep["strarr"] = strarr;
286 startRep["objarr"] = objarr;
289 OC::MessageContainer mc1;
290 mc1.addRepresentation(startRep);
292 OCRepPayload* cstart = mc1.getPayload();
293 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
298 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
299 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
300 cborData, cborSize));
301 OCPayloadDestroy((OCPayload*)cstart);
304 OC::MessageContainer mc2;
305 mc2.setPayload(cparsed);
306 EXPECT_EQ(1u, mc2.representations().size());
307 const OC::OCRepresentation& r = mc2.representations()[0];
310 std::vector<int> iarr2 = r["iarr"];
311 std::vector<double> darr2 = r["darr"];
312 std::vector<bool> barr2 = r["barr"];
313 std::vector<std::string> strarr2 = r["strarr"];
314 std::vector<OC::OCRepresentation> objarr2 = r["objarr"];
316 EXPECT_EQ(iarr, iarr2);
317 EXPECT_EQ(darr, darr2);
318 EXPECT_EQ(barr, barr2);
319 EXPECT_EQ(strarr, strarr2);
320 EXPECT_EQ(objarr, objarr2);
321 OCPayloadDestroy(cparsed);
324 TEST(RepresentationEncoding, TwoDVectors)
327 OC::OCRepresentation startRep;
329 OC::OCRepresentation subRep1;
330 OC::OCRepresentation subRep2;
331 OC::OCRepresentation subRep3;
332 subRep1.setNULL("NullAttr");
333 subRep1.setValue("IntAttr", 77);
334 subRep2.setValue("DoubleAttr", 3.333);
335 subRep2.setValue("BoolAttr", true);
336 subRep3.setValue("StringAttr", std::string("String attr"));
338 std::vector<std::vector<int>> iarr {{1,2,3},{4,5,6},{7,8,9}};
339 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{7.7,8.8,9.9}};
340 std::vector<std::vector<bool>> barr {{false, true}, {false, false}, {true, true}};
341 std::vector<std::vector<std::string>> strarr {{"item1", "item2"}, {"item3", "item4"}};
342 std::vector<std::vector<OC::OCRepresentation>> objarr
343 {{subRep1, subRep2, subRep3}, {subRep3, subRep2, subRep1}};
345 startRep["iarr"] = iarr;
346 startRep["darr"] = darr;
347 startRep["barr"] = barr;
348 startRep["strarr"] = strarr;
349 startRep["objarr"] = objarr;
352 OC::MessageContainer mc1;
353 mc1.addRepresentation(startRep);
355 OCRepPayload* cstart = mc1.getPayload();
356 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
361 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
362 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
363 cborData, cborSize));
364 OCPayloadDestroy((OCPayload*)cstart);
367 OC::MessageContainer mc2;
368 mc2.setPayload(cparsed);
369 EXPECT_EQ(1u, mc2.representations().size());
370 const OC::OCRepresentation& r = mc2.representations()[0];
373 std::vector<std::vector<int>> iarr2 = r["iarr"];
374 std::vector<std::vector<double>> darr2 = r["darr"];
375 std::vector<std::vector<bool>> barr2 = r["barr"];
376 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
377 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
379 EXPECT_EQ(iarr, iarr2);
380 EXPECT_EQ(darr, darr2);
381 EXPECT_EQ(barr, barr2);
382 EXPECT_EQ(strarr, strarr2);
383 EXPECT_EQ(objarr, objarr2);
384 OCPayloadDestroy(cparsed);
387 TEST(RepresentationEncoding, TwoDVectorsJagged)
390 OC::OCRepresentation startRep;
392 OC::OCRepresentation subRep1;
393 OC::OCRepresentation subRep2;
394 OC::OCRepresentation subRep3;
395 subRep1.setNULL("NullAttr");
396 subRep1.setValue("IntAttr", 77);
397 subRep2.setValue("DoubleAttr", 3.333);
398 subRep2.setValue("BoolAttr", true);
399 subRep3.setValue("StringAttr", std::string("String attr"));
401 std::vector<std::vector<int>> iarr {{1,2,3},{4,6},{7,8,9}};
402 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{8.8,9.9}};
403 std::vector<std::vector<bool>> barr {{false, true}, {false}, {true, true}};
404 std::vector<std::vector<std::string>> strarr {{"item1"}, {"item3", "item4"}};
405 std::vector<std::vector<OC::OCRepresentation>> objarr
406 {{subRep1, subRep3}, {subRep3, subRep2, subRep1}};
408 startRep["iarr"] = iarr;
409 startRep["darr"] = darr;
410 startRep["barr"] = barr;
411 startRep["strarr"] = strarr;
412 startRep["objarr"] = objarr;
415 OC::MessageContainer mc1;
416 mc1.addRepresentation(startRep);
418 OCRepPayload* cstart = mc1.getPayload();
419 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
424 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
425 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
426 cborData, cborSize));
427 OCPayloadDestroy((OCPayload*)cstart);
430 OC::MessageContainer mc2;
431 mc2.setPayload(cparsed);
432 EXPECT_EQ(1u, mc2.representations().size());
433 const OC::OCRepresentation& r = mc2.representations()[0];
436 std::vector<std::vector<int>> iarr2 = r["iarr"];
437 std::vector<std::vector<double>> darr2 = r["darr"];
438 std::vector<std::vector<bool>> barr2 = r["barr"];
439 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
440 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
442 // Note: due to the way that the CSDK works, all 2d arrays need to be rectangular.
443 // Since std::vector doesn't require this, items received on the other side end up
444 // being backfilled. This section removes the backfilling
448 strarr2[0].pop_back();
449 objarr2[0].pop_back();
451 EXPECT_EQ(iarr, iarr2);
452 EXPECT_EQ(darr, darr2);
453 EXPECT_EQ(barr, barr2);
454 EXPECT_EQ(strarr, strarr2);
455 EXPECT_EQ(objarr, objarr2);
456 OCPayloadDestroy(cparsed);
459 TEST(RepresentationEncoding, ThreeDVectors)
462 OC::OCRepresentation startRep;
464 OC::OCRepresentation subRep1;
465 OC::OCRepresentation subRep2;
466 OC::OCRepresentation subRep3;
467 subRep1.setNULL("NullAttr");
468 subRep1.setValue("IntAttr", 77);
469 subRep2.setValue("DoubleAttr", 3.333);
470 subRep2.setValue("BoolAttr", true);
471 subRep3.setValue("StringAttr", std::string("String attr"));
473 std::vector<std::vector<std::vector<int>>> iarr
474 {{{1,2,3},{4,5,6}},{{7,8,9},{10,11,12}},{{13,14,15},{16,17,18}}};
475 std::vector<std::vector<std::vector<double>>> darr
476 {{{1.1,2.2,3.3},{4.4,5.5,6.6}},
477 {{7.7,8.7,9.7},{10.7,11.7,12.7}},
478 {{13.7,14.7,15.7},{16.7,17.7,18.7}}};
479 std::vector<std::vector<std::vector<bool>>> barr
480 {{{false, true},{true, false}},{{false, true},{true, false}}};
481 std::vector<std::vector<std::vector<std::string>>> strarr
483 {{"item1", "item2"},{"item3", "item4"}},
484 {{"item5", "item6"},{"item7", "item8"}},
485 {{"item9", "item10"},{"item11", ""}}
487 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
489 {{subRep1, subRep2},{subRep3, subRep1}},
490 {{subRep2, subRep3},{subRep2, subRep1}},
491 {{subRep3, subRep2},{subRep1, subRep2}}
494 startRep["iarr"] = iarr;
495 startRep["darr"] = darr;
496 startRep["barr"] = barr;
497 startRep["strarr"] = strarr;
498 startRep["objarr"] = objarr;
501 OC::MessageContainer mc1;
502 mc1.addRepresentation(startRep);
504 OCRepPayload* cstart = mc1.getPayload();
505 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
510 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
511 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
512 cborData, cborSize));
513 OCPayloadDestroy((OCPayload*)cstart);
516 OC::MessageContainer mc2;
517 mc2.setPayload(cparsed);
518 EXPECT_EQ(1u, mc2.representations().size());
519 const OC::OCRepresentation& r = mc2.representations()[0];
522 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
523 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
524 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
525 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
526 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
528 EXPECT_EQ(iarr, iarr2);
529 EXPECT_EQ(darr, darr2);
530 EXPECT_EQ(barr, barr2);
531 EXPECT_EQ(strarr, strarr2);
532 EXPECT_EQ(objarr, objarr2);
533 OCPayloadDestroy(cparsed);
536 TEST(RepresentationEncoding, ThreeDVectorsJagged)
539 OC::OCRepresentation startRep;
541 OC::OCRepresentation subRep1;
542 OC::OCRepresentation subRep2;
543 OC::OCRepresentation subRep3;
544 subRep1.setNULL("NullAttr");
545 subRep1.setValue("IntAttr", 77);
546 subRep2.setValue("DoubleAttr", 3.333);
547 subRep2.setValue("BoolAttr", true);
548 subRep3.setValue("StringAttr", std::string("String attr"));
550 std::vector<std::vector<std::vector<int>>> iarr
554 {{13,14,15},{16,17,18}}
556 std::vector<std::vector<std::vector<double>>> darr
558 {{1.1,2.2,3.3},{4.4,5.5,6.6}},
559 {{7.7,8.7,9.7},{10.7,12.7}},
560 {{13.7,14.7,15.7},{16.7,17.7,18.7}}
562 std::vector<std::vector<std::vector<bool>>> barr
564 {{false, true},{true}},
565 {{false, true},{true, false}}
567 std::vector<std::vector<std::vector<std::string>>> strarr
569 {{"item1", "item2"},{"item3", "item4"}},
570 {{"item5", "item6"},{"item8"}},
571 {{"item9", "item10"},{"item11", ""}}
573 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
575 {{subRep1, subRep2},{subRep3, subRep1}},
576 {{subRep2, subRep3},{subRep2}},
580 startRep["iarr"] = iarr;
581 startRep["darr"] = darr;
582 startRep["barr"] = barr;
583 startRep["strarr"] = strarr;
584 startRep["objarr"] = objarr;
587 OC::MessageContainer mc1;
588 mc1.addRepresentation(startRep);
590 OCRepPayload* cstart = mc1.getPayload();
591 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
596 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
597 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
598 cborData, cborSize));
599 OCPayloadDestroy((OCPayload*)cstart);
602 OC::MessageContainer mc2;
603 mc2.setPayload(cparsed);
604 EXPECT_EQ(1u, mc2.representations().size());
605 const OC::OCRepresentation& r = mc2.representations()[0];
608 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
609 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
610 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
611 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
612 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
614 // Note: due to the way that the CSDK works, all 3d arrays need to be cuboidal.
615 // Since std::vector doesn't require this, items received on the other side end up
616 // being backfilled. This section removes the backfilling
617 iarr2[1][1].pop_back();
618 darr2[1][1].pop_back();
619 barr2[0][1].pop_back();
620 strarr2[1][1].pop_back();
621 objarr2[1][1].pop_back();
622 objarr2[2].pop_back();
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(DiscoveryRTandIF, SingleItemNormal)
634 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
635 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
636 payload->resources = resource;
638 OCResourcePayloadAddResourceType(resource, "rt.singleitem");
639 OCResourcePayloadAddInterface(resource, "if.singleitem");
640 resource->uri = OICStrdup("/uri/thing");
641 resource->sid = (uint8_t*)OICMalloc(16);
647 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
648 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
649 cborData, cborSize));
651 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
652 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
654 EXPECT_EQ(NULL, parsedResource->next);
656 EXPECT_EQ(NULL, parsedResource->types->next);
657 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
658 EXPECT_EQ(NULL, parsedResource->interfaces->next);
659 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
662 OCPayloadDestroy(cparsed);
663 OCDiscoveryPayloadDestroy(payload);
666 TEST(DiscoveryRTandIF, SingleItemFrontTrim)
668 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
669 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
670 payload->resources = resource;
672 OCResourcePayloadAddResourceType(resource, " rt.singleitem");
673 OCResourcePayloadAddInterface(resource, " if.singleitem");
674 resource->uri = OICStrdup("/uri/thing");
675 resource->sid = (uint8_t*)OICMalloc(16);
681 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
682 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
683 cborData, cborSize));
685 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
686 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
688 EXPECT_EQ(NULL, parsedResource->next);
690 EXPECT_EQ(NULL, parsedResource->types->next);
691 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
692 EXPECT_EQ(NULL, parsedResource->interfaces->next);
693 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
696 OCPayloadDestroy(cparsed);
697 OCDiscoveryPayloadDestroy(payload);
699 TEST(DiscoveryRTandIF, SingleItemBackTrim)
701 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
702 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
703 payload->resources = resource;
705 OCResourcePayloadAddResourceType(resource, "rt.singleitem ");
706 OCResourcePayloadAddInterface(resource, "if.singleitem ");
707 resource->uri = OICStrdup("/uri/thing");
708 resource->sid = (uint8_t*)OICMalloc(16);
714 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
715 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
716 cborData, cborSize));
718 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
719 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
721 EXPECT_EQ(NULL, parsedResource->next);
723 EXPECT_EQ(NULL, parsedResource->types->next);
724 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
725 EXPECT_EQ(NULL, parsedResource->interfaces->next);
726 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
729 OCPayloadDestroy(cparsed);
730 OCDiscoveryPayloadDestroy(payload);
732 TEST(DiscoveryRTandIF, SingleItemBothTrim)
734 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
735 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
736 payload->resources = resource;
738 OCResourcePayloadAddResourceType(resource, " rt.singleitem ");
739 OCResourcePayloadAddInterface(resource, " if.singleitem ");
740 resource->uri = OICStrdup("/uri/thing");
741 resource->sid = (uint8_t*)OICMalloc(16);
747 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
748 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
749 cborData, cborSize));
751 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
752 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
754 EXPECT_EQ(NULL, parsedResource->next);
756 EXPECT_EQ(NULL, parsedResource->types->next);
757 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
758 EXPECT_EQ(NULL, parsedResource->interfaces->next);
759 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
762 OCPayloadDestroy(cparsed);
763 OCDiscoveryPayloadDestroy(payload);
765 TEST(DiscoveryRTandIF, MultiItemsNormal)
767 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
768 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
769 payload->resources = resource;
771 OCResourcePayloadAddResourceType(resource, "rt.firstitem");
772 OCResourcePayloadAddResourceType(resource, "rt.seconditem");
773 OCResourcePayloadAddInterface(resource, "if.firstitem");
774 OCResourcePayloadAddInterface(resource, "if.seconditem");
775 resource->uri = OICStrdup("/uri/thing");
776 resource->sid = (uint8_t*)OICMalloc(16);
782 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
783 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
784 cborData, cborSize));
786 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
787 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
789 EXPECT_EQ(NULL, parsedResource->next);
791 EXPECT_EQ(NULL, parsedResource->types->next->next);
792 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
793 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
794 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
795 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
796 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
799 OCPayloadDestroy(cparsed);
800 OCDiscoveryPayloadDestroy(payload);
802 TEST(DiscoveryRTandIF, MultiItemExtraLeadSpaces)
804 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
805 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
806 payload->resources = resource;
808 OCResourcePayloadAddResourceType(resource, " rt.firstitem");
809 OCResourcePayloadAddResourceType(resource, " rt.seconditem");
810 OCResourcePayloadAddInterface(resource, " if.firstitem");
811 OCResourcePayloadAddInterface(resource, " if.seconditem");
812 resource->uri = OICStrdup("/uri/thing");
813 resource->sid = (uint8_t*)OICMalloc(16);
819 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
820 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
821 cborData, cborSize));
823 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
824 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
826 EXPECT_EQ(NULL, parsedResource->next);
828 EXPECT_EQ(NULL, parsedResource->types->next->next);
829 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
830 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
831 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
832 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
833 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
836 OCPayloadDestroy(cparsed);
837 OCDiscoveryPayloadDestroy(payload);
839 TEST(DiscoveryRTandIF, MultiItemExtraTrailSpaces)
841 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
842 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
843 payload->resources = resource;
845 OCResourcePayloadAddResourceType(resource, "rt.firstitem ");
846 OCResourcePayloadAddResourceType(resource, "rt.seconditem ");
847 OCResourcePayloadAddInterface(resource, "if.firstitem ");
848 OCResourcePayloadAddInterface(resource, "if.seconditem ");
849 resource->uri = OICStrdup("/uri/thing");
850 resource->sid = (uint8_t*)OICMalloc(16);
856 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
857 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
858 cborData, cborSize));
860 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
861 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
863 EXPECT_EQ(NULL, parsedResource->next);
865 EXPECT_EQ(NULL, parsedResource->types->next->next);
866 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
867 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
868 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
869 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
870 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
873 OCPayloadDestroy(cparsed);
874 OCDiscoveryPayloadDestroy(payload);
876 TEST(DiscoveryRTandIF, MultiItemBothSpaces)
878 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
879 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
880 payload->resources = resource;
882 OCResourcePayloadAddResourceType(resource, " rt.firstitem ");
883 OCResourcePayloadAddResourceType(resource, " rt.seconditem ");
884 OCResourcePayloadAddInterface(resource, " if.firstitem ");
885 OCResourcePayloadAddInterface(resource, " if.seconditem ");
886 resource->uri = OICStrdup("/uri/thing");
887 resource->sid = (uint8_t*)OICMalloc(16);
893 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
894 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
895 cborData, cborSize));
897 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
898 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
900 EXPECT_EQ(NULL, parsedResource->next);
902 EXPECT_EQ(NULL, parsedResource->types->next->next);
903 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
904 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
905 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
906 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
907 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
910 OCPayloadDestroy(cparsed);
911 OCDiscoveryPayloadDestroy(payload);
913 TEST(RepresentationEncodingRTandIF, SingleItemNormal)
915 OCRepPayload* payload = OCRepPayloadCreate();
916 OCRepPayloadSetUri(payload, "/this/uri");
917 OCRepPayloadAddResourceType(payload, "rt.firstitem");
918 OCRepPayloadAddInterface(payload, "if.firstitem");
924 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
925 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
926 cborData, cborSize));
928 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
930 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
931 EXPECT_EQ(NULL, parsedPayload->types->next);
932 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
933 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
937 OCRepPayloadDestroy(payload);
938 OCPayloadDestroy(cparsed);
940 TEST(RepresentationEncodingRTandIF, SingleItemFrontTrim)
942 OCRepPayload* payload = OCRepPayloadCreate();
943 OCRepPayloadSetUri(payload, "/this/uri");
944 OCRepPayloadAddResourceType(payload, " rt.firstitem");
945 OCRepPayloadAddInterface(payload, " if.firstitem");
951 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
952 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
953 cborData, cborSize));
955 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
957 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
958 EXPECT_EQ(NULL, parsedPayload->types->next);
959 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
960 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
964 OCRepPayloadDestroy(payload);
965 OCPayloadDestroy(cparsed);
967 TEST(RepresentationEncodingRTandIF, SingleItemBackTrim)
969 OCRepPayload* payload = OCRepPayloadCreate();
970 OCRepPayloadSetUri(payload, "/this/uri");
971 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
972 OCRepPayloadAddInterface(payload, "if.firstitem ");
978 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
979 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
980 cborData, cborSize));
982 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
984 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
985 EXPECT_EQ(NULL, parsedPayload->types->next);
986 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
987 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
991 OCRepPayloadDestroy(payload);
992 OCPayloadDestroy(cparsed);
994 TEST(RepresentationEncodingRTandIF, SingleItemBothTrim)
996 OCRepPayload* payload = OCRepPayloadCreate();
997 OCRepPayloadSetUri(payload, "/this/uri");
998 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
999 OCRepPayloadAddInterface(payload, " if.firstitem ");
1005 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1006 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1007 cborData, cborSize));
1009 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1011 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1012 EXPECT_EQ(NULL, parsedPayload->types->next);
1013 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1014 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1018 OCRepPayloadDestroy(payload);
1019 OCPayloadDestroy(cparsed);
1021 TEST(RepresentationEncodingRTandIF, MultiItemsNormal)
1023 OCRepPayload* payload = OCRepPayloadCreate();
1024 OCRepPayloadSetUri(payload, "/this/uri");
1025 OCRepPayloadAddResourceType(payload, "rt.firstitem");
1026 OCRepPayloadAddResourceType(payload, "rt.seconditem");
1027 OCRepPayloadAddInterface(payload, "if.firstitem");
1028 OCRepPayloadAddInterface(payload, "if.seconditem");
1034 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1035 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1036 cborData, cborSize));
1038 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1040 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1041 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1042 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1043 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1044 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1045 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1049 OCRepPayloadDestroy(payload);
1050 OCPayloadDestroy(cparsed);
1052 TEST(RepresentationEncodingRTandIF, MultiItemExtraLeadSpaces)
1054 OCRepPayload* payload = OCRepPayloadCreate();
1055 OCRepPayloadSetUri(payload, "/this/uri");
1056 OCRepPayloadAddResourceType(payload, " rt.firstitem");
1057 OCRepPayloadAddResourceType(payload, " rt.seconditem");
1058 OCRepPayloadAddInterface(payload, " if.firstitem");
1059 OCRepPayloadAddInterface(payload, " if.seconditem");
1065 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1066 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1067 cborData, cborSize));
1069 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1071 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1072 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1073 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1074 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1075 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1076 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1080 OCRepPayloadDestroy(payload);
1081 OCPayloadDestroy(cparsed);
1083 TEST(RepresentationEncodingRTandIF, MultiItemExtraTrailSpaces)
1085 OCRepPayload* payload = OCRepPayloadCreate();
1086 OCRepPayloadSetUri(payload, "/this/uri");
1087 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
1088 OCRepPayloadAddResourceType(payload, "rt.seconditem ");
1089 OCRepPayloadAddInterface(payload, "if.firstitem ");
1090 OCRepPayloadAddInterface(payload, "if.seconditem ");
1096 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1097 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1098 cborData, cborSize));
1100 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1102 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1103 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1104 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1105 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1106 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1107 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1111 OCRepPayloadDestroy(payload);
1112 OCPayloadDestroy(cparsed);
1114 TEST(RepresentationEncodingRTandIF, MultiItemExtraMiddleSpaces)
1116 OCRepPayload* payload = OCRepPayloadCreate();
1117 OCRepPayloadSetUri(payload, "/this/uri");
1118 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1119 OCRepPayloadAddResourceType(payload, " rt.seconditem ");
1120 OCRepPayloadAddInterface(payload, " if.firstitem ");
1121 OCRepPayloadAddInterface(payload, " if.seconditem ");
1127 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1128 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1129 cborData, cborSize));
1131 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1133 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1134 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1135 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1136 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1137 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1138 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1142 OCRepPayloadDestroy(payload);
1143 OCPayloadDestroy(cparsed);