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);
287 TEST(PresencePayload, Normal)
289 static const char uri1[] = "/testuri";
291 uint32_t sequenceNumber = 0;
292 OCPresenceTrigger trigger = OC_PRESENCE_TRIGGER_CREATE;
293 OCPresencePayload *presence = OCPresencePayloadCreate(sequenceNumber, maxAge, trigger, uri1);
298 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)presence, &cborData, &cborSize));
299 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_PRESENCE,
300 cborData, cborSize));
301 OCPayloadDestroy((OCPayload*)presence);
304 OCPresencePayload* parsed = ((OCPresencePayload*)cparsed);
305 EXPECT_EQ(sequenceNumber, parsed->sequenceNumber);
306 EXPECT_EQ(maxAge, parsed->maxAge);
307 EXPECT_EQ(trigger, parsed->trigger);
308 EXPECT_STREQ(uri1, parsed->resourceType);
310 OCPayloadDestroy(cparsed);
313 // Representation Payloads
314 TEST(RepresentationEncoding, BaseAttributeTypes)
316 OC::OCRepresentation startRep;
317 startRep.setNULL("NullAttr");
318 startRep.setValue("IntAttr", 77);
319 startRep.setValue("DoubleAttr", 3.333);
320 startRep.setValue("BoolAttr", true);
321 startRep.setValue("StringAttr", std::string("String attr"));
323 uint8_t binval[] = {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8,
324 0x9, 0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF
326 OCByteString byteString = {binval, sizeof(binval)};
327 startRep.setValue("ByteStringAttr", byteString);
329 OC::MessageContainer mc1;
330 mc1.addRepresentation(startRep);
332 OCRepPayload* cstart = mc1.getPayload();
333 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
338 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
339 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
340 cborData, cborSize));
341 OCPayloadDestroy((OCPayload*)cstart);
344 OC::MessageContainer mc2;
345 mc2.setPayload(cparsed);
346 EXPECT_EQ(1u, mc2.representations().size());
347 const OC::OCRepresentation& r = mc2.representations()[0];
349 EXPECT_TRUE(r.isNULL("NullAttr"));
350 EXPECT_EQ(77, r.getValue<int>("IntAttr"));
351 EXPECT_EQ(3.333, r.getValue<double>("DoubleAttr"));
352 EXPECT_EQ(true, r.getValue<bool>("BoolAttr"));
353 EXPECT_STREQ("String attr", r.getValue<std::string>("StringAttr").c_str());
354 const char *expectedByteString = "\\x1\\x2\\x3\\x4\\x5\\x6\\x7\\x8\\x9\\x0\\xa\\xb\\xc\\xd\\xe\\xf";
355 EXPECT_STREQ(expectedByteString, r.getValueToString("ByteStringAttr").c_str());
357 OCPayloadDestroy(cparsed);
360 TEST(RepresentationEncoding, RepAttributeEmpty)
362 OC::OCRepresentation startRep;
363 std::vector<int> iarr {};
364 std::vector<double> darr {};
365 std::vector<bool> barr {};
366 std::vector<std::string> strarr {};
367 std::vector<OC::OCRepresentation> objarr {};
368 std::vector<OCByteString> bytestrarr {{NULL, 0}};
369 startRep.setValue("StringAttr", std::string(""));
370 startRep["iarr"] = iarr;
371 startRep["darr"] = darr;
372 startRep["barr"] = barr;
373 startRep["strarr"] = strarr;
374 startRep["objarr"] = objarr;
375 startRep["bytestrarr"] = bytestrarr;
376 startRep.setValue("StringAttr2", std::string("String attr"));
378 OC::MessageContainer mc1;
379 mc1.addRepresentation(startRep);
380 OCRepPayload* cstart = mc1.getPayload();
381 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
383 uint8_t *cborData = NULL;
385 OCPayload *cparsed = NULL;
386 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
387 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
388 cborData, cborSize));
389 OCPayloadDestroy((OCPayload*)cstart);
392 OC::MessageContainer mc2;
393 mc2.setPayload(cparsed);
394 EXPECT_EQ(1u, mc2.representations().size());
395 const OC::OCRepresentation& r = mc2.representations()[0];
397 EXPECT_STREQ("", r.getValue<std::string>("StringAttr").c_str());
398 std::vector<int> iarr2 = r["iarr"];
399 EXPECT_EQ(iarr, iarr2);
400 std::vector<double> darr2 = r["darr"];
401 EXPECT_EQ(darr, darr2);
402 std::vector<bool> barr2 = r["barr"];
403 EXPECT_EQ(barr, barr2);
404 std::vector<std::string> strarr2 = r["strarr"];
405 EXPECT_EQ(strarr, strarr2);
406 std::vector<OC::OCRepresentation> objarr2 = r["objarr"];
407 EXPECT_EQ(objarr, objarr2);
408 std::vector<uint8_t> binAttr = r.getValue<std::vector<uint8_t>>("BinaryAttr");
409 EXPECT_EQ(bytestrarr[0].len, binAttr.size());
410 EXPECT_STREQ("String attr", r.getValue<std::string>("StringAttr2").c_str());
411 OIC_LOG_PAYLOAD(DEBUG, cparsed);
412 OCPayloadDestroy(cparsed);
415 TEST(RepresentationEncoding, RepAttribute)
417 OC::OCRepresentation startRep;
418 OC::OCRepresentation subRep;
419 subRep.setNULL("NullAttr");
420 subRep.setValue("IntAttr", 77);
421 subRep.setValue("DoubleAttr", 3.333);
422 subRep.setValue("BoolAttr", true);
423 subRep.setValue("StringAttr", std::string("String attr"));
424 std::vector<uint8_t> bin_data {5,3,4,5,6,0,34,2,4,5,6,3};
425 subRep.setValue("BinaryAttr", bin_data);
426 startRep.setValue("Sub", subRep);
428 OC::MessageContainer mc1;
429 mc1.addRepresentation(startRep);
431 OCRepPayload* cstart = mc1.getPayload();
432 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
436 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)cstart, &cborData, &cborSize));
438 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
439 cborData, cborSize));
440 OCPayloadDestroy((OCPayload*)cstart);
443 OC::MessageContainer mc2;
444 mc2.setPayload(cparsed);
445 EXPECT_EQ(1u, mc2.representations().size());
446 const OC::OCRepresentation& r = mc2.representations()[0];
448 OC::OCRepresentation newSubRep = r["Sub"];
450 EXPECT_TRUE(newSubRep.isNULL("NullAttr"));
451 EXPECT_EQ(77, newSubRep.getValue<int>("IntAttr"));
452 EXPECT_EQ(3.333, newSubRep.getValue<double>("DoubleAttr"));
453 EXPECT_EQ(true, newSubRep.getValue<bool>("BoolAttr"));
454 EXPECT_STREQ("String attr", newSubRep.getValue<std::string>("StringAttr").c_str());
456 newSubRep.getValue<std::vector<uint8_t>>("BinaryAttr"));
457 OCPayloadDestroy(cparsed);
460 TEST(RepresentationEncoding, OneDVectors)
463 OC::OCRepresentation startRep;
465 OC::OCRepresentation subRep1;
466 OC::OCRepresentation subRep2;
467 OC::OCRepresentation subRep3;
468 subRep1.setNULL("NullAttr");
469 subRep1.setValue("IntAttr", 77);
470 subRep2.setValue("DoubleAttr", 3.333);
471 subRep2.setValue("BoolAttr", true);
472 subRep3.setValue("StringAttr", std::string("String attr"));
474 std::vector<int> iarr {1,2,3,4,5,6,7,8,9};
475 std::vector<double> darr {1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9};
476 std::vector<bool> barr {false, true, false, false, true, true};
477 std::vector<std::string> strarr {"item1", "item2", "item3", "item4"};
478 std::vector<OC::OCRepresentation> objarr {subRep1, subRep2, subRep3};
480 uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8};
481 OCByteString byteStringRef1 {binval1, sizeof(binval1)};
482 OCByteString byteString1 {NULL,0};
483 EXPECT_TRUE(OCByteStringCopy(&byteString1, &byteStringRef1));
484 uint8_t binval2[] = {0x9, 0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF};
485 OCByteString byteStringRef2 {binval2, sizeof(binval2)};
486 OCByteString byteString2 {NULL,0};
487 EXPECT_TRUE(OCByteStringCopy(&byteString2, &byteStringRef2));
488 std::vector<OCByteString> bytestrarrRef {byteStringRef1, byteStringRef2 };
489 std::vector<OCByteString> bytestrarr {byteString1, byteString2 };
491 startRep["iarr"] = iarr;
492 startRep["darr"] = darr;
493 startRep["barr"] = barr;
494 startRep["strarr"] = strarr;
495 startRep["objarr"] = objarr;
496 startRep["bytestrarr"] = bytestrarr;
499 OC::MessageContainer mc1;
500 mc1.addRepresentation(startRep);
502 OCRepPayload* cstart = mc1.getPayload();
503 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
508 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload *)cstart, &cborData, &cborSize));
509 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
510 cborData, cborSize));
511 OCPayloadDestroy((OCPayload *)cstart);
514 OC::MessageContainer mc2;
515 mc2.setPayload(cparsed);
516 EXPECT_EQ(1u, mc2.representations().size());
517 const OC::OCRepresentation &r = mc2.representations()[0];
520 std::vector<int> iarr2 = r["iarr"];
521 std::vector<double> darr2 = r["darr"];
522 std::vector<bool> barr2 = r["barr"];
523 std::vector<std::string> strarr2 = r["strarr"];
524 std::vector<OC::OCRepresentation> objarr2 = r["objarr"];
525 std::vector<OCByteString> bytestrarr2 = r["bytestrarr"];
527 EXPECT_EQ(iarr, iarr2);
528 EXPECT_EQ(darr, darr2);
529 EXPECT_EQ(barr, barr2);
530 EXPECT_EQ(strarr, strarr2);
531 EXPECT_EQ(objarr, objarr2);
533 EXPECT_EQ(bytestrarrRef, bytestrarr2);
534 OCPayloadDestroy(cparsed);
537 TEST(RepresentationEncoding, TwoDVectors)
540 OC::OCRepresentation startRep;
542 OC::OCRepresentation subRep1;
543 OC::OCRepresentation subRep2;
544 OC::OCRepresentation subRep3;
545 subRep1.setNULL("NullAttr");
546 subRep1.setValue("IntAttr", 77);
547 subRep2.setValue("DoubleAttr", 3.333);
548 subRep2.setValue("BoolAttr", true);
549 subRep3.setValue("StringAttr", std::string("String attr"));
551 std::vector<std::vector<int>> iarr {{1,2,3},{4,5,6},{7,8,9}};
552 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{7.7,8.8,9.9}};
553 std::vector<std::vector<bool>> barr {{false, true}, {false, false}, {true, true}};
554 std::vector<std::vector<std::string>> strarr {{"item1", "item2"}, {"item3", "item4"}};
555 std::vector<std::vector<OC::OCRepresentation>> objarr
556 {{subRep1, subRep2, subRep3}, {subRep3, subRep2, subRep1}};
558 uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
559 OCByteString byteStringRef1 {binval1, sizeof(binval1) };
560 OCByteString byteString1 {NULL,0};
561 EXPECT_TRUE(OCByteStringCopy(&byteString1, &byteStringRef1));
562 uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
563 OCByteString byteStringRef2 {binval2, sizeof(binval2) };
564 OCByteString byteString2 {NULL,0};
565 EXPECT_TRUE(OCByteStringCopy(&byteString2, &byteStringRef2));
566 uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
567 OCByteString byteStringRef3 {binval3, sizeof(binval3) };
568 OCByteString byteString3 {NULL,0};
569 EXPECT_TRUE(OCByteStringCopy(&byteString3, &byteStringRef3));
570 uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
571 OCByteString byteStringRef4 {binval4, sizeof(binval4) };
572 OCByteString byteString4 {NULL,0};
573 EXPECT_TRUE(OCByteStringCopy(&byteString4, &byteStringRef4));
574 std::vector<std::vector<OCByteString>> bytestrarrRef
576 {byteStringRef1, byteStringRef2}, {byteStringRef3, byteStringRef4}
578 std::vector<std::vector<OCByteString>> bytestrarr
580 {byteString1, byteString2}, {byteString3, byteString4}
583 startRep["iarr"] = iarr;
584 startRep["darr"] = darr;
585 startRep["barr"] = barr;
586 startRep["strarr"] = strarr;
587 startRep["objarr"] = objarr;
588 startRep["bytestrarr"] = bytestrarr;
591 OC::MessageContainer mc1;
592 mc1.addRepresentation(startRep);
594 OCRepPayload *cstart = mc1.getPayload();
595 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
600 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload *)cstart, &cborData, &cborSize));
601 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
602 cborData, cborSize));
603 OCPayloadDestroy((OCPayload *)cstart);
606 OC::MessageContainer mc2;
607 mc2.setPayload(cparsed);
608 EXPECT_EQ(1u, mc2.representations().size());
609 const OC::OCRepresentation &r = mc2.representations()[0];
612 std::vector<std::vector<int>> iarr2 = r["iarr"];
613 std::vector<std::vector<double>> darr2 = r["darr"];
614 std::vector<std::vector<bool>> barr2 = r["barr"];
615 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
616 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
617 std::vector<std::vector<OCByteString>> bytestrarr2 = r["bytestrarr"];
619 EXPECT_EQ(iarr, iarr2);
620 EXPECT_EQ(darr, darr2);
621 EXPECT_EQ(barr, barr2);
622 EXPECT_EQ(strarr, strarr2);
623 EXPECT_EQ(objarr, objarr2);
625 EXPECT_EQ(bytestrarrRef, bytestrarr2);
627 OCPayloadDestroy(cparsed);
630 TEST(RepresentationEncoding, TwoDVectorsJagged)
633 OC::OCRepresentation startRep;
635 OC::OCRepresentation subRep1;
636 OC::OCRepresentation subRep2;
637 OC::OCRepresentation subRep3;
638 subRep1.setNULL("NullAttr");
639 subRep1.setValue("IntAttr", 77);
640 subRep2.setValue("DoubleAttr", 3.333);
641 subRep2.setValue("BoolAttr", true);
642 subRep3.setValue("StringAttr", std::string("String attr"));
644 std::vector<std::vector<int>> iarr {{1,2,3},{4,6},{7,8,9}};
645 std::vector<std::vector<double>> darr {{1.1,2.2,3.3},{4.4,5.5,6.6},{8.8,9.9}};
646 std::vector<std::vector<bool>> barr {{false, true}, {false}, {true, true}};
647 std::vector<std::vector<std::string>> strarr {{"item1"}, {"item3", "item4"}};
648 std::vector<std::vector<OC::OCRepresentation>> objarr
649 {{subRep1, subRep3}, {subRep3, subRep2, subRep1}};
651 uint8_t binval1[] = {0x1};
652 OCByteString byteStringRef1 {binval1, sizeof(binval1) };
653 OCByteString byteString1 {NULL,0};
654 EXPECT_TRUE(OCByteStringCopy(&byteString1, &byteStringRef1));
655 uint8_t binval3[] = {0x2, 0x3, 0x4};
656 OCByteString byteStringRef3 {binval3, sizeof(binval3) };
657 OCByteString byteString3 {NULL,0};
658 EXPECT_TRUE(OCByteStringCopy(&byteString3, &byteStringRef3));
659 uint8_t binval4[] = {0x5, 0x6, 0x7, 0x8};
660 OCByteString byteStringRef4 {binval4, sizeof(binval4) };
661 OCByteString byteString4 {NULL,0};
662 EXPECT_TRUE(OCByteStringCopy(&byteString4, &byteStringRef4));
664 std::vector<std::vector<OCByteString>> bytestrarrRef
666 {byteStringRef1}, {byteStringRef3, byteStringRef4}
669 std::vector<std::vector<OCByteString>> bytestrarr
671 {byteString1}, {byteString3, byteString4}
674 startRep["iarr"] = iarr;
675 startRep["darr"] = darr;
676 startRep["barr"] = barr;
677 startRep["strarr"] = strarr;
678 startRep["objarr"] = objarr;
680 startRep["bytestrarr"] = bytestrarr;
682 EXPECT_STREQ("[[\\x1 ] [\\x2\\x3\\x4 \\x5\\x6\\x7\\x8 ] ]",
683 startRep.getValueToString("bytestrarr").c_str());
685 OC::MessageContainer mc1;
686 mc1.addRepresentation(startRep);
688 OCRepPayload *cstart = mc1.getPayload();
689 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
694 OCStackResult result = OCConvertPayload((OCPayload *)cstart, &cborData, &cborSize);
695 EXPECT_EQ(OC_STACK_OK, result);
696 result = OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
698 EXPECT_EQ(OC_STACK_OK, result);
700 OCPayloadDestroy((OCPayload *)cstart);
703 OC::MessageContainer mc2;
704 mc2.setPayload(cparsed);
705 EXPECT_EQ(1u, mc2.representations().size());
706 const OC::OCRepresentation &r = mc2.representations()[0];
709 std::vector<std::vector<int>> iarr2 = r["iarr"];
710 std::vector<std::vector<double>> darr2 = r["darr"];
711 std::vector<std::vector<bool>> barr2 = r["barr"];
712 std::vector<std::vector<std::string>> strarr2 = r["strarr"];
713 std::vector<std::vector<OC::OCRepresentation>> objarr2 = r["objarr"];
715 std::vector<std::vector<OCByteString>> bytestrarr2 = r["bytestrarr"];
717 // Note: due to the way that the CSDK works, all 2d arrays need to be rectangular.
718 // Since std::vector doesn't require this, items received on the other side end up
719 // being backfilled. This section removes the backfilling
723 strarr2[0].pop_back();
724 objarr2[0].pop_back();
725 bytestrarr2[0].pop_back();
727 EXPECT_EQ(iarr, iarr2);
728 EXPECT_EQ(darr, darr2);
729 EXPECT_EQ(barr, barr2);
730 EXPECT_EQ(strarr, strarr2);
731 EXPECT_EQ(objarr, objarr2);
732 EXPECT_EQ(bytestrarr.size(), bytestrarr2.size());
733 EXPECT_EQ(bytestrarrRef, bytestrarr2);
735 OCPayloadDestroy(cparsed);
738 TEST(RepresentationEncoding, ThreeDVectors)
741 OC::OCRepresentation startRep;
743 OC::OCRepresentation subRep1;
744 OC::OCRepresentation subRep2;
745 OC::OCRepresentation subRep3;
746 subRep1.setNULL("NullAttr");
747 subRep1.setValue("IntAttr", 77);
748 subRep2.setValue("DoubleAttr", 3.333);
749 subRep2.setValue("BoolAttr", true);
750 subRep3.setValue("StringAttr", std::string("String attr"));
752 std::vector<std::vector<std::vector<int>>> iarr
753 {{{1,2,3},{4,5,6}},{{7,8,9},{10,11,12}},{{13,14,15},{16,17,18}}};
754 std::vector<std::vector<std::vector<double>>> darr
755 {{{1.1,2.2,3.3},{4.4,5.5,6.6}},
756 {{7.7,8.7,9.7},{10.7,11.7,12.7}},
757 {{13.7,14.7,15.7},{16.7,17.7,18.7}}};
758 std::vector<std::vector<std::vector<bool>>> barr
759 {{{false, true},{true, false}},{{false, true},{true, false}}};
760 std::vector<std::vector<std::vector<std::string>>> strarr
762 {{"item1", "item2"},{"item3", "item4"}},
763 {{"item5", "item6"},{"item7", "item8"}},
764 {{"item9", "item10"},{"item11", ""}}
766 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
768 {{subRep1, subRep2},{subRep3, subRep1}},
769 {{subRep2, subRep3},{subRep2, subRep1}},
770 {{subRep3, subRep2},{subRep1, subRep2}}
773 uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
774 OCByteString byteStringRef1 {binval1, sizeof(binval1)};
775 OCByteString byteString1 {NULL,0};
776 EXPECT_TRUE(OCByteStringCopy(&byteString1, &byteStringRef1));
777 uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
778 OCByteString byteStringRef2 {binval2, sizeof(binval2)};
779 OCByteString byteString2 {NULL,0};
780 EXPECT_TRUE(OCByteStringCopy(&byteString2, &byteStringRef2));
781 uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
782 OCByteString byteStringRef3 {binval3, sizeof(binval3)};
783 OCByteString byteString3 {NULL,0};
784 EXPECT_TRUE(OCByteStringCopy(&byteString3, &byteStringRef3));
785 uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
786 OCByteString byteStringRef4 {binval4, sizeof(binval4)};
787 OCByteString byteString4 {NULL,0};
788 EXPECT_TRUE(OCByteStringCopy(&byteString4, &byteStringRef4));
789 uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
790 OCByteString byteStringRef5 {binval5, sizeof(binval5)};
791 OCByteString byteString5 {NULL,0};
792 EXPECT_TRUE(OCByteStringCopy(&byteString5, &byteStringRef5));
793 uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
794 OCByteString byteStringRef6 {binval6, sizeof(binval6)};
795 OCByteString byteString6 {NULL,0};
796 EXPECT_TRUE(OCByteStringCopy(&byteString6, &byteStringRef6));
797 uint8_t binval7[] = {0x19, 0x10, 0x1A, 0x1B};
798 OCByteString byteStringRef7 {binval7, sizeof(binval7)};
799 OCByteString byteString7 {NULL,0};
800 EXPECT_TRUE(OCByteStringCopy(&byteString7, &byteStringRef7));
801 uint8_t binval8[] = {0x1C, 0x1D, 0x1E, 0x1F};
802 OCByteString byteStringRef8 {binval8, sizeof(binval8)};
803 OCByteString byteString8 {NULL,0};
804 EXPECT_TRUE(OCByteStringCopy(&byteString8, &byteStringRef8));
805 uint8_t binval9[] = {0x21, 0x22, 0x23, 0x24};
806 OCByteString byteStringRef9 {binval9, sizeof(binval9)};
807 OCByteString byteString9 {NULL,0};
808 EXPECT_TRUE(OCByteStringCopy(&byteString9, &byteStringRef9));
809 uint8_t binval10[] = {0x25, 0x26, 0x27, 0x28};
810 OCByteString byteStringRef10 {binval10, sizeof(binval10)};
811 OCByteString byteString10 {NULL,0};
812 EXPECT_TRUE(OCByteStringCopy(&byteString10, &byteStringRef10));
813 uint8_t binval11[] = {0x29, 0x20, 0x2A, 0x2B};
814 OCByteString byteStringRef11 {binval11, sizeof(binval11)};
815 OCByteString byteString11 {NULL,0};
816 EXPECT_TRUE(OCByteStringCopy(&byteString11, &byteStringRef11));
817 uint8_t binval12[] = {0xFF};
818 OCByteString byteStringRef12 {binval12, sizeof(binval12)};
819 OCByteString byteString12 {NULL,0};
820 EXPECT_TRUE(OCByteStringCopy(&byteString12, &byteStringRef12));
822 std::vector<std::vector<std::vector<OCByteString>>> bytestrarrRef
824 {{byteStringRef1, byteStringRef2}, {byteStringRef3, byteStringRef4}},
825 {{byteStringRef5, byteStringRef6}, {byteStringRef7, byteStringRef8}},
826 {{byteStringRef9, byteStringRef10}, {byteStringRef11, byteStringRef12}}
829 std::vector<std::vector<std::vector<OCByteString>>> bytestrarr
831 {{byteString1, byteString2}, {byteString3, byteString4}},
832 {{byteString5, byteString6}, {byteString7, byteString8}},
833 {{byteString9, byteString10}, {byteString11, byteString12}}
836 startRep["iarr"] = iarr;
837 startRep["darr"] = darr;
838 startRep["barr"] = barr;
839 startRep["strarr"] = strarr;
840 startRep["objarr"] = objarr;
841 startRep["bytestrarr"] = bytestrarr;
844 OC::MessageContainer mc1;
845 mc1.addRepresentation(startRep);
847 OCRepPayload *cstart = mc1.getPayload();
848 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
853 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload *)cstart, &cborData, &cborSize));
854 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
855 cborData, cborSize));
856 OCPayloadDestroy((OCPayload *)cstart);
859 OC::MessageContainer mc2;
860 mc2.setPayload(cparsed);
861 EXPECT_EQ(1u, mc2.representations().size());
862 const OC::OCRepresentation &r = mc2.representations()[0];
865 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
866 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
867 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
868 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
869 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
870 std::vector<std::vector<std::vector<OCByteString>>> bytestrarr2 = r["bytestrarr"];
872 EXPECT_EQ(iarr, iarr2);
873 EXPECT_EQ(darr, darr2);
874 EXPECT_EQ(barr, barr2);
875 EXPECT_EQ(strarr, strarr2);
876 EXPECT_EQ(objarr, objarr2);
877 EXPECT_EQ(bytestrarrRef, bytestrarr2);
878 OCPayloadDestroy(cparsed);
881 TEST(RepresentationEncoding, ThreeDVectorsJagged)
884 OC::OCRepresentation startRep;
886 OC::OCRepresentation subRep1;
887 OC::OCRepresentation subRep2;
888 OC::OCRepresentation subRep3;
889 subRep1.setNULL("NullAttr");
890 subRep1.setValue("IntAttr", 77);
891 subRep2.setValue("DoubleAttr", 3.333);
892 subRep2.setValue("BoolAttr", true);
893 subRep3.setValue("StringAttr", std::string("String attr"));
895 std::vector<std::vector<std::vector<int>>> iarr
899 {{13,14,15},{16,17,18}}
901 std::vector<std::vector<std::vector<double>>> darr
903 {{1.1,2.2,3.3},{4.4,5.5,6.6}},
904 {{7.7,8.7,9.7},{10.7,12.7}},
905 {{13.7,14.7,15.7},{16.7,17.7,18.7}}
907 std::vector<std::vector<std::vector<bool>>> barr
909 {{false, true},{true}},
910 {{false, true},{true, false}}
912 std::vector<std::vector<std::vector<std::string>>> strarr
914 {{"item1", "item2"},{"item3", "item4"}},
915 {{"item5", "item6"},{"item8"}},
916 {{"item9", "item10"},{"item11", ""}}
918 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr
920 {{subRep1, subRep2},{subRep3, subRep1}},
921 {{subRep2, subRep3},{subRep2}},
925 uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
926 OCByteString byteStringRef1 {binval1, sizeof(binval1)};
927 OCByteString byteString1 {NULL,0};
928 EXPECT_TRUE(OCByteStringCopy(&byteString1, &byteStringRef1));
929 uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
930 OCByteString byteStringRef2 {binval2, sizeof(binval2)};
931 OCByteString byteString2 {NULL,0};
932 EXPECT_TRUE(OCByteStringCopy(&byteString2, &byteStringRef2));
933 uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
934 OCByteString byteStringRef3 {binval3, sizeof(binval3)};
935 OCByteString byteString3 {NULL,0};
936 EXPECT_TRUE(OCByteStringCopy(&byteString3, &byteStringRef3));
937 uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
938 OCByteString byteStringRef4 {binval4, sizeof(binval4)};
939 OCByteString byteString4 {NULL,0};
940 EXPECT_TRUE(OCByteStringCopy(&byteString4, &byteStringRef4));
941 uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
942 OCByteString byteStringRef5 {binval5, sizeof(binval5)};
943 OCByteString byteString5 {NULL,0};
944 EXPECT_TRUE(OCByteStringCopy(&byteString5, &byteStringRef5));
945 uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
946 OCByteString byteStringRef6 {binval6, sizeof(binval6)};
947 OCByteString byteString6 {NULL,0};
948 EXPECT_TRUE(OCByteStringCopy(&byteString6, &byteStringRef6));
949 uint8_t binval8[] = {0x1C, 0x1D, 0x1E, 0x1F};
950 OCByteString byteStringRef8 {binval8, sizeof(binval8)};
951 OCByteString byteString8 {NULL,0};
952 EXPECT_TRUE(OCByteStringCopy(&byteString8, &byteStringRef8));
953 uint8_t binval9[] = {0x21, 0x22, 0x23, 0x24};
954 OCByteString byteStringRef9 {binval9, sizeof(binval9)};
955 OCByteString byteString9 {NULL,0};
956 EXPECT_TRUE(OCByteStringCopy(&byteString9, &byteStringRef9));
957 uint8_t binval10[] = {0x25, 0x26, 0x27, 0x28};
958 OCByteString byteStringRef10 {binval10, sizeof(binval10)};
959 OCByteString byteString10 {NULL,0};
960 EXPECT_TRUE(OCByteStringCopy(&byteString10, &byteStringRef10));
961 uint8_t binval11[] = {0x29, 0x20, 0x2A, 0x2B};
962 OCByteString byteStringRef11 {binval11, sizeof(binval11)};
963 OCByteString byteString11 {NULL,0};
964 EXPECT_TRUE(OCByteStringCopy(&byteString11, &byteStringRef11));
965 uint8_t binval12[] = {0xFF};
966 OCByteString byteStringRef12 {binval12, sizeof(binval12)};
967 OCByteString byteString12 {NULL,0};
968 EXPECT_TRUE(OCByteStringCopy(&byteString12, &byteStringRef12));
970 std::vector<std::vector<std::vector<OCByteString>>> bytestrarrRef
972 {{byteStringRef1, byteStringRef2}, {byteStringRef3, byteStringRef4}},
973 {{byteStringRef5, byteStringRef6}, {byteStringRef8}},
974 {{byteStringRef9, byteStringRef10}, {byteStringRef11, byteStringRef12}}
977 std::vector<std::vector<std::vector<OCByteString>>> bytestrarr
979 {{byteString1, byteString2}, {byteString3, byteString4}},
980 {{byteString5, byteString6}, {byteString8}},
981 {{byteString9, byteString10}, {byteString11, byteString12}}
984 startRep["iarr"] = iarr;
985 startRep["darr"] = darr;
986 startRep["barr"] = barr;
987 startRep["strarr"] = strarr;
988 startRep["objarr"] = objarr;
989 startRep["bytestrarr"] = bytestrarr;
992 OC::MessageContainer mc1;
993 mc1.addRepresentation(startRep);
995 OCRepPayload *cstart = mc1.getPayload();
996 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, cstart->base.type);
1001 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload *)cstart, &cborData, &cborSize));
1002 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1003 cborData, cborSize));
1004 OCPayloadDestroy((OCPayload *)cstart);
1007 OC::MessageContainer mc2;
1008 mc2.setPayload(cparsed);
1009 EXPECT_EQ(1u, mc2.representations().size());
1010 const OC::OCRepresentation &r = mc2.representations()[0];
1013 std::vector<std::vector<std::vector<int>>> iarr2 = r["iarr"];
1014 std::vector<std::vector<std::vector<double>>> darr2 = r["darr"];
1015 std::vector<std::vector<std::vector<bool>>> barr2 = r["barr"];
1016 std::vector<std::vector<std::vector<std::string>>> strarr2 = r["strarr"];
1017 std::vector<std::vector<std::vector<OC::OCRepresentation>>> objarr2 = r["objarr"];
1018 std::vector<std::vector<std::vector<OCByteString>>> bytestrarr2 = r["bytestrarr"];
1020 // Note: due to the way that the CSDK works, all 3d arrays need to be cuboidal.
1021 // Since std::vector doesn't require this, items received on the other side end up
1022 // being backfilled. This section removes the backfilling
1023 iarr2[1][1].pop_back();
1024 darr2[1][1].pop_back();
1025 barr2[0][1].pop_back();
1026 strarr2[1][1].pop_back();
1027 objarr2[1][1].pop_back();
1028 objarr2[2].pop_back();
1029 bytestrarr2[1][1].pop_back();
1031 EXPECT_EQ(iarr, iarr2);
1032 EXPECT_EQ(darr, darr2);
1033 EXPECT_EQ(barr, barr2);
1034 EXPECT_EQ(strarr, strarr2);
1035 EXPECT_EQ(objarr, objarr2);
1036 EXPECT_EQ(bytestrarrRef, bytestrarr2);
1037 OCPayloadDestroy(cparsed);
1040 TEST(DiscoveryRTandIF, SingleItemNormal)
1042 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1043 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1044 payload->sid = OICStrdup(sid1);
1045 payload->resources = resource;
1047 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem"));
1048 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem"));
1050 resource->uri = OICStrdup("/uri/thing");
1056 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1057 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1058 cborData, cborSize));
1060 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1061 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1063 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1064 EXPECT_EQ(NULL, parsedResource->next);
1065 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
1066 EXPECT_EQ(NULL, parsedResource->types->next);
1067 EXPECT_EQ(NULL, parsedResource->interfaces->next);
1068 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
1071 OCPayloadDestroy(cparsed);
1072 OCDiscoveryPayloadDestroy(payload);
1075 TEST(DiscoveryRTandIF, SingleItemFrontTrim)
1077 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1078 payload->sid = OICStrdup(sid1);
1079 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1080 payload->resources = resource;
1082 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->types, " rt.singleitem"));
1083 EXPECT_TRUE(OCResourcePayloadAddStringLL(&resource->interfaces, " if.singleitem"));
1084 resource->uri = OICStrdup("/uri/thing");
1090 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1091 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1092 cborData, cborSize));
1094 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1095 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1097 EXPECT_EQ(NULL, parsedResource->next);
1098 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1099 EXPECT_EQ(NULL, parsedResource->types->next);
1100 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
1101 EXPECT_EQ(NULL, parsedResource->interfaces->next);
1102 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
1105 OCPayloadDestroy(cparsed);
1106 OCDiscoveryPayloadDestroy(payload);
1109 TEST(DiscoveryRTandIF, SingleItemBackTrim)
1111 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1112 payload->sid = OICStrdup(sid1);
1113 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1114 payload->resources = resource;
1116 OCResourcePayloadAddStringLL(&resource->types, "rt.singleitem ");
1117 OCResourcePayloadAddStringLL(&resource->interfaces, "if.singleitem ");
1118 resource->uri = OICStrdup("/uri/thing");
1124 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1125 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1126 cborData, cborSize));
1128 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1129 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1131 EXPECT_EQ(NULL, parsedResource->next);
1132 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1133 EXPECT_EQ(NULL, parsedResource->types->next);
1134 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
1135 EXPECT_EQ(NULL, parsedResource->interfaces->next);
1136 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
1139 OCPayloadDestroy(cparsed);
1140 OCDiscoveryPayloadDestroy(payload);
1142 TEST(DiscoveryRTandIF, SingleItemBothTrim)
1144 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1145 payload->sid = OICStrdup(sid1);
1146 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1147 payload->resources = resource;
1149 OCResourcePayloadAddStringLL(&resource->types, " rt.singleitem ");
1150 OCResourcePayloadAddStringLL(&resource->interfaces, " if.singleitem ");
1151 resource->uri = OICStrdup("/uri/thing");
1157 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1158 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1159 cborData, cborSize));
1161 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1162 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1164 EXPECT_EQ(NULL, parsedResource->next);
1165 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1166 EXPECT_EQ(NULL, parsedResource->types->next);
1167 EXPECT_STREQ("rt.singleitem", parsedResource->types->value);
1168 EXPECT_EQ(NULL, parsedResource->interfaces->next);
1169 EXPECT_STREQ("if.singleitem", parsedResource->interfaces->value);
1172 OCPayloadDestroy(cparsed);
1173 OCDiscoveryPayloadDestroy(payload);
1175 TEST(DiscoveryRTandIF, MultiItemsNormal)
1177 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1178 payload->sid = OICStrdup(sid1);
1179 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1180 payload->resources = resource;
1182 OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem");
1183 OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem");
1184 OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem");
1185 OCResourcePayloadAddStringLL(&resource->interfaces, "if.seconditem");
1186 resource->uri = OICStrdup("/uri/thing");
1192 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1193 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1194 cborData, cborSize));
1196 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1197 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1199 EXPECT_EQ(NULL, parsedResource->next);
1200 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1201 EXPECT_EQ(NULL, parsedResource->types->next->next);
1202 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
1203 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
1204 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
1205 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
1206 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
1209 OCPayloadDestroy(cparsed);
1210 OCDiscoveryPayloadDestroy(payload);
1212 TEST(DiscoveryRTandIF, MultiItemExtraLeadSpaces)
1214 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1215 payload->sid = OICStrdup(sid1);
1216 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1217 payload->resources = resource;
1219 OCResourcePayloadAddStringLL(&resource->types, " rt.firstitem");
1220 OCResourcePayloadAddStringLL(&resource->types, " rt.seconditem");
1221 OCResourcePayloadAddStringLL(&resource->interfaces, " if.firstitem");
1222 OCResourcePayloadAddStringLL(&resource->interfaces, " if.seconditem");
1223 resource->uri = OICStrdup("/uri/thing");
1229 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1230 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1231 cborData, cborSize));
1233 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1234 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1236 EXPECT_EQ(NULL, parsedResource->next);
1237 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1238 EXPECT_EQ(NULL, parsedResource->types->next->next);
1239 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
1240 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
1241 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
1242 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
1243 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
1246 OCPayloadDestroy(cparsed);
1247 OCDiscoveryPayloadDestroy(payload);
1249 TEST(DiscoveryRTandIF, MultiItemExtraTrailSpaces)
1251 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1252 payload->sid = OICStrdup(sid1);
1253 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1254 payload->resources = resource;
1256 OCResourcePayloadAddStringLL(&resource->types, "rt.firstitem ");
1257 OCResourcePayloadAddStringLL(&resource->types, "rt.seconditem ");
1258 OCResourcePayloadAddStringLL(&resource->interfaces, "if.firstitem ");
1259 OCResourcePayloadAddStringLL(&resource->interfaces, "if.seconditem ");
1260 resource->uri = OICStrdup("/uri/thing");
1266 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1267 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1268 cborData, cborSize));
1270 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1271 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1273 EXPECT_EQ(NULL, parsedResource->next);
1274 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1275 EXPECT_EQ(NULL, parsedResource->types->next->next);
1276 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
1277 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
1278 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
1279 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
1280 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
1283 OCPayloadDestroy(cparsed);
1284 OCDiscoveryPayloadDestroy(payload);
1286 TEST(DiscoveryRTandIF, MultiItemBothSpaces)
1288 OCDiscoveryPayload* payload = OCDiscoveryPayloadCreate();
1289 payload->sid = OICStrdup(sid1);
1290 OCResourcePayload* resource = (OCResourcePayload*)OICCalloc(1, sizeof(OCResourcePayload));
1291 payload->resources = resource;
1293 OCResourcePayloadAddStringLL(&resource->types, " rt.firstitem ");
1294 OCResourcePayloadAddStringLL(&resource->types, " rt.seconditem ");
1295 OCResourcePayloadAddStringLL(&resource->interfaces, " if.firstitem ");
1296 OCResourcePayloadAddStringLL(&resource->interfaces, " if.seconditem ");
1297 resource->uri = OICStrdup("/uri/thing");
1303 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1304 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_DISCOVERY,
1305 cborData, cborSize));
1307 EXPECT_EQ(1u, OCDiscoveryPayloadGetResourceCount((OCDiscoveryPayload*)cparsed));
1308 OCResourcePayload* parsedResource = ((OCDiscoveryPayload*)cparsed)->resources;
1310 EXPECT_EQ(NULL, parsedResource->next);
1311 EXPECT_STREQ(sid1, ((OCDiscoveryPayload*)cparsed)->sid);
1312 EXPECT_EQ(NULL, parsedResource->types->next->next);
1313 EXPECT_STREQ("rt.firstitem", parsedResource->types->value);
1314 EXPECT_STREQ("rt.seconditem", parsedResource->types->next->value);
1315 EXPECT_EQ(NULL, parsedResource->interfaces->next->next);
1316 EXPECT_STREQ("if.firstitem", parsedResource->interfaces->value);
1317 EXPECT_STREQ("if.seconditem", parsedResource->interfaces->next->value);
1320 OCPayloadDestroy(cparsed);
1321 OCDiscoveryPayloadDestroy(payload);
1323 TEST(RepresentationEncodingRTandIF, SingleItemNormal)
1325 OCRepPayload* payload = OCRepPayloadCreate();
1326 OCRepPayloadAddResourceType(payload, "rt.firstitem");
1327 OCRepPayloadAddInterface(payload, "if.firstitem");
1333 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1334 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1335 cborData, cborSize));
1337 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1339 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1340 EXPECT_EQ(NULL, parsedPayload->types->next);
1341 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1342 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1345 OCRepPayloadDestroy(payload);
1346 OCPayloadDestroy(cparsed);
1348 TEST(RepresentationEncodingRTandIF, SingleItemFrontTrim)
1350 OCRepPayload* payload = OCRepPayloadCreate();
1351 OCRepPayloadAddResourceType(payload, " rt.firstitem");
1352 OCRepPayloadAddInterface(payload, " if.firstitem");
1358 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1359 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1360 cborData, cborSize));
1362 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1364 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1365 EXPECT_EQ(NULL, parsedPayload->types->next);
1366 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1367 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1371 OCRepPayloadDestroy(payload);
1372 OCPayloadDestroy(cparsed);
1374 TEST(RepresentationEncodingRTandIF, SingleItemBackTrim)
1376 OCRepPayload* payload = OCRepPayloadCreate();
1377 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
1378 OCRepPayloadAddInterface(payload, "if.firstitem ");
1384 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1385 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1386 cborData, cborSize));
1388 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1390 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1391 EXPECT_EQ(NULL, parsedPayload->types->next);
1392 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1393 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1397 OCRepPayloadDestroy(payload);
1398 OCPayloadDestroy(cparsed);
1400 TEST(RepresentationEncodingRTandIF, SingleItemBothTrim)
1402 OCRepPayload* payload = OCRepPayloadCreate();
1403 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1404 OCRepPayloadAddInterface(payload, " if.firstitem ");
1410 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1411 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1412 cborData, cborSize));
1414 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1416 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1417 EXPECT_EQ(NULL, parsedPayload->types->next);
1418 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1419 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1423 OCRepPayloadDestroy(payload);
1424 OCPayloadDestroy(cparsed);
1426 TEST(RepresentationEncodingRTandIF, MultiItemsNormal)
1428 OCRepPayload* payload = OCRepPayloadCreate();
1429 OCRepPayloadAddResourceType(payload, "rt.firstitem");
1430 OCRepPayloadAddResourceType(payload, "rt.seconditem");
1431 OCRepPayloadAddInterface(payload, "if.firstitem");
1432 OCRepPayloadAddInterface(payload, "if.seconditem");
1438 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1439 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1440 cborData, cborSize));
1442 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1444 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1445 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1446 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1447 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1448 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1449 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1453 OCRepPayloadDestroy(payload);
1454 OCPayloadDestroy(cparsed);
1456 TEST(RepresentationEncodingRTandIF, MultiItemExtraLeadSpaces)
1458 OCRepPayload* payload = OCRepPayloadCreate();
1459 OCRepPayloadAddResourceType(payload, " rt.firstitem");
1460 OCRepPayloadAddResourceType(payload, " rt.seconditem");
1461 OCRepPayloadAddInterface(payload, " if.firstitem");
1462 OCRepPayloadAddInterface(payload, " if.seconditem");
1468 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1469 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1470 cborData, cborSize));
1472 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1474 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1475 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1476 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1477 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1478 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1479 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1483 OCRepPayloadDestroy(payload);
1484 OCPayloadDestroy(cparsed);
1486 TEST(RepresentationEncodingRTandIF, MultiItemExtraTrailSpaces)
1488 OCRepPayload* payload = OCRepPayloadCreate();
1489 OCRepPayloadAddResourceType(payload, "rt.firstitem ");
1490 OCRepPayloadAddResourceType(payload, "rt.seconditem ");
1491 OCRepPayloadAddInterface(payload, "if.firstitem ");
1492 OCRepPayloadAddInterface(payload, "if.seconditem ");
1498 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1499 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1500 cborData, cborSize));
1502 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1504 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1505 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1506 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1507 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1508 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1509 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1513 OCRepPayloadDestroy(payload);
1514 OCPayloadDestroy(cparsed);
1516 TEST(RepresentationEncodingRTandIF, MultiItemExtraMiddleSpaces)
1518 OCRepPayload* payload = OCRepPayloadCreate();
1519 OCRepPayloadAddResourceType(payload, " rt.firstitem ");
1520 OCRepPayloadAddResourceType(payload, " rt.seconditem ");
1521 OCRepPayloadAddInterface(payload, " if.firstitem ");
1522 OCRepPayloadAddInterface(payload, " if.seconditem ");
1528 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)payload, &cborData, &cborSize));
1529 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1530 cborData, cborSize));
1532 OCRepPayload* parsedPayload = (OCRepPayload*)cparsed;
1534 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1535 EXPECT_STREQ("rt.seconditem", parsedPayload->types->next->value);
1536 EXPECT_EQ(NULL, parsedPayload->types->next->next);
1537 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1538 EXPECT_STREQ("if.seconditem", parsedPayload->interfaces->next->value);
1539 EXPECT_EQ(NULL, parsedPayload->interfaces->next->next);
1543 OCRepPayloadDestroy(payload);
1544 OCPayloadDestroy(cparsed);
1546 TEST(RepresentationEncodingRTandIF, TestPayloadContents)
1548 OC::OCRepresentation subRep1;
1549 std::vector<std::string> types;
1550 types.push_back("rt.firstitem");
1551 std::vector<std::string> interfaces;
1552 interfaces.push_back("if.firstitem");
1553 subRep1.setResourceTypes(types);
1554 subRep1.setResourceInterfaces(interfaces);
1555 subRep1.setNULL("NullAttr");
1556 subRep1.setValue("IntAttr", 77);
1557 subRep1.setValue("DoubleAttr", 3.333);
1558 subRep1.setValue("BoolAttr", true);
1559 subRep1.setValue("StringAttr", std::string("String attr"));
1561 OC::MessageContainer mc1;
1562 mc1.addRepresentation(subRep1);
1564 OCRepPayload *repPayload = mc1.getPayload();
1565 EXPECT_EQ(PAYLOAD_TYPE_REPRESENTATION, repPayload->base.type);
1567 uint8_t *cborData = NULL;
1568 size_t cborSize = 0;
1569 OCPayload *cparsed = NULL;
1571 EXPECT_EQ(OC_STACK_OK, OCConvertPayload((OCPayload*)repPayload, &cborData, &cborSize));
1572 EXPECT_EQ(OC_STACK_OK, OCParsePayload(&cparsed, PAYLOAD_TYPE_REPRESENTATION,
1573 cborData, cborSize));
1575 OCRepPayload *parsedPayload = (OCRepPayload *)cparsed;
1576 EXPECT_EQ(NULL, parsedPayload->uri);
1577 EXPECT_STREQ("rt.firstitem", parsedPayload->types->value);
1578 EXPECT_EQ(NULL, parsedPayload->types->next);
1579 EXPECT_STREQ("if.firstitem", parsedPayload->interfaces->value);
1580 EXPECT_EQ(NULL, parsedPayload->interfaces->next);
1582 // To make sure rt and if are not duplicated.
1583 EXPECT_STREQ("BoolAttr", parsedPayload->values->name);
1584 EXPECT_EQ(true, parsedPayload->values->b);
1585 EXPECT_EQ(OCREP_PROP_BOOL, parsedPayload->values->type);
1586 parsedPayload->values = parsedPayload->values->next;
1588 EXPECT_STREQ("DoubleAttr", parsedPayload->values->name);
1589 EXPECT_EQ(OCREP_PROP_DOUBLE, parsedPayload->values->type);
1590 EXPECT_EQ(3.3330000000000002, parsedPayload->values->d);
1591 parsedPayload->values = parsedPayload->values->next;
1593 EXPECT_STREQ("IntAttr", parsedPayload->values->name);
1594 EXPECT_EQ(77, parsedPayload->values->i);
1595 EXPECT_EQ(OCREP_PROP_INT, parsedPayload->values->type);
1596 parsedPayload->values = parsedPayload->values->next;
1598 EXPECT_STREQ("NullAttr", parsedPayload->values->name);
1599 EXPECT_EQ(OCREP_PROP_NULL, parsedPayload->values->type);
1600 parsedPayload->values = parsedPayload->values->next;
1602 EXPECT_STREQ("StringAttr", parsedPayload->values->name);
1603 EXPECT_STREQ("String attr", parsedPayload->values->str);
1604 EXPECT_EQ(OCREP_PROP_STRING, parsedPayload->values->type);
1605 parsedPayload->values = parsedPayload->values->next;
1607 EXPECT_EQ(NULL, parsedPayload->values);
1610 OCRepPayloadDestroy(repPayload);
1611 OCPayloadDestroy(cparsed);