1 //******************************************************************
3 // Copyright 2014 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 "oic_string.h"
26 #include <boost/lexical_cast.hpp>
27 namespace OCRepresentationTest
33 void parsedEqual(double expected, const std::string& actualStr)
35 double actual = boost::lexical_cast<double>(actualStr);
36 EXPECT_GE(actual, expected - .0000001);
37 EXPECT_LE(actual, expected + .0000001);
40 // getValueToString(all types)
41 TEST(OCRepresentationValueToString, Null)
43 static const std::string AttrName = "NullTest";
45 rep.setNULL(AttrName);
47 EXPECT_TRUE(rep.isNULL(AttrName));
48 EXPECT_EQ("(null)", rep.getValueToString(AttrName));
49 EXPECT_EQ("(null)", rep[AttrName].getValueToString());
52 TEST(OCRepresentationValueToString, Integer)
54 static const std::string AttrName = "IntTest";
57 rep.setValue(AttrName, -5);
58 EXPECT_EQ("-5", rep.getValueToString(AttrName));
59 EXPECT_EQ("-5", rep[AttrName].getValueToString());
61 rep.setValue(AttrName, 0);
62 EXPECT_EQ("0", rep.getValueToString(AttrName));
63 EXPECT_EQ("0", rep[AttrName].getValueToString());
65 rep.setValue(AttrName, 5);
66 EXPECT_EQ("5", rep.getValueToString(AttrName));
67 EXPECT_EQ("5", rep[AttrName].getValueToString());
69 rep.setValue(AttrName, 54321);
70 EXPECT_EQ("54321", rep.getValueToString(AttrName));
71 EXPECT_EQ("54321", rep[AttrName].getValueToString());
74 TEST(OCRepresentationValueToString, Double)
76 static const std::string AttrName = "DoubleTest";
79 rep.setValue(AttrName, -5.0);
80 parsedEqual(-5.0, rep.getValueToString(AttrName));
81 parsedEqual(-5.0, rep[AttrName].getValueToString());
83 rep.setValue(AttrName, 0.0);
84 parsedEqual(0.0, rep.getValueToString(AttrName));
85 parsedEqual(0.0, rep[AttrName].getValueToString());
87 rep.setValue(AttrName, 5.0);
88 parsedEqual(5.0, rep.getValueToString(AttrName));
89 parsedEqual(5.0, rep[AttrName].getValueToString());
91 rep.setValue(AttrName, 54321.0);
92 parsedEqual(54321.0, rep.getValueToString(AttrName));
93 parsedEqual(54321.0, rep[AttrName].getValueToString());
95 rep.setValue(AttrName, 3.55);
96 parsedEqual(3.55, rep.getValueToString(AttrName));
97 parsedEqual(3.55, rep[AttrName].getValueToString());
99 rep.setValue(AttrName, -4.95);
100 parsedEqual(-4.95, rep.getValueToString(AttrName));
101 parsedEqual(-4.95, rep[AttrName].getValueToString());
103 rep.setValue(AttrName, 99999.5555);
104 parsedEqual(99999.5555, rep.getValueToString(AttrName));
105 parsedEqual(99999.5555, rep[AttrName].getValueToString());
108 TEST(OCRepresentationValueToString, Boolean)
110 static const std::string AttrName = "BooleanTest";
111 OCRepresentation rep;
113 rep.setValue(AttrName, false);
114 EXPECT_EQ("false", rep.getValueToString(AttrName));
115 EXPECT_EQ("false", rep[AttrName].getValueToString());
117 rep.setValue(AttrName, true);
118 EXPECT_EQ("true", rep.getValueToString(AttrName));
119 EXPECT_EQ("true", rep[AttrName].getValueToString());
122 TEST(OCRepresentationValueToString, String)
124 static const std::string AttrName = "StringTest";
125 OCRepresentation rep;
127 rep.setValue(AttrName, std::string("test 1"));
128 EXPECT_EQ("test 1", rep.getValueToString(AttrName));
129 EXPECT_EQ("test 1", rep[AttrName].getValueToString());
131 rep.setValue(AttrName, std::string("test 2"));
132 EXPECT_EQ("test 2", rep.getValueToString(AttrName));
133 EXPECT_EQ("test 2", rep[AttrName].getValueToString());
136 TEST(OCRepresentationValueToString, SubRepresentation)
138 static const std::string AttrName = "SubRepTest";
139 OCRepresentation rep;
140 OCRepresentation sub1;
141 OCRepresentation sub2;
143 rep.setValue(AttrName, sub1);
144 EXPECT_EQ("OC::OCRepresentation", rep.getValueToString(AttrName));
145 EXPECT_EQ("OC::OCRepresentation", rep[AttrName].getValueToString());
147 rep.setValue(AttrName, sub2);
148 EXPECT_EQ("OC::OCRepresentation", rep.getValueToString(AttrName));
149 EXPECT_EQ("OC::OCRepresentation", rep[AttrName].getValueToString());
152 TEST(OCRepresentationValueToString, ByteString)
154 static const std::string AttrName = "ByteStringTest";
155 static uint8_t binval[] = {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8,
156 0x9, 0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF};
158 OCByteString bytestring {binval, sizeof(binval)};
159 OCRepresentation rep;
161 rep.setValue(AttrName, bytestring);
162 const char* expected = "\\x1\\x2\\x3\\x4\\x5\\x6\\x7\\x8"
163 "\\x9\\x0\\xa\\xb\\xc\\xd\\xe\\xf";
164 EXPECT_STREQ(expected, rep.getValueToString(AttrName).c_str() );
167 TEST(OCRepresentationValueToString, IntegerVector)
169 static const std::string AttrName = "VectorTest";
170 OCRepresentation rep;
172 vector<int> vect {1,2,3,4,5,6,7,8,9};
173 vector<int> vect2 {-5,-3,-1,0,5,3,2};
174 rep.setValue(AttrName, vect);
175 EXPECT_EQ("[1 2 3 4 5 6 7 8 9 ]", rep.getValueToString(AttrName));
176 EXPECT_EQ("[1 2 3 4 5 6 7 8 9 ]", rep[AttrName].getValueToString());
178 rep.setValue(AttrName, vect2);
179 EXPECT_EQ("[-5 -3 -1 0 5 3 2 ]", rep.getValueToString(AttrName));
180 EXPECT_EQ("[-5 -3 -1 0 5 3 2 ]", rep[AttrName].getValueToString());
183 TEST(OCRepresentationValueToString, IntegerVectorVector)
185 static const std::string AttrName = "VectorTest";
186 OCRepresentation rep;
188 vector<int> vect1 {1,2,3,4,5,6,7,8,9};
189 vector<int> vect2 {-5,-3,-1,0,5,3,2};
190 vector<vector<int>> vect{vect1, vect2};
192 rep.setValue(AttrName, vect);
193 static const string Expected = "[[1 2 3 4 5 6 7 8 9 ] [-5 -3 -1 0 5 3 2 ] ]";
194 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
195 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
198 TEST(OCRepresentationValueToString, IntegerVectorVectorVector)
200 static const std::string AttrName = "VectorTest";
201 OCRepresentation rep;
203 vector<int> vect11 {1,2,3,4,5,6,7,8,9};
204 vector<int> vect12 {-5,-3,-1,0,5,3,2};
205 vector<vector<int>> vect1{vect11, vect12};
206 vector<int> vect21 {2,0,1,6,9,3,8};
207 vector<int> vect22 {9,7,8,100003};
208 vector<vector<int>> vect2{vect21, vect22};
209 vector<vector<vector<int>>> vect{vect1, vect2};
210 rep.setValue(AttrName, vect);
211 static const std::string Expected =
212 "[[[1 2 3 4 5 6 7 8 9 ] [-5 -3 -1 0 5 3 2 ] ] [[2 0 1 6 9 3 8 ] [9 7 8 100003 ] ] ]";
213 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
214 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
217 TEST(OCRepresentationValueToString, DoubleVector)
219 static const std::string AttrName = "VectorTest";
220 OCRepresentation rep;
222 vector<double> vect {3.12, -5.3, 7.5, 1.110};
223 vector<double> vect2 {2.1, -555.5, 0.0001, -0.2};
224 rep.setValue(AttrName, vect);
225 EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
227 rep.setValue(AttrName, vect2);
228 EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
231 TEST(OCRepresentationValueToString, DoubleVectorVector)
233 static const std::string AttrName = "VectorTest";
234 OCRepresentation rep;
235 vector<double> vect1 {30.1,5.88,-22.0,0};
236 vector<double> vect2 {2.1,-55.5,0.1100,-.2};
237 vector<vector<double>> vect{vect1, vect2};
239 rep.setValue(AttrName, vect);
240 EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
243 TEST(OCRepresentationValueToString, DoubleVectorVectorVector)
245 static const std::string AttrName = "VectorTest";
246 OCRepresentation rep;
248 vector<double> vect11 {3.01, 5.88, -22.0, 0.0};
249 vector<double> vect12 {99.3,8.0,.01236,-.22};
250 vector<vector<double>> vect1{vect11, vect12};
251 vector<double> vect21 {9.0,-1};
252 vector<double> vect22 {-99.2};
253 vector<vector<double>> vect2{vect21, vect22};
254 vector<vector<vector<double>>> vect{vect1, vect2};
255 rep.setValue(AttrName, vect);
256 EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
259 TEST(OCRepresentationValueToString, BooleanVector)
261 static const std::string AttrName = "VectorTest";
262 OCRepresentation rep;
264 vector<bool> vect {true, false, false, true};
265 vector<bool> vect2 {false, false, false, true};
266 rep.setValue(AttrName, vect);
267 EXPECT_EQ("[true false false true ]", rep.getValueToString(AttrName));
268 EXPECT_EQ("[true false false true ]", rep[AttrName].getValueToString());
270 rep.setValue(AttrName, vect2);
271 EXPECT_EQ("[false false false true ]", rep.getValueToString(AttrName));
272 EXPECT_EQ("[false false false true ]", rep[AttrName].getValueToString());
275 TEST(OCRepresentationValueToString, BooleanVectorVector)
277 static const std::string AttrName = "VectorTest";
278 OCRepresentation rep;
280 vector<bool> vect1 {true, false, false, true};
281 vector<bool> vect2 {false, false, false, true};
282 vector<vector<bool>> vect{vect1, vect2};
284 rep.setValue(AttrName, vect);
285 static const string Expected="[[true false false true ] [false false false true ] ]";
287 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
288 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
291 TEST(OCRepresentationValueToString, BooleanVectorVectorVector)
293 static const std::string AttrName = "VectorTest";
294 OCRepresentation rep;
296 vector<bool> vect11 {true, false, false, true};
297 vector<bool> vect12 {false, false, false, true};
298 vector<vector<bool>> vect1{vect11, vect12};
299 vector<bool> vect21 {false, true, true, false};
300 vector<bool> vect22 {true, true, true, false};
301 vector<vector<bool>> vect2{vect21, vect22};
302 vector<vector<vector<bool>>> vect{vect1, vect2};
303 rep.setValue(AttrName, vect);
304 static const std::string Expected =
305 "[[[true false false true ] [false false false true ] ]"
306 " [[false true true false ] [true true true false ] ] ]";
307 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
308 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
311 TEST(OCRepresentationValueToString, StringVector)
313 static const std::string AttrName = "VectorTest";
314 OCRepresentation rep;
316 vector<string> vect {"s1", "s2", "s3"};
317 vector<string> vect2 {"s4", "s5", "s6"};
318 rep.setValue(AttrName, vect);
319 EXPECT_EQ("[s1 s2 s3 ]", rep.getValueToString(AttrName));
320 EXPECT_EQ("[s1 s2 s3 ]", rep[AttrName].getValueToString());
322 rep.setValue(AttrName, vect2);
323 EXPECT_EQ("[s4 s5 s6 ]", rep.getValueToString(AttrName));
324 EXPECT_EQ("[s4 s5 s6 ]", rep[AttrName].getValueToString());
327 TEST(OCRepresentationValueToString, StringVectorVector)
329 static const std::string AttrName = "VectorTest";
330 OCRepresentation rep;
332 vector<string> vect1 {"s1", "s2", "s3"};
333 vector<string> vect2 {"s4", "s5", "s6"};
334 vector<vector<string>> vect{vect1, vect2};
336 rep.setValue(AttrName, vect);
337 static const string Expected="[[s1 s2 s3 ] [s4 s5 s6 ] ]";
339 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
340 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
343 TEST(OCRepresentationValueToString, StringVectorVectorVector)
345 static const std::string AttrName = "VectorTest";
346 OCRepresentation rep;
348 vector<string> vect11 {"s1", "s2", "s3"};
349 vector<string> vect12 {"s4", "s5", "s6"};
350 vector<vector<string>> vect1{vect11, vect12};
351 vector<string> vect21 {"s7", "s8"};
352 vector<string> vect22 {"s9"};
353 vector<vector<string>> vect2{vect21, vect22};
354 vector<vector<vector<string>>> vect{vect1, vect2};
355 rep.setValue(AttrName, vect);
356 static const std::string Expected =
357 "[[[s1 s2 s3 ] [s4 s5 s6 ] ]"
358 " [[s7 s8 ] [s9 ] ] ]";
359 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
360 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
363 TEST(OCRepresentationValueToByteString, ByteStringVector)
365 static const std::string AttrName = "VectorTest";
366 OCRepresentation rep;
368 uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
369 OCByteString s1 {binval1, sizeof(binval1)};
370 uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
371 OCByteString s2 {binval2, sizeof(binval2)};
372 uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
373 OCByteString s3 {binval3, sizeof(binval3)};
374 vector<OCByteString> vect {s1, s2, s3};
376 uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
377 OCByteString s4 {binval4, sizeof(binval4)};
378 uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
379 OCByteString s5 {binval5, sizeof(binval5)};
380 uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
381 OCByteString s6 {binval6, sizeof(binval6)};
382 vector<OCByteString> vect2 {s4, s5, s6};
384 rep.setValue(AttrName, vect);
385 const char *expected1tob = "[\\x1\\x2\\x3\\x4 \\x5\\x6\\x7\\x8 \\x9\\x0\\xa\\xb ]";
386 EXPECT_EQ(expected1tob, rep.getValueToString(AttrName));
387 EXPECT_EQ(expected1tob, rep[AttrName].getValueToString());
389 rep.setValue(AttrName, vect2);
390 const char *expectedcto18 = "[\\xc\\xd\\xe\\xf \\x11\\x12\\x13\\x14 \\x15\\x16\\x17\\x18 ]";
391 EXPECT_EQ(expectedcto18, rep.getValueToString(AttrName));
392 EXPECT_EQ(expectedcto18, rep[AttrName].getValueToString());
395 TEST(OCRepresentationValueToByteString, ByteStringVectorVector)
397 static const std::string AttrName = "VectorTest";
398 OCRepresentation rep;
400 uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
401 OCByteString s1 {binval1, sizeof(binval1)};
402 uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
403 OCByteString s2 {binval2, sizeof(binval2)};
404 uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
405 OCByteString s3 {binval3, sizeof(binval3)};
406 vector<OCByteString> vect1 {s1, s2, s3};
408 uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
409 OCByteString s4 {binval4, sizeof(binval4)};
410 uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
411 OCByteString s5 {binval5, sizeof(binval5)};
412 uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
413 OCByteString s6 {binval6, sizeof(binval6)};
414 vector<OCByteString> vect2 {s4, s5, s6};
416 vector<vector<OCByteString>> vect {vect1, vect2};
418 rep.setValue(AttrName, vect);
420 const char *expected =
422 "\\x1\\x2\\x3\\x4 \\x5\\x6\\x7\\x8 \\x9\\x0\\xa\\xb "
424 "\\xc\\xd\\xe\\xf \\x11\\x12\\x13\\x14 \\x15\\x16\\x17\\x18 "
428 EXPECT_EQ(expected, rep.getValueToString(AttrName));
429 EXPECT_EQ(expected, rep[AttrName].getValueToString());
432 TEST(OCRepresentationValueToByteString, ByteStringVectorVectorVector)
434 static const std::string AttrName = "VectorTest";
435 OCRepresentation rep;
437 uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
438 OCByteString s1 {binval1, sizeof(binval1)};
439 uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
440 OCByteString s2 {binval2, sizeof(binval2)};
441 uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
442 OCByteString s3 {binval3, sizeof(binval3)};
443 vector<OCByteString> vect11 {s1, s2, s3};
445 uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
446 OCByteString s4 {binval4, sizeof(binval4)};
447 uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
448 OCByteString s5 {binval5, sizeof(binval5)};
449 uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
450 OCByteString s6 {binval6, sizeof(binval6)};
451 vector<OCByteString> vect12 {s4, s5, s6};
453 uint8_t binval7[] = {0x19, 0x10, 0x1A, 0x1B};
454 OCByteString s7 {binval7, sizeof(binval7)};
455 uint8_t binval8[] = {0x1C, 0x1D, 0x1E, 0x1F};
456 OCByteString s8 {binval8, sizeof(binval8)};
457 vector<OCByteString> vect21 {s7, s8};
459 uint8_t binval9[] = {0x21, 0x22, 0x23, 0x24};
460 OCByteString s9 {binval9, sizeof(binval9)};
461 vector<OCByteString> vect22 {s9};
463 vector<vector<OCByteString>> vect1 {vect11, vect12};
464 vector<vector<OCByteString>> vect2 {vect21, vect22};
465 vector<vector<vector<OCByteString>>> vect {vect1, vect2};
466 rep.setValue(AttrName, vect);
467 static const std::string expected =
469 "\\x1\\x2\\x3\\x4 \\x5\\x6\\x7\\x8 \\x9\\x0\\xa\\xb "
471 "\\xc\\xd\\xe\\xf \\x11\\x12\\x13\\x14 \\x15\\x16\\x17\\x18 "
473 "\\x19\\x10\\x1a\\x1b \\x1c\\x1d\\x1e\\x1f "
475 "\\x21\\x22\\x23\\x24 "
478 EXPECT_EQ(expected, rep.getValueToString(AttrName));
479 EXPECT_EQ(expected, rep[AttrName].getValueToString());
482 TEST(OCRepresentationValueToString, SubRepresentationVector)
484 static const std::string AttrName = "VectorTest";
485 OCRepresentation rep;
487 OCRepresentation sub1;
488 OCRepresentation sub2;
489 vector<OCRepresentation> vect {sub1, sub2};
490 rep.setValue(AttrName, vect);
491 EXPECT_EQ("[OC::OCRepresentation OC::OCRepresentation ]", rep.getValueToString(AttrName));
492 EXPECT_EQ("[OC::OCRepresentation OC::OCRepresentation ]", rep[AttrName].getValueToString());
495 TEST(OCRepresentationValueToString, SubRepresentationVectorVector)
497 static const std::string AttrName = "VectorTest";
498 OCRepresentation rep;
500 OCRepresentation sub1;
501 OCRepresentation sub2;
502 OCRepresentation sub3;
503 OCRepresentation sub4;
504 vector<OCRepresentation> vect1 {sub1, sub2};
505 vector<OCRepresentation> vect2 {sub3, sub4};
506 vector<vector<OCRepresentation>> vect{vect1, vect2};
507 rep.setValue(AttrName, vect);
508 static const string Expected = "[[OC::OCRepresentation OC::OCRepresentation ]"
509 " [OC::OCRepresentation OC::OCRepresentation ] ]";
510 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
511 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
514 TEST(OCRepresentationValueToString, SubRepresentationVectorVectorVector)
516 static const std::string AttrName = "VectorTest";
517 OCRepresentation rep;
519 OCRepresentation sub1;
520 OCRepresentation sub2;
521 OCRepresentation sub3;
522 OCRepresentation sub4;
523 OCRepresentation sub5;
524 OCRepresentation sub6;
526 vector<OCRepresentation> vect11 {sub1, sub2};
527 vector<OCRepresentation> vect12 {sub3, sub4};
528 vector<vector<OCRepresentation>> vect1{vect11, vect12};
529 vector<OCRepresentation> vect21 {sub5};
530 vector<OCRepresentation> vect22 {sub6};
531 vector<vector<OCRepresentation>> vect2{vect21, vect22};
532 vector<vector<vector<OCRepresentation>>> vect{vect1, vect2};
534 rep.setValue(AttrName, vect);
535 static const string Expected =
536 "[[[OC::OCRepresentation OC::OCRepresentation ] "
537 "[OC::OCRepresentation OC::OCRepresentation ] ] "
538 "[[OC::OCRepresentation ] [OC::OCRepresentation ] ] ]";
539 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
540 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
543 // Subscript get/set (all types)
544 TEST(OCRepresentationSubscript, NullPtr)
546 static const std::string AttrName = "NullTest";
547 OCRepresentation rep;
548 rep[AttrName] = nullptr;
549 EXPECT_TRUE(rep.isNULL(AttrName));
551 std::nullptr_t repout = rep[AttrName];
552 std::nullptr_t repout2;
553 repout2 = rep[AttrName];
555 EXPECT_EQ(nullptr, repout);
556 EXPECT_EQ(nullptr, repout2);
559 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
561 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
566 TEST(OCRepresentationSubscript, Integer)
568 static const std::string AttrName = "IntTest";
569 OCRepresentation rep;
571 rep[AttrName] = repsource;
572 int repout = rep[AttrName];
574 repout2 = rep[AttrName];
576 EXPECT_EQ(repsource, repout);
577 EXPECT_EQ(repsource, repout2);
580 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
582 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
587 TEST(OCRepresentationSubscript, Double)
589 static const std::string AttrName = "DoubleTest";
590 OCRepresentation rep;
591 double repsource = -5.33;
592 rep[AttrName] = repsource;
593 double repout = rep[AttrName];
595 repout2 = rep[AttrName];
597 EXPECT_EQ(repsource, repout);
598 EXPECT_EQ(repsource, repout2);
601 EXPECT_FALSE(rep.getValue<int>(AttrName, badout));
603 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
608 //Disabled this test due to older GCC v4.6 fails for this test.
609 //We will enable it when we have a fix for it.
610 TEST(OCRepresentationSubscript, DISABLED_Boolean)
612 static const std::string AttrName = "BooleanTest";
613 OCRepresentation rep;
614 bool repsource = true;
615 rep[AttrName] = repsource;
616 bool repout = rep[AttrName];
618 repout2 = rep[AttrName];
620 EXPECT_EQ(repsource, repout);
621 EXPECT_EQ(repsource, repout2);
624 rep[AttrName] = repsource;
625 repout = rep[AttrName];
627 EXPECT_EQ(repsource, repout);
630 EXPECT_FALSE(rep.getValue<int>(AttrName, badout));
632 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
637 TEST(OCRepresentationSubscript, String)
639 static const std::string AttrName = "StringTest";
640 OCRepresentation rep;
641 string repsource = "This is a string!";
642 rep[AttrName] = repsource;
643 string repout = rep[AttrName];
645 repout2 = rep[AttrName];
647 EXPECT_EQ(repsource, repout);
648 EXPECT_EQ(repsource, repout2);
651 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
655 TEST(OCRepresentationSubscript, SubRepresentation)
657 static const std::string AttrName = "SubRepresentationTest";
658 OCRepresentation rep;
659 OCRepresentation repsource;
660 repsource.setUri("This is a uri");
662 rep[AttrName] = repsource;
663 OCRepresentation repout = rep[AttrName];
664 OCRepresentation repout2;
665 repout2 = rep[AttrName];
667 //OCRepresentation doesn't overload equality, so this just compares
668 //the value we set to ensure we got the same one out;
669 EXPECT_EQ(repsource.getUri(), repout.getUri());
670 EXPECT_EQ(repsource.getUri(), repout2.getUri());
673 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
675 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
680 TEST(OCRepresentationSubscript, IntegerVector)
682 static const std::string AttrName = "VectorTest";
683 OCRepresentation rep;
684 vector<int> repsource {1,2,3,4};
685 rep[AttrName] = repsource;
686 vector<int> repout = rep[AttrName];
688 repout2 = rep[AttrName];
690 EXPECT_EQ(repsource, repout);
691 EXPECT_EQ(repsource, repout2);
694 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
696 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
701 TEST(OCRepresentationSubscript, IntegerVectorVector)
703 static const std::string AttrName = "VectorTest";
704 OCRepresentation rep;
705 vector<vector<int>> repsource {{1,2,3,4},{5,6,7,8}};
706 rep[AttrName] = repsource;
707 vector<vector<int>> repout = rep[AttrName];
708 vector<vector<int>> repout2;
709 repout2 = rep[AttrName];
711 EXPECT_EQ(repsource, repout);
712 EXPECT_EQ(repsource, repout2);
715 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
717 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
722 TEST(OCRepresentationSubscript, IntegerVectorVectorVector)
724 static const std::string AttrName = "VectorTest";
725 OCRepresentation rep;
726 vector<vector<vector<int>>> repsource {{{1,2,3,4},{5,6,7,8}},{{9,10,11},{21,13}}};
727 rep[AttrName] = repsource;
728 vector<vector<vector<int>>> repout = rep[AttrName];
729 vector<vector<vector<int>>> repout2;
730 repout2 = rep[AttrName];
732 EXPECT_EQ(repsource, repout);
733 EXPECT_EQ(repsource, repout2);
736 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
738 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
743 TEST(OCRepresentationSubscript, DoubleVector)
745 static const std::string AttrName = "VectorTest";
746 OCRepresentation rep;
747 vector<double> repsource {1.1,2.2,3.2,4.2};
748 rep[AttrName] = repsource;
749 vector<double> repout = rep[AttrName];
750 vector<double> repout2;
751 repout2 = rep[AttrName];
753 EXPECT_EQ(repsource, repout);
754 EXPECT_EQ(repsource, repout2);
757 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
759 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
764 TEST(OCRepresentationSubscript, DoubleVectorVector)
766 static const std::string AttrName = "VectorTest";
767 OCRepresentation rep;
768 vector<vector<double>> repsource {{1.1,2.2,3.2,4.3},{5.5,6.6,7.8,.8}};
769 rep[AttrName] = repsource;
770 vector<vector<double>> repout = rep[AttrName];
771 vector<vector<double>> repout2;
772 repout2 = rep[AttrName];
774 EXPECT_EQ(repsource, repout);
775 EXPECT_EQ(repsource, repout2);
778 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
780 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
785 TEST(OCRepresentationSubscript, DoubleVectorVectorVector)
787 static const std::string AttrName = "VectorTest";
788 OCRepresentation rep;
789 vector<vector<vector<double>>> repsource {{{1.1,2.5,3.5,4.4},{.5,.6,7.8,8.9}},
790 {{9.8,10.8,11.8},{2.1,1.3}}};
791 rep[AttrName] = repsource;
792 vector<vector<vector<double>>> repout = rep[AttrName];
793 vector<vector<vector<double>>> repout2;
794 repout2 = rep[AttrName];
796 EXPECT_EQ(repsource, repout);
797 EXPECT_EQ(repsource, repout2);
800 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
802 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
807 TEST(OCRepresentationSubscript, BooleanVector)
809 static const std::string AttrName = "VectorTest";
810 OCRepresentation rep;
811 vector<bool> repsource {false, false, true};
812 rep[AttrName] = repsource;
813 vector<bool> repout = rep[AttrName];
814 vector<bool> repout2;
815 repout2 = rep[AttrName];
817 EXPECT_EQ(repsource, repout);
818 EXPECT_EQ(repsource, repout2);
821 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
823 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
828 TEST(OCRepresentationSubscript, BooleanVectorVector)
830 static const std::string AttrName = "VectorTest";
831 OCRepresentation rep;
832 vector<vector<bool>> repsource {{true, true},{false, true}};
833 rep[AttrName] = repsource;
834 vector<vector<bool>> repout = rep[AttrName];
835 vector<vector<bool>> repout2;
836 repout2 = rep[AttrName];
838 EXPECT_EQ(repsource, repout);
839 EXPECT_EQ(repsource, repout2);
842 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
844 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
849 TEST(OCRepresentationSubscript, BooleanVectorVectorVector)
851 static const std::string AttrName = "VectorTest";
852 OCRepresentation rep;
853 vector<vector<vector<bool>>> repsource {{{true, true, false},{true}},
854 {{true, false, false},{false, true, true}}};
855 rep[AttrName] = repsource;
856 vector<vector<vector<bool>>> repout = rep[AttrName];
857 vector<vector<vector<bool>>> repout2;
858 repout2 = rep[AttrName];
860 EXPECT_EQ(repsource, repout);
861 EXPECT_EQ(repsource, repout2);
864 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
866 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
871 TEST(OCRepresentationSubscript, StringVector)
873 static const std::string AttrName = "VectorTest";
874 OCRepresentation rep;
875 vector<string> repsource {"str1", "str2"};
876 rep[AttrName] = repsource;
877 vector<string> repout = rep[AttrName];
878 vector<string> repout2;
879 repout2 = rep[AttrName];
881 EXPECT_EQ(repsource, repout);
882 EXPECT_EQ(repsource, repout2);
885 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
887 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
892 TEST(OCRepresentationSubscript, StringVectorVector)
894 static const std::string AttrName = "VectorTest";
895 OCRepresentation rep;
896 vector<vector<string>> repsource {{"str1", "str2"},{"str3", "str4"}};
897 rep[AttrName] = repsource;
898 vector<vector<string>> repout = rep[AttrName];
899 vector<vector<string>> repout2;
900 repout2 = rep[AttrName];
902 EXPECT_EQ(repsource, repout);
903 EXPECT_EQ(repsource, repout2);
906 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
908 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
913 TEST(OCRepresentationSubscript, StringVectorVectorVector)
915 static const std::string AttrName = "VectorTest";
916 OCRepresentation rep;
917 vector<vector<vector<string>>> repsource {{{"str1", "str2"},{"str3", "str4"}},
918 {{"str5"},{"str6"}}};
919 rep[AttrName] = repsource;
920 vector<vector<vector<string>>> repout = rep[AttrName];
921 vector<vector<vector<string>>> repout2;
922 repout2 = rep[AttrName];
924 EXPECT_EQ(repsource, repout);
925 EXPECT_EQ(repsource, repout2);
928 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
930 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
935 TEST(OCRepresentationSubscript, SubRepresentationVector)
937 static const std::string AttrName = "VectorTest";
938 OCRepresentation rep;
939 OCRepresentation inner1, inner2;
940 inner1.setUri("inner1");
941 inner2.setUri("inner2");
942 vector<OCRepresentation> repsource {inner1, inner2};
943 rep[AttrName] = repsource;
944 vector<OCRepresentation> repout = rep[AttrName];
945 vector<OCRepresentation> repout2;
946 repout2 = rep[AttrName];
948 EXPECT_EQ(2u, repout.size());
949 EXPECT_EQ(inner1.getUri(), repout[0].getUri());
950 EXPECT_EQ(inner2.getUri(), repout[1].getUri());
951 EXPECT_EQ(2u, repout2.size());
952 EXPECT_EQ(inner1.getUri(), repout2[0].getUri());
953 EXPECT_EQ(inner2.getUri(), repout2[1].getUri());
956 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
958 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
963 TEST(OCRepresentationSubscript, SubRepresentationVectorVector)
965 static const std::string AttrName = "VectorTest";
966 OCRepresentation rep;
967 OCRepresentation inner1, inner2, inner3, inner4;
968 inner1.setUri("inner1");
969 inner2.setUri("inner2");
970 inner3.setUri("inner3");
971 inner4.setUri("inner4");
973 vector<vector<OCRepresentation>> repsource {{inner1, inner2}, {inner3, inner4}};
974 rep[AttrName] = repsource;
975 vector<vector<OCRepresentation>> repout = rep[AttrName];
976 vector<vector<OCRepresentation>> repout2;
977 repout2 = rep[AttrName];
979 EXPECT_EQ(2u, repout.size());
980 EXPECT_EQ(2u, repout[0].size());
981 EXPECT_EQ(inner1.getUri(), repout[0][0].getUri());
982 EXPECT_EQ(inner2.getUri(), repout[0][1].getUri());
983 EXPECT_EQ(2u, repout.size());
984 EXPECT_EQ(2u, repout[1].size());
985 EXPECT_EQ(inner3.getUri(), repout[1][0].getUri());
986 EXPECT_EQ(inner4.getUri(), repout[1][1].getUri());
988 EXPECT_EQ(2u, repout2.size());
989 EXPECT_EQ(2u, repout2[0].size());
990 EXPECT_EQ(inner1.getUri(), repout2[0][0].getUri());
991 EXPECT_EQ(inner2.getUri(), repout2[0][1].getUri());
992 EXPECT_EQ(2u, repout2.size());
993 EXPECT_EQ(2u, repout2[1].size());
994 EXPECT_EQ(inner3.getUri(), repout2[1][0].getUri());
995 EXPECT_EQ(inner4.getUri(), repout2[1][1].getUri());
998 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
1000 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
1005 TEST(OCRepresentationSubscript, SubRepresentationVectorVectorVector)
1007 static const std::string AttrName = "VectorTest";
1008 OCRepresentation rep;
1009 OCRepresentation inner1, inner2, inner3, inner4, inner5, inner6, inner7, inner8;
1010 inner1.setUri("inner1");
1011 inner2.setUri("inner2");
1012 inner3.setUri("inner3");
1013 inner4.setUri("inner4");
1014 inner5.setUri("inner5");
1015 inner6.setUri("inner6");
1016 inner7.setUri("inner7");
1017 inner8.setUri("inner8");
1019 vector<vector<vector<OCRepresentation>>> repsource
1020 {{{inner1, inner2},{inner3, inner4}},{{inner5, inner6},{inner7,inner8}}};
1022 rep[AttrName] = repsource;
1023 vector<vector<vector<OCRepresentation>>> repout = rep[AttrName];
1024 vector<vector<vector<OCRepresentation>>> repout2;
1025 repout2 = rep[AttrName];
1027 EXPECT_EQ(2u, repout.size());
1028 EXPECT_EQ(2u, repout[0].size());
1029 EXPECT_EQ(2u, repout[0][0].size());
1030 EXPECT_EQ(inner1.getUri(), repout[0][0][0].getUri());
1031 EXPECT_EQ(inner2.getUri(), repout[0][0][1].getUri());
1032 EXPECT_EQ(2u, repout[0][1].size());
1033 EXPECT_EQ(inner3.getUri(), repout[0][1][0].getUri());
1034 EXPECT_EQ(inner4.getUri(), repout[0][1][1].getUri());
1035 EXPECT_EQ(2u, repout[1].size());
1036 EXPECT_EQ(2u, repout[1][0].size());
1037 EXPECT_EQ(inner5.getUri(), repout[1][0][0].getUri());
1038 EXPECT_EQ(inner6.getUri(), repout[1][0][1].getUri());
1039 EXPECT_EQ(2u, repout[1][1].size());
1040 EXPECT_EQ(inner7.getUri(), repout[1][1][0].getUri());
1041 EXPECT_EQ(inner8.getUri(), repout[1][1][1].getUri());
1043 EXPECT_EQ(2u, repout2.size());
1044 EXPECT_EQ(2u, repout2[0].size());
1045 EXPECT_EQ(2u, repout2[0][0].size());
1046 EXPECT_EQ(inner1.getUri(), repout2[0][0][0].getUri());
1047 EXPECT_EQ(inner2.getUri(), repout2[0][0][1].getUri());
1048 EXPECT_EQ(2u, repout[0][1].size());
1049 EXPECT_EQ(inner3.getUri(), repout2[0][1][0].getUri());
1050 EXPECT_EQ(inner4.getUri(), repout2[0][1][1].getUri());
1051 EXPECT_EQ(2u, repout[1].size());
1052 EXPECT_EQ(2u, repout[1][0].size());
1053 EXPECT_EQ(inner5.getUri(), repout2[1][0][0].getUri());
1054 EXPECT_EQ(inner6.getUri(), repout2[1][0][1].getUri());
1055 EXPECT_EQ(2u, repout[1][1].size());
1056 EXPECT_EQ(inner7.getUri(), repout2[1][1][0].getUri());
1057 EXPECT_EQ(inner8.getUri(), repout2[1][1][1].getUri());
1060 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
1062 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
1067 TEST(OCRepresentationIterator, constiterator)
1069 OCRepresentation rep;
1071 EXPECT_TRUE(rep.empty());
1072 rep.setValue("int", 8);
1073 EXPECT_FALSE(rep.empty());
1074 rep.setValue("double", 8.8);
1075 rep.setValue("bool", true);
1076 rep.setValue("string", std::string("this is a string"));
1078 EXPECT_EQ(4u, rep.size());
1079 EXPECT_FALSE(rep.empty());
1081 OCRepresentation::const_iterator itr = rep.cbegin();
1082 OCRepresentation::const_iterator endItr = rep.cend();
1083 for(;itr!=endItr;++itr);
1085 const OCRepresentation& rep2(rep);
1086 OCRepresentation::const_iterator itr2 = rep2.begin();
1087 OCRepresentation::const_iterator endItr2 = rep2.end();
1088 for(;itr2!=endItr2;++itr2);
1092 TEST(OCRepresentationIterator, constautoiterator)
1094 OCRepresentation rep;
1096 EXPECT_TRUE(rep.empty());
1097 rep.setValue("int", 8);
1098 EXPECT_FALSE(rep.empty());
1099 rep.setValue("double", 8.8);
1100 rep.setValue("bool", true);
1101 rep.setValue("string", std::string("this is a string"));
1103 EXPECT_EQ(4u, rep.size());
1104 EXPECT_FALSE(rep.empty());
1106 for(const auto& a : rep)
1111 const OCRepresentation& rep2(rep);
1112 for(const auto& a : rep2)
1117 TEST(OCRepresentationIterator, autoiterator)
1119 OCRepresentation rep;
1121 EXPECT_TRUE(rep.empty());
1122 rep.setValue("int", 8);
1123 EXPECT_FALSE(rep.empty());
1124 rep.setValue("double", 8.8);
1125 rep.setValue("bool", true);
1126 rep.setValue("string", std::string("this is a string"));
1128 EXPECT_EQ(4u, rep.size());
1129 EXPECT_FALSE(rep.empty());
1131 for(auto& cur : rep)
1133 if(cur.attrname() == "int")
1135 EXPECT_EQ("int", cur.attrname());
1136 EXPECT_EQ(AttributeType::Integer, cur.type());
1137 EXPECT_EQ(AttributeType::Integer, cur.base_type());
1138 EXPECT_EQ(0u, cur.depth());
1139 int curInt = cur.getValue<int>();
1140 EXPECT_EQ(8, curInt);
1142 if(cur.attrname() == "double")
1144 EXPECT_EQ("double", cur.attrname());
1145 EXPECT_EQ(AttributeType::Double, cur.type());
1146 EXPECT_EQ(AttributeType::Double, cur.base_type());
1147 EXPECT_EQ(0u, cur.depth());
1148 double curDouble = cur.getValue<double>();
1149 EXPECT_EQ(8.8, curDouble);
1151 if(cur.attrname() == "bool")
1153 EXPECT_EQ("bool", cur.attrname());
1154 EXPECT_EQ(AttributeType::Boolean, cur.type());
1155 EXPECT_EQ(AttributeType::Boolean, cur.base_type());
1156 EXPECT_EQ(0u, cur.depth());
1157 bool curBool = cur.getValue<bool>();
1158 EXPECT_EQ(true, curBool);
1160 if(cur.attrname() == "string")
1162 EXPECT_EQ("string", cur.attrname());
1163 EXPECT_EQ(AttributeType::String, cur.type());
1164 EXPECT_EQ(AttributeType::String, cur.base_type());
1165 EXPECT_EQ(0u, cur.depth());
1166 string curStr = cur.getValue<string>();
1167 EXPECT_EQ("this is a string", curStr);
1172 TEST(OCRepresentationIterator, iterator)
1174 OCRepresentation rep;
1175 OCRepresentation sub1;
1176 sub1.setUri("sub rep1 URI");
1177 OCRepresentation sub2;
1178 sub2.setUri("sub rep2 URI");
1179 OCRepresentation sub3;
1180 sub3.setUri("sub rep3 URI");
1181 OCRepresentation sub4;
1182 sub4.setUri("sub rep4 URI");
1183 OCRepresentation sub5;
1184 sub5.setUri("sub rep5 URI");
1185 OCRepresentation sub6;
1186 sub6.setUri("sub rep6 URI");
1189 EXPECT_TRUE(rep.empty());
1190 rep.setValue("int", 8);
1191 EXPECT_FALSE(rep.empty());
1192 rep.setValue("double", 8.8);
1193 rep.setValue("bool", true);
1194 rep.setValue("string", std::string("this is a string"));
1195 rep.setValue("rep", sub1);
1197 vector<int> intv {1,2,3,4};
1198 rep.setValue("intv", intv);
1199 vector<double> doublev {1.1,2.2,3.3,4.4};
1200 rep.setValue("doublev", doublev);
1201 vector<bool> boolv{false, false, true};
1202 rep.setValue("boolv", boolv);
1203 vector<string> strv{"abc", "def", "ghi"};
1204 rep.setValue("strv", strv);
1205 vector<OCRepresentation> repv { sub1, sub2 };
1206 rep.setValue("repv", repv);
1208 vector<vector<int>> intvv{{1,2,3},{4,5,6}};
1209 rep.setValue("intvv", intvv);
1210 vector<vector<vector<int>>> intvvv{{{1,2},{3,4}},{{5,6},{8,7}}};
1211 rep.setValue("intvvv", intvvv);
1213 vector<vector<double>> doublevv{{1.1,2.1,3},{4.4,5.4,6.4}};
1214 rep.setValue("doublevv", doublevv);
1215 vector<vector<vector<double>>> doublevvv{{{1.1,2.1},{3.1,4.1}},{{5.1,6.1},{8.1,7.1}}};
1216 rep.setValue("doublevvv", doublevvv);
1218 vector<vector<bool>> boolvv{{false, true},{true, false}};
1219 rep.setValue("boolvv", boolvv);
1220 vector<vector<vector<bool>>> boolvvv{{{true, false},{true}},{{false},{true}}};
1221 rep.setValue("boolvvv", boolvvv);
1223 vector<vector<string>> strvv{{"abc", "def"},{"wer", "qwer"}};
1224 rep.setValue("strvv", strvv);
1225 vector<vector<vector<string>>> strvvv{{{"wqr", "xcv"},{"234"}},{{"we"},{"wert"}}};
1226 rep.setValue("strvvv", strvvv);
1228 vector<vector<OCRepresentation>> repvv{{sub1, sub2},{sub3, sub4}};
1229 rep.setValue("repvv", repvv);
1230 vector<vector<vector<OCRepresentation>>> repvvv{{{sub5},{sub6}},{{sub3},{sub2}}};
1231 rep.setValue("repvvv", repvvv);
1233 EXPECT_EQ(20u, rep.size());
1234 EXPECT_FALSE(rep.empty());
1236 OCRepresentation::iterator itr= rep.begin();
1237 OCRepresentation::iterator endItr = rep.end();
1239 for(;itr!=endItr;++itr)
1241 if(itr->attrname() == "int")
1243 EXPECT_EQ("int", itr->attrname());
1244 EXPECT_EQ(AttributeType::Integer, itr->type());
1245 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1246 EXPECT_EQ(0u, itr->depth());
1247 int curInt = (*itr).getValue<int>();
1248 EXPECT_EQ(8, curInt);
1250 else if (itr->attrname() == "double")
1252 EXPECT_EQ("double", itr->attrname());
1253 EXPECT_EQ(AttributeType::Double, itr->type());
1254 EXPECT_EQ(AttributeType::Double, itr->base_type());
1255 EXPECT_EQ(0u, itr->depth());
1256 double curDouble = (*itr).getValue<double>();
1257 EXPECT_EQ(8.8, curDouble);
1259 else if (itr->attrname() == "bool")
1261 EXPECT_EQ("bool", itr->attrname());
1262 EXPECT_EQ(AttributeType::Boolean, itr->type());
1263 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1264 EXPECT_EQ(0u, itr->depth());
1265 bool curBool = (*itr).getValue<bool>();
1266 EXPECT_EQ(true, curBool);
1268 else if (itr->attrname() == "string")
1270 EXPECT_EQ("string", itr->attrname());
1271 EXPECT_EQ(AttributeType::String, itr->type());
1272 EXPECT_EQ(AttributeType::String, itr->base_type());
1273 EXPECT_EQ(0u, itr->depth());
1274 string curString = (*itr).getValue<string>();
1275 EXPECT_EQ("this is a string", curString);
1277 else if (itr->attrname() == "rep")
1279 EXPECT_EQ("rep", itr->attrname());
1280 EXPECT_EQ(AttributeType::OCRepresentation, itr->type());
1281 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1282 EXPECT_EQ(0u, itr->depth());
1283 OCRepresentation curRep = (*itr).getValue<OCRepresentation>();
1284 EXPECT_EQ(sub1.getUri(), curRep.getUri());
1286 else if (itr->attrname() == "intv")
1288 EXPECT_EQ("intv", itr->attrname());
1289 EXPECT_EQ(AttributeType::Vector, itr->type());
1290 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1291 EXPECT_EQ(1u, itr->depth());
1292 vector<int> curv = (*itr).getValue<vector<int>>();
1293 EXPECT_EQ(intv, curv);
1295 else if (itr->attrname() == "doublev")
1297 EXPECT_EQ("doublev", itr->attrname());
1298 EXPECT_EQ(AttributeType::Vector, itr->type());
1299 EXPECT_EQ(AttributeType::Double, itr->base_type());
1300 EXPECT_EQ(1u, itr->depth());
1301 vector<double> curv = (*itr).getValue<vector<double>>();
1302 EXPECT_EQ(doublev, curv);
1304 else if (itr->attrname() == "boolv")
1306 EXPECT_EQ("boolv", itr->attrname());
1307 EXPECT_EQ(AttributeType::Vector, itr->type());
1308 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1309 EXPECT_EQ(1u, itr->depth());
1310 vector<bool> curv = (*itr).getValue<vector<bool>>();
1311 EXPECT_EQ(boolv, curv);
1313 else if (itr->attrname() == "strv")
1315 EXPECT_EQ("strv", itr->attrname());
1316 EXPECT_EQ(AttributeType::Vector, itr->type());
1317 EXPECT_EQ(AttributeType::String, itr->base_type());
1318 EXPECT_EQ(1u, itr->depth());
1319 vector<string> curv = (*itr).getValue<vector<string>>();
1320 EXPECT_EQ(strv, curv);
1322 else if (itr->attrname() == "repv")
1324 EXPECT_EQ("repv", itr->attrname());
1325 EXPECT_EQ(AttributeType::Vector, itr->type());
1326 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1327 EXPECT_EQ(1u, itr->depth());
1328 vector<OCRepresentation> curv = (*itr).getValue<vector<OCRepresentation>>();
1329 EXPECT_EQ(2u, repv.size());
1330 EXPECT_EQ(sub1.getUri(), repv[0].getUri());
1331 EXPECT_EQ(sub2.getUri(), repv[1].getUri());
1333 else if (itr->attrname() == "intvv")
1335 EXPECT_EQ("intvv", itr->attrname());
1336 EXPECT_EQ(AttributeType::Vector, itr->type());
1337 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1338 EXPECT_EQ(2u, itr->depth());
1339 vector<vector<int>> curv = (*itr).getValue<vector<vector<int>>>();
1340 EXPECT_EQ(intvv, curv);
1342 else if (itr->attrname() == "intvvv")
1344 EXPECT_EQ("intvvv", itr->attrname());
1345 EXPECT_EQ(AttributeType::Vector, itr->type());
1346 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1347 EXPECT_EQ(3u, itr->depth());
1348 vector<vector<vector<int>>> curv = (*itr).getValue<vector<vector<vector<int>>>>();
1349 EXPECT_EQ(intvvv, curv);
1351 else if (itr->attrname() == "doublevv")
1353 EXPECT_EQ("doublevv", itr->attrname());
1354 EXPECT_EQ(AttributeType::Vector, itr->type());
1355 EXPECT_EQ(AttributeType::Double, itr->base_type());
1356 EXPECT_EQ(2u, itr->depth());
1357 vector<vector<double>> curv = (*itr).getValue<vector<vector<double>>>();
1358 EXPECT_EQ(doublevv, curv);
1360 else if (itr->attrname() == "doublevvv")
1362 EXPECT_EQ("doublevvv", itr->attrname());
1363 EXPECT_EQ(AttributeType::Vector, itr->type());
1364 EXPECT_EQ(AttributeType::Double, itr->base_type());
1365 EXPECT_EQ(3u, itr->depth());
1366 vector<vector<vector<double>>> curv =
1367 (*itr).getValue<vector<vector<vector<double>>>>();
1368 EXPECT_EQ(doublevvv, curv);
1370 else if (itr->attrname() == "boolvv")
1372 EXPECT_EQ("boolvv", itr->attrname());
1373 EXPECT_EQ(AttributeType::Vector, itr->type());
1374 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1375 EXPECT_EQ(2u, itr->depth());
1376 vector<vector<bool>> curv = (*itr).getValue<vector<vector<bool>>>();
1377 EXPECT_EQ(boolvv, curv);
1379 else if (itr->attrname() == "boolvvv")
1381 EXPECT_EQ("boolvvv", itr->attrname());
1382 EXPECT_EQ(AttributeType::Vector, itr->type());
1383 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1384 EXPECT_EQ(3u, itr->depth());
1385 vector<vector<vector<bool>>> curv = (*itr).getValue<vector<vector<vector<bool>>>>();
1386 EXPECT_EQ(boolvvv, curv);
1388 else if (itr->attrname() == "strvv")
1390 EXPECT_EQ("strvv", itr->attrname());
1391 EXPECT_EQ(AttributeType::Vector, itr->type());
1392 EXPECT_EQ(AttributeType::String, itr->base_type());
1393 EXPECT_EQ(2u, itr->depth());
1394 vector<vector<string>> curv = (*itr).getValue<vector<vector<string>>>();
1395 EXPECT_EQ(strvv, curv);
1397 else if (itr->attrname() == "strvvv")
1399 EXPECT_EQ("strvvv", itr->attrname());
1400 EXPECT_EQ(AttributeType::Vector, itr->type());
1401 EXPECT_EQ(AttributeType::String, itr->base_type());
1402 EXPECT_EQ(3u, itr->depth());
1403 vector<vector<vector<string>>> curv =
1404 (*itr).getValue<vector<vector<vector<string>>>>();
1405 EXPECT_EQ(strvvv, curv);
1407 else if (itr->attrname() == "repvv")
1409 EXPECT_EQ("repvv", itr->attrname());
1410 EXPECT_EQ(AttributeType::Vector, itr->type());
1411 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1412 EXPECT_EQ(2u, itr->depth());
1413 vector<vector<OCRepresentation>> curv =
1414 (*itr).getValue<vector<vector<OCRepresentation>>>();
1415 EXPECT_EQ(2u, curv.size());
1416 EXPECT_EQ(2u, curv[0].size());
1417 EXPECT_EQ(sub1.getUri(), curv[0][0].getUri());
1418 EXPECT_EQ(sub2.getUri(), curv[0][1].getUri());
1419 EXPECT_EQ(2u, curv[1].size());
1420 EXPECT_EQ(sub3.getUri(), curv[1][0].getUri());
1421 EXPECT_EQ(sub4.getUri(), curv[1][1].getUri());
1423 else if (itr->attrname() == "repvvv")
1425 EXPECT_EQ("repvvv", itr->attrname());
1426 EXPECT_EQ(AttributeType::Vector, itr->type());
1427 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1428 EXPECT_EQ(3u, itr->depth());
1429 vector<vector<vector<OCRepresentation>>> curv =
1430 (*itr).getValue<vector<vector<vector<OCRepresentation>>>>();
1431 EXPECT_EQ(2u, curv.size());
1432 EXPECT_EQ(2u, curv[0].size());
1433 EXPECT_EQ(1u, curv[0][0].size());
1434 EXPECT_EQ(sub5.getUri(), curv[0][0][0].getUri());
1435 EXPECT_EQ(1u, curv[0][1].size());
1436 EXPECT_EQ(sub6.getUri(), curv[0][1][0].getUri());
1437 EXPECT_EQ(1u, curv[1][0].size());
1438 EXPECT_EQ(sub3.getUri(), curv[1][0][0].getUri());
1439 EXPECT_EQ(1u, curv[1][1].size());
1440 EXPECT_EQ(sub2.getUri(), curv[1][1][0].getUri());
1444 EXPECT_TRUE(false) << itr->attrname();
1449 TEST(OCRepresentationHostTest, ValidHost)
1451 OCDevAddr addr = {OC_DEFAULT_ADAPTER, OC_IP_USE_V6};
1453 OICStrcpy(addr.addr, sizeof(addr.addr), "fe80::1%eth0");
1455 OCRepresentation rep;
1456 rep.setDevAddr(addr);
1457 std::string host = rep.getHost();
1458 std::string expected = "coap://[fe80::1%25eth0]:5000";
1459 EXPECT_EQ(host, expected);
1462 TEST(OCRepresentationHostTest, InvalidHost)
1464 OCDevAddr addr = {OC_DEFAULT_ADAPTER, OC_IP_USE_V6};
1466 OICStrcpy(addr.addr, sizeof(addr.addr), "fe80::1%%");
1468 OCRepresentation rep;
1469 EXPECT_ANY_THROW(rep.setDevAddr(addr));