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"
32 bool operator==(const OCByteString& lhs, const OCByteString& rhs)
34 bool result = (lhs.len == rhs.len);
37 result = (memcmp(lhs.bytes, rhs.bytes, lhs.len) == 0);
44 bool operator==(const OC::NullType&, const OC::NullType&)
49 bool operator==(const OC::OCRepresentation& lhs, const OC::OCRepresentation& rhs)
51 return lhs.getUri() == rhs.getUri() &&
52 lhs.getChildren() == rhs.getChildren() &&
53 lhs.getResourceInterfaces() == rhs.getResourceInterfaces() &&
54 lhs.getResourceTypes() == rhs.getResourceTypes() &&
55 lhs.m_values == rhs.m_values;
58 // these tests validate the OCRepresentation->OCPayload, OCPayload->CBOR,
59 // CBOR->OCPayload and OCPayload->OCRepresentation conversions
60 namespace OCRepresentationEncodingTest
62 static const char *sid1;
64 TEST(DeviceDiscoveryEncoding, Normal)
66 sid1 = OCGetServerInstanceIDString();
67 const char devicename1[] = "device name";
68 OCRepPayload *device = OCRepPayloadCreate();
70 EXPECT_TRUE(OCRepPayloadAddResourceType(device, OC_RSRVD_RESOURCE_TYPE_DEVICE));
71 EXPECT_TRUE(OCRepPayloadAddResourceType(device, "oic.d.tv"));
72 EXPECT_TRUE(OCRepPayloadSetPropString(device, OC_RSRVD_DEVICE_ID, sid1));
73 EXPECT_TRUE(OCRepPayloadSetPropString(device, OC_RSRVD_DEVICE_NAME, devicename1));
74 EXPECT_TRUE(OCRepPayloadSetPropString(device, OC_RSRVD_SPEC_VERSION, OC_SPEC_VERSION));
75 EXPECT_TRUE(OCRepPayloadSetPropString(device, "x.org.iotivity.newproperty", "value"));
77 size_t dim[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
78 char **dt = (char **)OICMalloc(sizeof(char *) * 1);
80 dt[0] = OICStrdup(OC_DATA_MODEL_VERSION);
81 EXPECT_TRUE(OCRepPayloadSetStringArray(device, OC_RSRVD_DATA_MODEL_VERSION, (const char **)dt, dim));
87 OCPayload* parsedDevice;
88 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)device, &cborData, &cborSize));
89 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedDevice, PAYLOAD_TYPE_REPRESENTATION, cborData, cborSize));
92 OCRepPayload *parsedRep = (OCRepPayload *)parsedDevice;
94 EXPECT_TRUE(OCRepPayloadGetPropString(parsedRep, OC_RSRVD_DEVICE_ID, &value));
95 EXPECT_STREQ(sid1, value);
97 EXPECT_TRUE(OCRepPayloadGetPropString(parsedRep, OC_RSRVD_DEVICE_NAME, &value));
98 EXPECT_STREQ(devicename1, value);
100 EXPECT_TRUE(OCRepPayloadGetPropString(parsedRep, OC_RSRVD_SPEC_VERSION, &value));
101 EXPECT_STREQ(OC_SPEC_VERSION, value);
103 EXPECT_TRUE(OCRepPayloadGetPropString(device, "x.org.iotivity.newproperty", &value));
104 EXPECT_STREQ("value", value);
107 EXPECT_TRUE(OCRepPayloadGetStringArray(parsedRep, OC_RSRVD_DATA_MODEL_VERSION, &dmv, dim));
108 EXPECT_STREQ(OC_DATA_MODEL_VERSION, dmv[0]);
111 EXPECT_STREQ("oic.wk.d", parsedRep->types->value);
112 EXPECT_STREQ("oic.d.tv", parsedRep->types->next->value);
113 EXPECT_EQ(device->base.type, parsedRep->base.type);
115 OCPayloadDestroy((OCPayload*)device);
117 OC::MessageContainer mc1;
118 mc1.setPayload(parsedDevice);
119 EXPECT_EQ(1u, mc1.representations().size());
120 const OC::OCRepresentation &r1 = mc1.representations()[0];
121 EXPECT_STREQ(sid1, r1.getValue<std::string>(OC_RSRVD_DEVICE_ID).c_str());
122 EXPECT_STREQ(devicename1, r1.getValue<std::string>(OC_RSRVD_DEVICE_NAME).c_str());
123 EXPECT_STREQ(OC_SPEC_VERSION, r1.getValue<std::string>(OC_RSRVD_SPEC_VERSION).c_str());
124 EXPECT_STREQ("value", r1.getValue<std::string>("x.org.iotivity.newproperty").c_str());
125 std::vector<std::string> dmv2 = r1.getValue<std::vector<std::string>>(OC_RSRVD_DATA_MODEL_VERSION);
126 EXPECT_STREQ(OC_DATA_MODEL_VERSION, dmv2[0].c_str());
128 OCPayloadDestroy(parsedDevice);
130 device = OCRepPayloadCreate();
132 EXPECT_TRUE(OCRepPayloadAddResourceType(device, OC_RSRVD_RESOURCE_TYPE_DEVICE));
133 EXPECT_TRUE(OCRepPayloadAddResourceType(device, "oic.d.tv"));
134 EXPECT_TRUE(OCRepPayloadSetPropString(device, OC_RSRVD_DEVICE_NAME, devicename1));
135 EXPECT_TRUE(OCRepPayloadSetPropString(device, OC_RSRVD_DEVICE_ID, sid1));
136 EXPECT_TRUE(OCRepPayloadSetPropString(device, OC_RSRVD_SPEC_VERSION, OC_SPEC_VERSION));
137 size_t dim1[MAX_REP_ARRAY_DEPTH] = {2, 0, 0};
138 char **dt1 = (char **)OICMalloc(sizeof(char *) * 2);
140 dt1[0] = OICStrdup("res.1.1.0");
141 dt1[1] = OICStrdup("sh.1.1.0");
142 OCRepPayloadSetStringArray(device, OC_RSRVD_DATA_MODEL_VERSION, (const char**)dt1, dim1);
143 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload *)device, &cborData, &cborSize));
144 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedDevice, PAYLOAD_TYPE_REPRESENTATION, cborData, cborSize));
150 parsedRep = (OCRepPayload *)parsedDevice;
151 EXPECT_TRUE(OCRepPayloadGetStringArray(parsedRep, OC_RSRVD_DATA_MODEL_VERSION, &dmv1, dim));
152 EXPECT_STREQ("res.1.1.0", dmv1[0]);
153 EXPECT_STREQ("sh.1.1.0", dmv1[1]);
157 OCPayloadDestroy((OCPayload *)device);
158 OC::MessageContainer mc2;
159 mc2.setPayload(parsedDevice);
160 EXPECT_EQ(1u, mc2.representations().size());
161 const OC::OCRepresentation r2 = mc2.representations()[0];
162 std::vector<std::string> dmv3 = r2.getValue<std::vector<std::string>>(OC_RSRVD_DATA_MODEL_VERSION);
163 EXPECT_STREQ("res.1.1.0", dmv3[0].c_str());
164 EXPECT_STREQ("sh.1.1.0", dmv3[1].c_str());
165 OCPayloadDestroy(parsedDevice);
169 TEST(PlatformDiscoveryEncoding, Normal)
171 static char pfid1[] = "646F6F72-4465-7669-6365-555549443030";
172 static char mfgnm1[] = "mfgnm";
173 static char mfgurl1[] = "http://www.iotivity.org";
174 static char modelnum1[] = "modelnum";
175 static char dom1[] = "dom";
176 static char pfver1[] = "pfver";
177 static char osver1[] = "osver";
178 static char hwver1[] = "hwver";
179 static char fwver1[] = "fwver";
180 static char url1[] = "http://www.iotivity.org";
181 static char time1[] = "20161122T143938Z";
182 static char vid1[] = "Manufacturer Freeform Text";
183 OCRepPayload *platform = OCRepPayloadCreate();
184 EXPECT_TRUE(platform != NULL);
185 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, ((OCPayload*)platform)->type);
186 EXPECT_TRUE(OCRepPayloadAddResourceType(platform, (char *)OC_RSRVD_RESOURCE_TYPE_PLATFORM));
187 EXPECT_TRUE(OCRepPayloadAddInterface(platform, (char *)OC_RSRVD_INTERFACE_DEFAULT));
188 EXPECT_TRUE(OCRepPayloadAddInterface(platform, (char *)OC_RSRVD_INTERFACE_READ));
189 EXPECT_TRUE(OCRepPayloadSetPropString(platform, OC_RSRVD_PLATFORM_ID, pfid1));
190 EXPECT_TRUE(OCRepPayloadSetPropString(platform, OC_RSRVD_MFG_NAME, mfgnm1));
191 EXPECT_TRUE(OCRepPayloadSetPropString(platform, OC_RSRVD_MFG_URL, mfgurl1));
192 EXPECT_TRUE(OCRepPayloadSetPropString(platform, OC_RSRVD_MODEL_NUM, modelnum1));
193 EXPECT_TRUE(OCRepPayloadSetPropString(platform, OC_RSRVD_MFG_DATE, dom1));
194 EXPECT_TRUE(OCRepPayloadSetPropString(platform, OC_RSRVD_OS_VERSION, osver1));
195 EXPECT_TRUE(OCRepPayloadSetPropString(platform, OC_RSRVD_PLATFORM_VERSION, pfver1));
196 EXPECT_TRUE(OCRepPayloadSetPropString(platform, OC_RSRVD_HARDWARE_VERSION, hwver1));
197 EXPECT_TRUE(OCRepPayloadSetPropString(platform, OC_RSRVD_FIRMWARE_VERSION, fwver1));
198 EXPECT_TRUE(OCRepPayloadSetPropString(platform, OC_RSRVD_SUPPORT_URL, url1));
199 EXPECT_TRUE(OCRepPayloadSetPropString(platform, OC_RSRVD_SYSTEM_TIME, time1));
200 EXPECT_TRUE(OCRepPayloadSetPropString(platform, OC_RSRVD_VID, vid1));
205 OCPayload* parsedPlatform = NULL;
206 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)platform, &cborData, &cborSize));
207 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&parsedPlatform, PAYLOAD_TYPE_REPRESENTATION, cborData, cborSize));
210 OCRepPayload *platform1 = (OCRepPayload *)parsedPlatform;
211 EXPECT_EQ(platform->base.type, platform1->base.type);
213 EXPECT_TRUE(OCRepPayloadGetPropString(platform1, OC_RSRVD_PLATFORM_ID, &value));
214 EXPECT_STREQ(pfid1, value);
217 EXPECT_TRUE(OCRepPayloadGetPropString(platform1, OC_RSRVD_MFG_NAME, &value));
218 EXPECT_STREQ(mfgnm1, value);
221 EXPECT_TRUE(OCRepPayloadGetPropString(platform1, OC_RSRVD_MFG_URL, &value));
222 EXPECT_STREQ(mfgurl1, value);
225 EXPECT_TRUE(OCRepPayloadGetPropString(platform1, OC_RSRVD_MODEL_NUM, &value));
226 EXPECT_STREQ(modelnum1, value);
229 EXPECT_TRUE(OCRepPayloadGetPropString(platform1, OC_RSRVD_MFG_DATE, &value));
230 EXPECT_STREQ(dom1, value);
233 EXPECT_TRUE(OCRepPayloadGetPropString(platform1, OC_RSRVD_OS_VERSION, &value));
234 EXPECT_STREQ(osver1, value);
237 EXPECT_TRUE(OCRepPayloadGetPropString(platform1, OC_RSRVD_PLATFORM_VERSION, &value));
238 EXPECT_STREQ(pfver1, value);
241 EXPECT_TRUE(OCRepPayloadGetPropString(platform1, OC_RSRVD_HARDWARE_VERSION, &value));
242 EXPECT_STREQ(hwver1, value);
245 EXPECT_TRUE(OCRepPayloadGetPropString(platform1, OC_RSRVD_FIRMWARE_VERSION, &value));
246 EXPECT_STREQ(fwver1, value);
249 EXPECT_TRUE(OCRepPayloadGetPropString(platform1, OC_RSRVD_SUPPORT_URL, &value));
250 EXPECT_STREQ(url1, value);
253 EXPECT_TRUE(OCRepPayloadGetPropString(platform1, OC_RSRVD_SYSTEM_TIME, &value));
254 EXPECT_STREQ(time1, value);
257 EXPECT_TRUE(OCRepPayloadGetPropString(platform1, OC_RSRVD_VID, &value));
258 EXPECT_STREQ(vid1, value);
261 EXPECT_STREQ(platform1->types->value, OC_RSRVD_RESOURCE_TYPE_PLATFORM);
262 EXPECT_STREQ(platform1->interfaces->value, OC_RSRVD_INTERFACE_DEFAULT);
263 EXPECT_STREQ(platform1->interfaces->next->value, OC_RSRVD_INTERFACE_READ);
265 OC::MessageContainer mc;
266 mc.setPayload(parsedPlatform);
267 EXPECT_EQ(1u, mc.representations().size());
268 const OC::OCRepresentation& r = mc.representations()[0];
269 EXPECT_STREQ(pfid1, r.getValue<std::string>(OC_RSRVD_PLATFORM_ID).c_str());
270 EXPECT_STREQ(mfgnm1, r.getValue<std::string>(OC_RSRVD_MFG_NAME).c_str());
271 EXPECT_STREQ(mfgurl1, r.getValue<std::string>(OC_RSRVD_MFG_URL).c_str());
272 EXPECT_STREQ(modelnum1, r.getValue<std::string>(OC_RSRVD_MODEL_NUM).c_str());
273 EXPECT_STREQ(dom1, r.getValue<std::string>(OC_RSRVD_MFG_DATE).c_str());
274 EXPECT_STREQ(pfver1, r.getValue<std::string>(OC_RSRVD_PLATFORM_VERSION).c_str());
275 EXPECT_STREQ(osver1, r.getValue<std::string>(OC_RSRVD_OS_VERSION).c_str());
276 EXPECT_STREQ(hwver1, r.getValue<std::string>(OC_RSRVD_HARDWARE_VERSION).c_str());
277 EXPECT_STREQ(fwver1, r.getValue<std::string>(OC_RSRVD_FIRMWARE_VERSION).c_str());
278 EXPECT_STREQ(url1, r.getValue<std::string>(OC_RSRVD_SUPPORT_URL).c_str());
279 EXPECT_STREQ(time1, r.getValue<std::string>(OC_RSRVD_SYSTEM_TIME).c_str());
280 EXPECT_STREQ(vid1, r.getValue<std::string>(OC_RSRVD_VID).c_str());
282 OCPayloadDestroy((OCPayload *)platform);
283 OCPayloadDestroy((OCPayload *)platform1);
286 TEST(PresencePayload, Normal)
288 static const char uri1[] = "/testuri";
290 uint32_t sequenceNumber = 0;
291 OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE;
292 OCPresencePayload *presence = OCPresencePayloadCreate(sequenceNumber, maxAge, trigger, uri1);
297 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)presence, &cborData, &cborSize));
298 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_PRESENCE,
299 cborData, cborSize));
300 OCPayloadDestroy((OCPayload*)presence);
303 OCPresencePayload* parsed = ((OCPresencePayload*)cparsed);
304 EXPECT_EQ(sequenceNumber, parsed->sequenceNumber);
305 EXPECT_EQ(maxAge, parsed->maxAge);
306 EXPECT_EQ(trigger, parsed->trigger);
307 EXPECT_STREQ(uri1, parsed->resourceType);
309 OCPayloadDestroy(cparsed);
311 // Representation Payloads
312 TEST(RepresentationEncoding, BaseAttributeTypes)
314 OC::OCRepresentation startRep;
315 startRep.setNULL("NullAttr");
316 startRep.setValue("IntAttr", 77);
317 startRep.setValue("DoubleAttr", 3.333);
318 startRep.setValue("BoolAttr", true);
319 startRep.setValue("StringAttr", std::string("String attr"));
321 uint8_t binval[] = {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8,
322 0x9, 0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF
324 OCByteString byteString = {binval, sizeof(binval)};
325 startRep.setValue("ByteStringAttr", byteString);
327 OC::MessageContainer mc1;
328 mc1.addRepresentation(startRep);
330 OCRepPayload* cstart = mc1.getPayload();
331 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
336 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
337 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
338 cborData, cborSize));
339 OCPayloadDestroy((OCPayload*)cstart);
342 OC::MessageContainer mc2;
343 mc2.setPayload(cparsed);
344 EXPECT_EQ(1u, mc2.representations().size());
345 const OC::OCRepresentation& r = mc2.representations()[0];
347 EXPECT_TRUE(r.isNULL("NullAttr"));
348 EXPECT_EQ(77, r.getValue<int>("IntAttr"));
349 EXPECT_EQ(3.333, r.getValue<double>("DoubleAttr"));
350 EXPECT_EQ(true, r.getValue<bool>("BoolAttr"));
351 EXPECT_STREQ("String attr", r.getValue<std::string>("StringAttr").c_str());
352 const char *expectedByteString = "\\x1\\x2\\x3\\x4\\x5\\x6\\x7\\x8\\x9\\x0\\xa\\xb\\xc\\xd\\xe\\xf";
353 EXPECT_STREQ(expectedByteString, r.getValueToString("ByteStringAttr").c_str());
355 OCPayloadDestroy(cparsed);
358 TEST(RepresentationEncoding, RepAttributeEmpty)
360 OC::OCRepresentation startRep;
361 std::vector<int> iarr {};
362 std::vector<double> darr {};
363 std::vector<bool> barr {};
364 std::vector<std::string> strarr {};
365 std::vector<OC::OCRepresentation> objarr {};
366 std::vector<OCByteString> bytestrarr {{NULL, 0}};
367 startRep.setValue("StringAttr", std::string(""));
368 startRep["iarr"] = iarr;
369 startRep["darr"] = darr;
370 startRep["barr"] = barr;
371 startRep["strarr"] = strarr;
372 startRep["objarr"] = objarr;
373 startRep["bytestrarr"] = bytestrarr;
374 startRep.setValue("StringAttr2", std::string("String attr"));
376 OC::MessageContainer mc1;
377 mc1.addRepresentation(startRep);
378 OCRepPayload* cstart = mc1.getPayload();
379 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
381 uint8_t *cborData = NULL;
383 OCPayload *cparsed = NULL;
384 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
385 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
386 cborData, cborSize));
387 OCPayloadDestroy((OCPayload*)cstart);
390 OC::MessageContainer mc2;
391 mc2.setPayload(cparsed);
392 EXPECT_EQ(1u, mc2.representations().size());
393 const OC::OCRepresentation& r = mc2.representations()[0];
395 EXPECT_STREQ("", r.getValue<std::string>("StringAttr").c_str());
396 std::vector<int> iarr2 = r["iarr"];
397 EXPECT_EQ(iarr, iarr2);
398 std::vector<double> darr2 = r["darr"];
399 EXPECT_EQ(darr, darr2);
400 std::vector<bool> barr2 = r["barr"];
401 EXPECT_EQ(barr, barr2);
402 std::vector<std::string> strarr2 = r["strarr"];
403 EXPECT_EQ(strarr, strarr2);
404 std::vector<OC::OCRepresentation> objarr2 = r["objarr"];
405 EXPECT_EQ(objarr, objarr2);
406 std::vector<uint8_t> binAttr = r.getValue<std::vector<uint8_t>>("BinaryAttr");
407 EXPECT_EQ(bytestrarr[0].len, binAttr.size());
408 EXPECT_STREQ("String attr", r.getValue<std::string>("StringAttr2").c_str());
409 OIC_LOG_PAYLOAD(DEBUG, cparsed);
410 OCPayloadDestroy(cparsed);
413 TEST(RepresentationEncoding, RepAttribute)
415 OC::OCRepresentation startRep;
416 OC::OCRepresentation subRep;
417 subRep.setNULL("NullAttr");
418 subRep.setValue("IntAttr", 77);
419 subRep.setValue("DoubleAttr", 3.333);
420 subRep.setValue("BoolAttr", true);
421 subRep.setValue("StringAttr", std::string("String attr"));
422 std::vector<uint8_t> bin_data {5,3,4,5,6,0,34,2,4,5,6,3};
423 subRep.setValue("BinaryAttr", bin_data);
424 startRep.setValue("Sub", subRep);
426 OC::MessageContainer mc1;
427 mc1.addRepresentation(startRep);
429 OCRepPayload* cstart = mc1.getPayload();
430 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
434 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
436 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
437 cborData, cborSize));
438 OCPayloadDestroy((OCPayload*)cstart);
441 OC::MessageContainer mc2;
442 mc2.setPayload(cparsed);
443 EXPECT_EQ(1u, mc2.representations().size());
444 const OC::OCRepresentation& r = mc2.representations()[0];
446 OC::OCRepresentation newSubRep = r["Sub"];
448 EXPECT_TRUE(newSubRep.isNULL("NullAttr"));
449 EXPECT_EQ(77, newSubRep.getValue<int>("IntAttr"));
450 EXPECT_EQ(3.333, newSubRep.getValue<double>("DoubleAttr"));
451 EXPECT_EQ(true, newSubRep.getValue<bool>("BoolAttr"));
452 EXPECT_STREQ("String attr", newSubRep.getValue<std::string>("StringAttr").c_str());
454 newSubRep.getValue<std::vector<uint8_t>>("BinaryAttr"));
455 OCPayloadDestroy(cparsed);
458 TEST(RepresentationEncoding, OneDVectors)
461 OC::OCRepresentation startRep;
463 OC::OCRepresentation subRep1;
464 OC::OCRepresentation subRep2;
465 OC::OCRepresentation subRep3;
466 subRep1.setNULL("NullAttr");
467 subRep1.setValue("IntAttr", 77);
468 subRep2.setValue("DoubleAttr", 3.333);
469 subRep2.setValue("BoolAttr", true);
470 subRep3.setValue("StringAttr", std::string("String attr"));
472 std::vector<int> iarr {1,2,3,4,5,6,7,8,9};
473 std::vector<double> darr {1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9};
474 std::vector<bool> barr {false, true, false, false, true, true};
475 std::vector<std::string> strarr {"item1", "item2", "item3", "item4"};
476 std::vector<OC::OCRepresentation> objarr {subRep1, subRep2, subRep3};
478 uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8};
479 OCByteString byteStringRef1 {binval1, sizeof(binval1)};
480 OCByteString byteString1 {NULL,0};
481 EXPECT_TRUE(OCByteStringCopy(&byteString1, &byteStringRef1));
482 uint8_t binval2[] = {0x9, 0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF};
483 OCByteString byteStringRef2 {binval2, sizeof(binval2)};
484 OCByteString byteString2 {NULL,0};
485 EXPECT_TRUE(OCByteStringCopy(&byteString2, &byteStringRef2));
486 std::vector<OCByteString> bytestrarrRef {byteStringRef1, byteStringRef2 };
487 std::vector<OCByteString> bytestrarr {byteString1, byteString2 };
489 startRep["iarr"] = iarr;
490 startRep["darr"] = darr;
491 startRep["barr"] = barr;
492 startRep["strarr"] = strarr;
493 startRep["objarr"] = objarr;
494 startRep["bytestrarr"] = bytestrarr;
497 OC::MessageContainer mc1;
498 mc1.addRepresentation(startRep);
500 OCRepPayload* cstart = mc1.getPayload();
501 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
506 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload *)cstart, &cborData, &cborSize));
507 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
508 cborData, cborSize));
509 OCPayloadDestroy((OCPayload *)cstart);
512 OC::MessageContainer mc2;
513 mc2.setPayload(cparsed);
514 EXPECT_EQ(1u, mc2.representations().size());
515 const OC::OCRepresentation &r = mc2.representations()[0];
518 std::vector<int> iarr2 = r["iarr"];
519 std::vector<double> darr2 = r["darr"];
520 std::vector<bool> barr2 = r["barr"];
521 std::vector<std::string> strarr2 = r["strarr"];
522 std::vector<OC::OCRepresentation> objarr2 = r["objarr"];
523 std::vector<OCByteString> bytestrarr2 = r["bytestrarr"];
525 EXPECT_EQ(iarr, iarr2);
526 EXPECT_EQ(darr, darr2);
527 EXPECT_EQ(barr, barr2);
528 EXPECT_EQ(strarr, strarr2);
529 EXPECT_EQ(objarr, objarr2);
531 EXPECT_EQ(bytestrarrRef, bytestrarr2);
532 OCPayloadDestroy(cparsed);
535 TEST(RepresentationEncoding, TwoDVectors)
538 OC::OCRepresentation startRep;
540 OC::OCRepresentation subRep1;
541 OC::OCRepresentation subRep2;
542 OC::OCRepresentation subRep3;
543 subRep1.setNULL("NullAttr");
544 subRep1.setValue("IntAttr", 77);
545 subRep2.setValue("DoubleAttr", 3.333);
546 subRep2.setValue("BoolAttr", true);
547 subRep3.setValue("StringAttr", std::string("String attr"));
549 std::vector<std::vector<int>> iarr {{1,2,3},{4,5,6},{7,8,9}};
550 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{7.7,8.8,9.9}};
551 std::vector<std::vector<bool>> barr {{false, true}, {false, false}, {true, true}};
552 std::vector<std::vector<std::string>> strarr {{"item1", "item2"}, {"item3", "item4"}};
553 std::vector<std::vector<OC::OCRepresentation>> objarr
554 {{subRep1, subRep2, subRep3}, {subRep3, subRep2, subRep1}};
556 uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
557 OCByteString byteStringRef1 {binval1, sizeof(binval1) };
558 OCByteString byteString1 {NULL,0};
559 EXPECT_TRUE(OCByteStringCopy(&byteString1, &byteStringRef1));
560 uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
561 OCByteString byteStringRef2 {binval2, sizeof(binval2) };
562 OCByteString byteString2 {NULL,0};
563 EXPECT_TRUE(OCByteStringCopy(&byteString2, &byteStringRef2));
564 uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
565 OCByteString byteStringRef3 {binval3, sizeof(binval3) };
566 OCByteString byteString3 {NULL,0};
567 EXPECT_TRUE(OCByteStringCopy(&byteString3, &byteStringRef3));
568 uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
569 OCByteString byteStringRef4 {binval4, sizeof(binval4) };
570 OCByteString byteString4 {NULL,0};
571 EXPECT_TRUE(OCByteStringCopy(&byteString4, &byteStringRef4));
572 std::vector<std::vector<OCByteString>> bytestrarrRef
574 {byteStringRef1, byteStringRef2}, {byteStringRef3, byteStringRef4}
576 std::vector<std::vector<OCByteString>> bytestrarr
578 {byteString1, byteString2}, {byteString3, byteString4}
581 startRep["iarr"] = iarr;
582 startRep["darr"] = darr;
583 startRep["barr"] = barr;
584 startRep["strarr"] = strarr;
585 startRep["objarr"] = objarr;
586 startRep["bytestrarr"] = bytestrarr;
589 OC::MessageContainer mc1;
590 mc1.addRepresentation(startRep);
592 OCRepPayload *cstart = mc1.getPayload();
593 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
598 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload *)cstart, &cborData, &cborSize));
599 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
600 cborData, cborSize));
601 OCPayloadDestroy((OCPayload *)cstart);
604 OC::MessageContainer mc2;
605 mc2.setPayload(cparsed);
606 EXPECT_EQ(1u, mc2.representations().size());
607 const OC::OCRepresentation &r = mc2.representations()[0];
610 std::vector<std::vector<int>> iarr2 = r["iarr"];
611 std::vector<std::vector<double>> darr2 = r["darr"];
612 std::vector<std::vector<bool>> barr2 = r["barr"];
613 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
614 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
615 std::vector<std::vector<OCByteString>> bytestrarr2 = r["bytestrarr"];
617 EXPECT_EQ(iarr, iarr2);
618 EXPECT_EQ(darr, darr2);
619 EXPECT_EQ(barr, barr2);
620 EXPECT_EQ(strarr, strarr2);
621 EXPECT_EQ(objarr, objarr2);
623 EXPECT_EQ(bytestrarrRef, bytestrarr2);
625 OCPayloadDestroy(cparsed);
628 TEST(RepresentationEncoding, TwoDVectorsJagged)
631 OC::OCRepresentation startRep;
633 OC::OCRepresentation subRep1;
634 OC::OCRepresentation subRep2;
635 OC::OCRepresentation subRep3;
636 subRep1.setNULL("NullAttr");
637 subRep1.setValue("IntAttr", 77);
638 subRep2.setValue("DoubleAttr", 3.333);
639 subRep2.setValue("BoolAttr", true);
640 subRep3.setValue("StringAttr", std::string("String attr"));
642 std::vector<std::vector<int>> iarr {{1,2,3},{4,6},{7,8,9}};
643 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{8.8,9.9}};
644 std::vector<std::vector<bool>> barr {{false, true}, {false}, {true, true}};
645 std::vector<std::vector<std::string>> strarr {{"item1"}, {"item3", "item4"}};
646 std::vector<std::vector<OC::OCRepresentation>> objarr
647 {{subRep1, subRep3}, {subRep3, subRep2, subRep1}};
649 uint8_t binval1[] = {0x1};
650 OCByteString byteStringRef1 {binval1, sizeof(binval1) };
651 OCByteString byteString1 {NULL,0};
652 EXPECT_TRUE(OCByteStringCopy(&byteString1, &byteStringRef1));
653 uint8_t binval3[] = {0x2, 0x3, 0x4};
654 OCByteString byteStringRef3 {binval3, sizeof(binval3) };
655 OCByteString byteString3 {NULL,0};
656 EXPECT_TRUE(OCByteStringCopy(&byteString3, &byteStringRef3));
657 uint8_t binval4[] = {0x5, 0x6, 0x7, 0x8};
658 OCByteString byteStringRef4 {binval4, sizeof(binval4) };
659 OCByteString byteString4 {NULL,0};
660 EXPECT_TRUE(OCByteStringCopy(&byteString4, &byteStringRef4));
662 std::vector<std::vector<OCByteString>> bytestrarrRef
664 {byteStringRef1}, {byteStringRef3, byteStringRef4}
667 std::vector<std::vector<OCByteString>> bytestrarr
669 {byteString1}, {byteString3, byteString4}
672 startRep["iarr"] = iarr;
673 startRep["darr"] = darr;
674 startRep["barr"] = barr;
675 startRep["strarr"] = strarr;
676 startRep["objarr"] = objarr;
678 startRep["bytestrarr"] = bytestrarr;
680 EXPECT_STREQ("[[\\x1 ] [\\x2\\x3\\x4 \\x5\\x6\\x7\\x8 ] ]",
681 startRep.getValueToString("bytestrarr").c_str());
683 OC::MessageContainer mc1;
684 mc1.addRepresentation(startRep);
686 OCRepPayload *cstart = mc1.getPayload();
687 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
692 OCStackResult result = OCConvertPayload((OCPayload *)cstart, &cborData, &cborSize);
693 EXPECT_EQ(OC_STACK_OK, result);
694 result = OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
696 EXPECT_EQ(OC_STACK_OK, result);
698 OCPayloadDestroy((OCPayload *)cstart);
701 OC::MessageContainer mc2;
702 mc2.setPayload(cparsed);
703 EXPECT_EQ(1u, mc2.representations().size());
704 const OC::OCRepresentation &r = mc2.representations()[0];
707 std::vector<std::vector<int>> iarr2 = r["iarr"];
708 std::vector<std::vector<double>> darr2 = r["darr"];
709 std::vector<std::vector<bool>> barr2 = r["barr"];
710 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
711 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
713 std::vector<std::vector<OCByteString>> bytestrarr2 = r["bytestrarr"];
715 // Note: due to the way that the CSDK works, all 2d arrays need to be rectangular.
716 // Since std::vector doesn't require this, items received on the other side end up
717 // being backfilled. This section removes the backfilling
721 strarr2[0].pop_back();
722 objarr2[0].pop_back();
723 bytestrarr2[0].pop_back();
725 EXPECT_EQ(iarr, iarr2);
726 EXPECT_EQ(darr, darr2);
727 EXPECT_EQ(barr, barr2);
728 EXPECT_EQ(strarr, strarr2);
729 EXPECT_EQ(objarr, objarr2);
730 EXPECT_EQ(bytestrarr.size(), bytestrarr2.size());
731 EXPECT_EQ(bytestrarrRef, bytestrarr2);
733 OCPayloadDestroy(cparsed);
736 TEST(RepresentationEncoding, ThreeDVectors)
739 OC::OCRepresentation startRep;
741 OC::OCRepresentation subRep1;
742 OC::OCRepresentation subRep2;
743 OC::OCRepresentation subRep3;
744 subRep1.setNULL("NullAttr");
745 subRep1.setValue("IntAttr", 77);
746 subRep2.setValue("DoubleAttr", 3.333);
747 subRep2.setValue("BoolAttr", true);
748 subRep3.setValue("StringAttr", std::string("String attr"));
750 std::vector<std::vector<std::vector<int>>> iarr
751 {{{1,2,3},{4,5,6}},{{7,8,9},{10,11,12}},{{13,14,15},{16,17,18}}};
752 std::vector<std::vector<std::vector<double>>> darr
753 {{{1.1,2.2,3.3},{4.4,5.5,6.6}},
754 {{7.7,8.7,9.7},{10.7,11.7,12.7}},
755 {{13.7,14.7,15.7},{16.7,17.7,18.7}}};
756 std::vector<std::vector<std::vector<bool>>> barr
757 {{{false, true},{true, false}},{{false, true},{true, false}}};
758 std::vector<std::vector<std::vector<std::string>>> strarr
760 {{"item1", "item2"},{"item3", "item4"}},
761 {{"item5", "item6"},{"item7", "item8"}},
762 {{"item9", "item10"},{"item11", ""}}
764 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
766 {{subRep1, subRep2},{subRep3, subRep1}},
767 {{subRep2, subRep3},{subRep2, subRep1}},
768 {{subRep3, subRep2},{subRep1, subRep2}}
771 uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
772 OCByteString byteStringRef1 {binval1, sizeof(binval1)};
773 OCByteString byteString1 {NULL,0};
774 EXPECT_TRUE(OCByteStringCopy(&byteString1, &byteStringRef1));
775 uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
776 OCByteString byteStringRef2 {binval2, sizeof(binval2)};
777 OCByteString byteString2 {NULL,0};
778 EXPECT_TRUE(OCByteStringCopy(&byteString2, &byteStringRef2));
779 uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
780 OCByteString byteStringRef3 {binval3, sizeof(binval3)};
781 OCByteString byteString3 {NULL,0};
782 EXPECT_TRUE(OCByteStringCopy(&byteString3, &byteStringRef3));
783 uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
784 OCByteString byteStringRef4 {binval4, sizeof(binval4)};
785 OCByteString byteString4 {NULL,0};
786 EXPECT_TRUE(OCByteStringCopy(&byteString4, &byteStringRef4));
787 uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
788 OCByteString byteStringRef5 {binval5, sizeof(binval5)};
789 OCByteString byteString5 {NULL,0};
790 EXPECT_TRUE(OCByteStringCopy(&byteString5, &byteStringRef5));
791 uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
792 OCByteString byteStringRef6 {binval6, sizeof(binval6)};
793 OCByteString byteString6 {NULL,0};
794 EXPECT_TRUE(OCByteStringCopy(&byteString6, &byteStringRef6));
795 uint8_t binval7[] = {0x19, 0x10, 0x1A, 0x1B};
796 OCByteString byteStringRef7 {binval7, sizeof(binval7)};
797 OCByteString byteString7 {NULL,0};
798 EXPECT_TRUE(OCByteStringCopy(&byteString7, &byteStringRef7));
799 uint8_t binval8[] = {0x1C, 0x1D, 0x1E, 0x1F};
800 OCByteString byteStringRef8 {binval8, sizeof(binval8)};
801 OCByteString byteString8 {NULL,0};
802 EXPECT_TRUE(OCByteStringCopy(&byteString8, &byteStringRef8));
803 uint8_t binval9[] = {0x21, 0x22, 0x23, 0x24};
804 OCByteString byteStringRef9 {binval9, sizeof(binval9)};
805 OCByteString byteString9 {NULL,0};
806 EXPECT_TRUE(OCByteStringCopy(&byteString9, &byteStringRef9));
807 uint8_t binval10[] = {0x25, 0x26, 0x27, 0x28};
808 OCByteString byteStringRef10 {binval10, sizeof(binval10)};
809 OCByteString byteString10 {NULL,0};
810 EXPECT_TRUE(OCByteStringCopy(&byteString10, &byteStringRef10));
811 uint8_t binval11[] = {0x29, 0x20, 0x2A, 0x2B};
812 OCByteString byteStringRef11 {binval11, sizeof(binval11)};
813 OCByteString byteString11 {NULL,0};
814 EXPECT_TRUE(OCByteStringCopy(&byteString11, &byteStringRef11));
815 uint8_t binval12[] = {0xFF};
816 OCByteString byteStringRef12 {binval12, sizeof(binval12)};
817 OCByteString byteString12 {NULL,0};
818 EXPECT_TRUE(OCByteStringCopy(&byteString12, &byteStringRef12));
820 std::vector<std::vector<std::vector<OCByteString>>> bytestrarrRef
822 {{byteStringRef1, byteStringRef2}, {byteStringRef3, byteStringRef4}},
823 {{byteStringRef5, byteStringRef6}, {byteStringRef7, byteStringRef8}},
824 {{byteStringRef9, byteStringRef10}, {byteStringRef11, byteStringRef12}}
827 std::vector<std::vector<std::vector<OCByteString>>> bytestrarr
829 {{byteString1, byteString2}, {byteString3, byteString4}},
830 {{byteString5, byteString6}, {byteString7, byteString8}},
831 {{byteString9, byteString10}, {byteString11, byteString12}}
834 startRep["iarr"] = iarr;
835 startRep["darr"] = darr;
836 startRep["barr"] = barr;
837 startRep["strarr"] = strarr;
838 startRep["objarr"] = objarr;
839 startRep["bytestrarr"] = bytestrarr;
842 OC::MessageContainer mc1;
843 mc1.addRepresentation(startRep);
845 OCRepPayload *cstart = mc1.getPayload();
846 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
851 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload *)cstart, &cborData, &cborSize));
852 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
853 cborData, cborSize));
854 OCPayloadDestroy((OCPayload *)cstart);
857 OC::MessageContainer mc2;
858 mc2.setPayload(cparsed);
859 EXPECT_EQ(1u, mc2.representations().size());
860 const OC::OCRepresentation &r = mc2.representations()[0];
863 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
864 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
865 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
866 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
867 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
868 std::vector<std::vector<std::vector<OCByteString>>> bytestrarr2 = r["bytestrarr"];
870 EXPECT_EQ(iarr, iarr2);
871 EXPECT_EQ(darr, darr2);
872 EXPECT_EQ(barr, barr2);
873 EXPECT_EQ(strarr, strarr2);
874 EXPECT_EQ(objarr, objarr2);
875 EXPECT_EQ(bytestrarrRef, bytestrarr2);
876 OCPayloadDestroy(cparsed);
879 TEST(RepresentationEncoding, ThreeDVectorsJagged)
882 OC::OCRepresentation startRep;
884 OC::OCRepresentation subRep1;
885 OC::OCRepresentation subRep2;
886 OC::OCRepresentation subRep3;
887 subRep1.setNULL("NullAttr");
888 subRep1.setValue("IntAttr", 77);
889 subRep2.setValue("DoubleAttr", 3.333);
890 subRep2.setValue("BoolAttr", true);
891 subRep3.setValue("StringAttr", std::string("String attr"));
893 std::vector<std::vector<std::vector<int>>> iarr
897 {{13,14,15},{16,17,18}}
899 std::vector<std::vector<std::vector<double>>> darr
901 {{1.1,2.2,3.3},{4.4,5.5,6.6}},
902 {{7.7,8.7,9.7},{10.7,12.7}},
903 {{13.7,14.7,15.7},{16.7,17.7,18.7}}
905 std::vector<std::vector<std::vector<bool>>> barr
907 {{false, true},{true}},
908 {{false, true},{true, false}}
910 std::vector<std::vector<std::vector<std::string>>> strarr
912 {{"item1", "item2"},{"item3", "item4"}},
913 {{"item5", "item6"},{"item8"}},
914 {{"item9", "item10"},{"item11", ""}}
916 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
918 {{subRep1, subRep2},{subRep3, subRep1}},
919 {{subRep2, subRep3},{subRep2}},
923 uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
924 OCByteString byteStringRef1 {binval1, sizeof(binval1)};
925 OCByteString byteString1 {NULL,0};
926 EXPECT_TRUE(OCByteStringCopy(&byteString1, &byteStringRef1));
927 uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
928 OCByteString byteStringRef2 {binval2, sizeof(binval2)};
929 OCByteString byteString2 {NULL,0};
930 EXPECT_TRUE(OCByteStringCopy(&byteString2, &byteStringRef2));
931 uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
932 OCByteString byteStringRef3 {binval3, sizeof(binval3)};
933 OCByteString byteString3 {NULL,0};
934 EXPECT_TRUE(OCByteStringCopy(&byteString3, &byteStringRef3));
935 uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
936 OCByteString byteStringRef4 {binval4, sizeof(binval4)};
937 OCByteString byteString4 {NULL,0};
938 EXPECT_TRUE(OCByteStringCopy(&byteString4, &byteStringRef4));
939 uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
940 OCByteString byteStringRef5 {binval5, sizeof(binval5)};
941 OCByteString byteString5 {NULL,0};
942 EXPECT_TRUE(OCByteStringCopy(&byteString5, &byteStringRef5));
943 uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
944 OCByteString byteStringRef6 {binval6, sizeof(binval6)};
945 OCByteString byteString6 {NULL,0};
946 EXPECT_TRUE(OCByteStringCopy(&byteString6, &byteStringRef6));
947 uint8_t binval8[] = {0x1C, 0x1D, 0x1E, 0x1F};
948 OCByteString byteStringRef8 {binval8, sizeof(binval8)};
949 OCByteString byteString8 {NULL,0};
950 EXPECT_TRUE(OCByteStringCopy(&byteString8, &byteStringRef8));
951 uint8_t binval9[] = {0x21, 0x22, 0x23, 0x24};
952 OCByteString byteStringRef9 {binval9, sizeof(binval9)};
953 OCByteString byteString9 {NULL,0};
954 EXPECT_TRUE(OCByteStringCopy(&byteString9, &byteStringRef9));
955 uint8_t binval10[] = {0x25, 0x26, 0x27, 0x28};
956 OCByteString byteStringRef10 {binval10, sizeof(binval10)};
957 OCByteString byteString10 {NULL,0};
958 EXPECT_TRUE(OCByteStringCopy(&byteString10, &byteStringRef10));
959 uint8_t binval11[] = {0x29, 0x20, 0x2A, 0x2B};
960 OCByteString byteStringRef11 {binval11, sizeof(binval11)};
961 OCByteString byteString11 {NULL,0};
962 EXPECT_TRUE(OCByteStringCopy(&byteString11, &byteStringRef11));
963 uint8_t binval12[] = {0xFF};
964 OCByteString byteStringRef12 {binval12, sizeof(binval12)};
965 OCByteString byteString12 {NULL,0};
966 EXPECT_TRUE(OCByteStringCopy(&byteString12, &byteStringRef12));
968 std::vector<std::vector<std::vector<OCByteString>>> bytestrarrRef
970 {{byteStringRef1, byteStringRef2}, {byteStringRef3, byteStringRef4}},
971 {{byteStringRef5, byteStringRef6}, {byteStringRef8}},
972 {{byteStringRef9, byteStringRef10}, {byteStringRef11, byteStringRef12}}
975 std::vector<std::vector<std::vector<OCByteString>>> bytestrarr
977 {{byteString1, byteString2}, {byteString3, byteString4}},
978 {{byteString5, byteString6}, {byteString8}},
979 {{byteString9, byteString10}, {byteString11, byteString12}}
982 startRep["iarr"] = iarr;
983 startRep["darr"] = darr;
984 startRep["barr"] = barr;
985 startRep["strarr"] = strarr;
986 startRep["objarr"] = objarr;
987 startRep["bytestrarr"] = bytestrarr;
990 OC::MessageContainer mc1;
991 mc1.addRepresentation(startRep);
993 OCRepPayload *cstart = mc1.getPayload();
994 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
999 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload *)cstart, &cborData, &cborSize));
1000 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1001 cborData, cborSize));
1002 OCPayloadDestroy((OCPayload *)cstart);
1005 OC::MessageContainer mc2;
1006 mc2.setPayload(cparsed);
1007 EXPECT_EQ(1u, mc2.representations().size());
1008 const OC::OCRepresentation &r = mc2.representations()[0];
1011 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
1012 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
1013 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
1014 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
1015 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
1016 std::vector<std::vector<std::vector<OCByteString>>> bytestrarr2 = r["bytestrarr"];
1018 // Note: due to the way that the CSDK works, all 3d arrays need to be cuboidal.
1019 // Since std::vector doesn't require this, items received on the other side end up
1020 // being backfilled. This section removes the backfilling
1021 iarr2[1][1].pop_back();
1022 darr2[1][1].pop_back();
1023 barr2[0][1].pop_back();
1024 strarr2[1][1].pop_back();
1025 objarr2[1][1].pop_back();
1026 objarr2[2].pop_back();
1027 bytestrarr2[1][1].pop_back();
1029 EXPECT_EQ(iarr, iarr2);
1030 EXPECT_EQ(darr, darr2);
1031 EXPECT_EQ(barr, barr2);
1032 EXPECT_EQ(strarr, strarr2);
1033 EXPECT_EQ(objarr, objarr2);
1034 EXPECT_EQ(bytestrarrRef, bytestrarr2);
1035 OCPayloadDestroy(cparsed);
1038 TEST(DiscoveryRTandIF, SingleItemNormal)
1040 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1041 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1042 payload->sid = OICStrdup(sid1);
1043 payload->resources = resource;
1045 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem"));
1046 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem"));
1048 resource->uri = OICStrdup("/uri/thing");
1054 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1055 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1056 cborData, cborSize));
1058 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1059 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1061 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1062 EXPECT_EQ(NULL, parsedResource->next);
1063 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
1064 EXPECT_EQ(NULL, parsedResource->types->next);
1065 EXPECT_EQ(NULL, parsedResource->interfaces->next);
1066 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
1069 OCPayloadDestroy(cparsed);
1070 OCDiscoveryPayloadDestroy(payload);
1073 TEST(DiscoveryRTandIF, SingleItemFrontTrim)
1075 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1076 payload->sid = OICStrdup(sid1);
1077 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1078 payload->resources = resource;
1080 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, " rt.singleitem"));
1081 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, " if.singleitem"));
1082 resource->uri = OICStrdup("/uri/thing");
1088 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1089 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1090 cborData, cborSize));
1092 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1093 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1095 EXPECT_EQ(NULL, parsedResource->next);
1096 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1097 EXPECT_EQ(NULL, parsedResource->types->next);
1098 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
1099 EXPECT_EQ(NULL, parsedResource->interfaces->next);
1100 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
1103 OCPayloadDestroy(cparsed);
1104 OCDiscoveryPayloadDestroy(payload);
1107 TEST(DiscoveryRTandIF, SingleItemBackTrim)
1109 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1110 payload->sid = OICStrdup(sid1);
1111 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1112 payload->resources = resource;
1114 OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem ");
1115 OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem ");
1116 resource->uri = OICStrdup("/uri/thing");
1122 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1123 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1124 cborData, cborSize));
1126 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1127 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1129 EXPECT_EQ(NULL, parsedResource->next);
1130 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1131 EXPECT_EQ(NULL, parsedResource->types->next);
1132 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
1133 EXPECT_EQ(NULL, parsedResource->interfaces->next);
1134 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
1137 OCPayloadDestroy(cparsed);
1138 OCDiscoveryPayloadDestroy(payload);
1140 TEST(DiscoveryRTandIF, SingleItemBothTrim)
1142 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1143 payload->sid = OICStrdup(sid1);
1144 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1145 payload->resources = resource;
1147 OCResourcePayloadAddStringLL(&resource->types, " rt.singleitem ");
1148 OCResourcePayloadAddStringLL(&resource->interfaces, " if.singleitem ");
1149 resource->uri = OICStrdup("/uri/thing");
1155 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1156 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1157 cborData, cborSize));
1159 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1160 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1162 EXPECT_EQ(NULL, parsedResource->next);
1163 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1164 EXPECT_EQ(NULL, parsedResource->types->next);
1165 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
1166 EXPECT_EQ(NULL, parsedResource->interfaces->next);
1167 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
1170 OCPayloadDestroy(cparsed);
1171 OCDiscoveryPayloadDestroy(payload);
1173 TEST(DiscoveryRTandIF, MultiItemsNormal)
1175 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1176 payload->sid = OICStrdup(sid1);
1177 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1178 payload->resources = resource;
1180 OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem");
1181 OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem");
1182 OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem");
1183 OCResourcePayloadAddStringLL(&resource->interfaces, "if.seconditem");
1184 resource->uri = OICStrdup("/uri/thing");
1190 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1191 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1192 cborData, cborSize));
1194 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1195 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1197 EXPECT_EQ(NULL, parsedResource->next);
1198 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1199 EXPECT_EQ(NULL, parsedResource->types->next->next);
1200 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
1201 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
1202 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
1203 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
1204 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
1207 OCPayloadDestroy(cparsed);
1208 OCDiscoveryPayloadDestroy(payload);
1210 TEST(DiscoveryRTandIF, MultiItemExtraLeadSpaces)
1212 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1213 payload->sid = OICStrdup(sid1);
1214 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1215 payload->resources = resource;
1217 OCResourcePayloadAddStringLL(&resource->types, " rt.firstitem");
1218 OCResourcePayloadAddStringLL(&resource->types, " rt.seconditem");
1219 OCResourcePayloadAddStringLL(&resource->interfaces, " if.firstitem");
1220 OCResourcePayloadAddStringLL(&resource->interfaces, " if.seconditem");
1221 resource->uri = OICStrdup("/uri/thing");
1227 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1228 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1229 cborData, cborSize));
1231 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1232 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1234 EXPECT_EQ(NULL, parsedResource->next);
1235 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1236 EXPECT_EQ(NULL, parsedResource->types->next->next);
1237 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
1238 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
1239 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
1240 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
1241 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
1244 OCPayloadDestroy(cparsed);
1245 OCDiscoveryPayloadDestroy(payload);
1247 TEST(DiscoveryRTandIF, MultiItemExtraTrailSpaces)
1249 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1250 payload->sid = OICStrdup(sid1);
1251 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1252 payload->resources = resource;
1254 OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem ");
1255 OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem ");
1256 OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem ");
1257 OCResourcePayloadAddStringLL(&resource->interfaces, "if.seconditem ");
1258 resource->uri = OICStrdup("/uri/thing");
1264 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1265 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1266 cborData, cborSize));
1268 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1269 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1271 EXPECT_EQ(NULL, parsedResource->next);
1272 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1273 EXPECT_EQ(NULL, parsedResource->types->next->next);
1274 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
1275 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
1276 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
1277 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
1278 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
1281 OCPayloadDestroy(cparsed);
1282 OCDiscoveryPayloadDestroy(payload);
1284 TEST(DiscoveryRTandIF, MultiItemBothSpaces)
1286 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1287 payload->sid = OICStrdup(sid1);
1288 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1289 payload->resources = resource;
1291 OCResourcePayloadAddStringLL(&resource->types, " rt.firstitem ");
1292 OCResourcePayloadAddStringLL(&resource->types, " rt.seconditem ");
1293 OCResourcePayloadAddStringLL(&resource->interfaces, " if.firstitem ");
1294 OCResourcePayloadAddStringLL(&resource->interfaces, " if.seconditem ");
1295 resource->uri = OICStrdup("/uri/thing");
1301 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1302 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1303 cborData, cborSize));
1305 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1306 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1308 EXPECT_EQ(NULL, parsedResource->next);
1309 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1310 EXPECT_EQ(NULL, parsedResource->types->next->next);
1311 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
1312 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
1313 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
1314 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
1315 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
1318 OCPayloadDestroy(cparsed);
1319 OCDiscoveryPayloadDestroy(payload);
1321 TEST(RepresentationEncodingRTandIF, SingleItemNormal)
1323 OCRepPayload* payload = OCRepPayloadCreate();
1324 OCRepPayloadAddResourceType(payload, "rt.firstitem");
1325 OCRepPayloadAddInterface(payload, "if.firstitem");
1331 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1332 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1333 cborData, cborSize));
1335 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1337 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1338 EXPECT_EQ(NULL, parsedPayload->types->next);
1339 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1340 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1343 OCRepPayloadDestroy(payload);
1344 OCPayloadDestroy(cparsed);
1346 TEST(RepresentationEncodingRTandIF, SingleItemFrontTrim)
1348 OCRepPayload* payload = OCRepPayloadCreate();
1349 OCRepPayloadAddResourceType(payload, " rt.firstitem");
1350 OCRepPayloadAddInterface(payload, " if.firstitem");
1356 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1357 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1358 cborData, cborSize));
1360 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1362 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1363 EXPECT_EQ(NULL, parsedPayload->types->next);
1364 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1365 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1369 OCRepPayloadDestroy(payload);
1370 OCPayloadDestroy(cparsed);
1372 TEST(RepresentationEncodingRTandIF, SingleItemBackTrim)
1374 OCRepPayload* payload = OCRepPayloadCreate();
1375 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
1376 OCRepPayloadAddInterface(payload, "if.firstitem ");
1382 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1383 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1384 cborData, cborSize));
1386 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1388 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1389 EXPECT_EQ(NULL, parsedPayload->types->next);
1390 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1391 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1395 OCRepPayloadDestroy(payload);
1396 OCPayloadDestroy(cparsed);
1398 TEST(RepresentationEncodingRTandIF, SingleItemBothTrim)
1400 OCRepPayload* payload = OCRepPayloadCreate();
1401 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1402 OCRepPayloadAddInterface(payload, " if.firstitem ");
1408 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1409 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1410 cborData, cborSize));
1412 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1414 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1415 EXPECT_EQ(NULL, parsedPayload->types->next);
1416 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1417 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1421 OCRepPayloadDestroy(payload);
1422 OCPayloadDestroy(cparsed);
1424 TEST(RepresentationEncodingRTandIF, MultiItemsNormal)
1426 OCRepPayload* payload = OCRepPayloadCreate();
1427 OCRepPayloadAddResourceType(payload, "rt.firstitem");
1428 OCRepPayloadAddResourceType(payload, "rt.seconditem");
1429 OCRepPayloadAddInterface(payload, "if.firstitem");
1430 OCRepPayloadAddInterface(payload, "if.seconditem");
1436 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1437 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1438 cborData, cborSize));
1440 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1442 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1443 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1444 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1445 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1446 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1447 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1451 OCRepPayloadDestroy(payload);
1452 OCPayloadDestroy(cparsed);
1454 TEST(RepresentationEncodingRTandIF, MultiItemExtraLeadSpaces)
1456 OCRepPayload* payload = OCRepPayloadCreate();
1457 OCRepPayloadAddResourceType(payload, " rt.firstitem");
1458 OCRepPayloadAddResourceType(payload, " rt.seconditem");
1459 OCRepPayloadAddInterface(payload, " if.firstitem");
1460 OCRepPayloadAddInterface(payload, " if.seconditem");
1466 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1467 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1468 cborData, cborSize));
1470 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1472 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1473 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1474 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1475 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1476 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1477 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1481 OCRepPayloadDestroy(payload);
1482 OCPayloadDestroy(cparsed);
1484 TEST(RepresentationEncodingRTandIF, MultiItemExtraTrailSpaces)
1486 OCRepPayload* payload = OCRepPayloadCreate();
1487 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
1488 OCRepPayloadAddResourceType(payload, "rt.seconditem ");
1489 OCRepPayloadAddInterface(payload, "if.firstitem ");
1490 OCRepPayloadAddInterface(payload, "if.seconditem ");
1496 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1497 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1498 cborData, cborSize));
1500 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1502 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1503 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1504 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1505 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1506 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1507 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1511 OCRepPayloadDestroy(payload);
1512 OCPayloadDestroy(cparsed);
1514 TEST(RepresentationEncodingRTandIF, MultiItemExtraMiddleSpaces)
1516 OCRepPayload* payload = OCRepPayloadCreate();
1517 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1518 OCRepPayloadAddResourceType(payload, " rt.seconditem ");
1519 OCRepPayloadAddInterface(payload, " if.firstitem ");
1520 OCRepPayloadAddInterface(payload, " if.seconditem ");
1526 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1527 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1528 cborData, cborSize));
1530 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1532 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1533 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1534 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1535 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1536 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1537 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1541 OCRepPayloadDestroy(payload);
1542 OCPayloadDestroy(cparsed);
1544 TEST(RepresentationEncodingRTandIF, TestPayloadContents)
1546 OC::OCRepresentation subRep1;
1547 std::vector<std::string> types;
1548 types.push_back("rt.firstitem");
1549 std::vector<std::string> interfaces;
1550 interfaces.push_back("if.firstitem");
1551 subRep1.setResourceTypes(types);
1552 subRep1.setResourceInterfaces(interfaces);
1553 subRep1.setNULL("NullAttr");
1554 subRep1.setValue("IntAttr", 77);
1555 subRep1.setValue("DoubleAttr", 3.333);
1556 subRep1.setValue("BoolAttr", true);
1557 subRep1.setValue("StringAttr", std::string("String attr"));
1559 OC::MessageContainer mc1;
1560 mc1.addRepresentation(subRep1);
1562 OCRepPayload *repPayload = mc1.getPayload();
1563 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, repPayload->base.type);
1565 uint8_t *cborData = NULL;
1566 size_t cborSize = 0;
1567 OCPayload *cparsed = NULL;
1569 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)repPayload, &cborData, &cborSize));
1570 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1571 cborData, cborSize));
1573 OCRepPayload *parsedPayload = (OCRepPayload *)cparsed;
1574 EXPECT_EQ(NULL, parsedPayload->uri);
1575 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1576 EXPECT_EQ(NULL, parsedPayload->types->next);
1577 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1578 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1580 // To make sure rt and if are not duplicated.
1581 EXPECT_STREQ("BoolAttr", parsedPayload->values->name);
1582 EXPECT_EQ(true, parsedPayload->values->b);
1583 EXPECT_EQ(OCREP_PROP_BOOL, parsedPayload->values->type);
1584 parsedPayload->values = parsedPayload->values->next;
1586 EXPECT_STREQ("DoubleAttr", parsedPayload->values->name);
1587 EXPECT_EQ(OCREP_PROP_DOUBLE, parsedPayload->values->type);
1588 EXPECT_EQ(3.3330000000000002, parsedPayload->values->d);
1589 parsedPayload->values = parsedPayload->values->next;
1591 EXPECT_STREQ("IntAttr", parsedPayload->values->name);
1592 EXPECT_EQ(77, parsedPayload->values->i);
1593 EXPECT_EQ(OCREP_PROP_INT, parsedPayload->values->type);
1594 parsedPayload->values = parsedPayload->values->next;
1596 EXPECT_STREQ("NullAttr", parsedPayload->values->name);
1597 EXPECT_EQ(OCREP_PROP_NULL, parsedPayload->values->type);
1598 parsedPayload->values = parsedPayload->values->next;
1600 EXPECT_STREQ("StringAttr", parsedPayload->values->name);
1601 EXPECT_STREQ("String attr", parsedPayload->values->str);
1602 EXPECT_EQ(OCREP_PROP_STRING, parsedPayload->values->type);
1603 parsedPayload->values = parsedPayload->values->next;
1605 EXPECT_EQ(NULL, parsedPayload->values);
1608 OCRepPayloadDestroy(repPayload);
1609 OCPayloadDestroy(cparsed);