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>
25 #include <boost/lexical_cast.hpp>
26 namespace OCRepresentationTest
32 void parsedEqual(double expected, const std::string& actualStr)
34 double actual = boost::lexical_cast<double>(actualStr);
35 EXPECT_GE(actual, expected - .0000001);
36 EXPECT_LE(actual, expected + .0000001);
39 // getValueToString(all types)
40 TEST(OCRepresentationValueToString, Null)
42 static const std::string AttrName = "NullTest";
44 rep.setNULL(AttrName);
46 EXPECT_TRUE(rep.isNULL(AttrName));
47 EXPECT_EQ("(null)", rep.getValueToString(AttrName));
48 EXPECT_EQ("(null)", rep[AttrName].getValueToString());
51 TEST(OCRepresentationValueToString, Integer)
53 static const std::string AttrName = "IntTest";
56 rep.setValue(AttrName, -5);
57 EXPECT_EQ("-5", rep.getValueToString(AttrName));
58 EXPECT_EQ("-5", rep[AttrName].getValueToString());
60 rep.setValue(AttrName, 0);
61 EXPECT_EQ("0", rep.getValueToString(AttrName));
62 EXPECT_EQ("0", rep[AttrName].getValueToString());
64 rep.setValue(AttrName, 5);
65 EXPECT_EQ("5", rep.getValueToString(AttrName));
66 EXPECT_EQ("5", rep[AttrName].getValueToString());
68 rep.setValue(AttrName, 54321);
69 EXPECT_EQ("54321", rep.getValueToString(AttrName));
70 EXPECT_EQ("54321", rep[AttrName].getValueToString());
73 TEST(OCRepresentationValueToString, Double)
75 static const std::string AttrName = "DoubleTest";
78 rep.setValue(AttrName, -5.0);
79 parsedEqual(-5.0, rep.getValueToString(AttrName));
80 parsedEqual(-5.0, rep[AttrName].getValueToString());
82 rep.setValue(AttrName, 0.0);
83 parsedEqual(0.0, rep.getValueToString(AttrName));
84 parsedEqual(0.0, rep[AttrName].getValueToString());
86 rep.setValue(AttrName, 5.0);
87 parsedEqual(5.0, rep.getValueToString(AttrName));
88 parsedEqual(5.0, rep[AttrName].getValueToString());
90 rep.setValue(AttrName, 54321.0);
91 parsedEqual(54321.0, rep.getValueToString(AttrName));
92 parsedEqual(54321.0, rep[AttrName].getValueToString());
94 rep.setValue(AttrName, 3.55);
95 parsedEqual(3.55, rep.getValueToString(AttrName));
96 parsedEqual(3.55, rep[AttrName].getValueToString());
98 rep.setValue(AttrName, -4.95);
99 parsedEqual(-4.95, rep.getValueToString(AttrName));
100 parsedEqual(-4.95, rep[AttrName].getValueToString());
102 rep.setValue(AttrName, 99999.5555);
103 parsedEqual(99999.5555, rep.getValueToString(AttrName));
104 parsedEqual(99999.5555, rep[AttrName].getValueToString());
107 TEST(OCRepresentationValueToString, Boolean)
109 static const std::string AttrName = "BooleanTest";
110 OCRepresentation rep;
112 rep.setValue(AttrName, false);
113 EXPECT_EQ("false", rep.getValueToString(AttrName));
114 EXPECT_EQ("false", rep[AttrName].getValueToString());
116 rep.setValue(AttrName, true);
117 EXPECT_EQ("true", rep.getValueToString(AttrName));
118 EXPECT_EQ("true", rep[AttrName].getValueToString());
121 TEST(OCRepresentationValueToString, String)
123 static const std::string AttrName = "StringTest";
124 OCRepresentation rep;
126 rep.setValue(AttrName, std::string("test 1"));
127 EXPECT_EQ("test 1", rep.getValueToString(AttrName));
128 EXPECT_EQ("test 1", rep[AttrName].getValueToString());
130 rep.setValue(AttrName, std::string("test 2"));
131 EXPECT_EQ("test 2", rep.getValueToString(AttrName));
132 EXPECT_EQ("test 2", rep[AttrName].getValueToString());
135 TEST(OCRepresentationValueToString, SubRepresentation)
137 static const std::string AttrName = "SubRepTest";
138 OCRepresentation rep;
139 OCRepresentation sub1;
140 OCRepresentation sub2;
142 rep.setValue(AttrName, sub1);
143 EXPECT_EQ("OC::OCRepresentation", rep.getValueToString(AttrName));
144 EXPECT_EQ("OC::OCRepresentation", rep[AttrName].getValueToString());
146 rep.setValue(AttrName, sub2);
147 EXPECT_EQ("OC::OCRepresentation", rep.getValueToString(AttrName));
148 EXPECT_EQ("OC::OCRepresentation", rep[AttrName].getValueToString());
151 TEST(OCRepresentationValueToString, ByteString)
153 static const std::string AttrName = "ByteStringTest";
154 static uint8_t binval[] = {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8,
155 0x9, 0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF};
157 OCByteString bytestring {binval, sizeof(binval)};
158 OCRepresentation rep;
160 rep.setValue(AttrName, bytestring);
161 const char* expected = "\\x1\\x2\\x3\\x4\\x5\\x6\\x7\\x8"
162 "\\x9\\x0\\xa\\xb\\xc\\xd\\xe\\xf";
163 EXPECT_STREQ(expected, rep.getValueToString(AttrName).c_str() );
166 TEST(OCRepresentationValueToString, IntegerVector)
168 static const std::string AttrName = "VectorTest";
169 OCRepresentation rep;
171 vector<int> vect {1,2,3,4,5,6,7,8,9};
172 vector<int> vect2 {-5,-3,-1,0,5,3,2};
173 rep.setValue(AttrName, vect);
174 EXPECT_EQ("[1 2 3 4 5 6 7 8 9 ]", rep.getValueToString(AttrName));
175 EXPECT_EQ("[1 2 3 4 5 6 7 8 9 ]", rep[AttrName].getValueToString());
177 rep.setValue(AttrName, vect2);
178 EXPECT_EQ("[-5 -3 -1 0 5 3 2 ]", rep.getValueToString(AttrName));
179 EXPECT_EQ("[-5 -3 -1 0 5 3 2 ]", rep[AttrName].getValueToString());
182 TEST(OCRepresentationValueToString, IntegerVectorVector)
184 static const std::string AttrName = "VectorTest";
185 OCRepresentation rep;
187 vector<int> vect1 {1,2,3,4,5,6,7,8,9};
188 vector<int> vect2 {-5,-3,-1,0,5,3,2};
189 vector<vector<int>> vect{vect1, vect2};
191 rep.setValue(AttrName, vect);
192 static const string Expected = "[[1 2 3 4 5 6 7 8 9 ] [-5 -3 -1 0 5 3 2 ] ]";
193 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
194 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
197 TEST(OCRepresentationValueToString, IntegerVectorVectorVector)
199 static const std::string AttrName = "VectorTest";
200 OCRepresentation rep;
202 vector<int> vect11 {1,2,3,4,5,6,7,8,9};
203 vector<int> vect12 {-5,-3,-1,0,5,3,2};
204 vector<vector<int>> vect1{vect11, vect12};
205 vector<int> vect21 {2,0,1,6,9,3,8};
206 vector<int> vect22 {9,7,8,100003};
207 vector<vector<int>> vect2{vect21, vect22};
208 vector<vector<vector<int>>> vect{vect1, vect2};
209 rep.setValue(AttrName, vect);
210 static const std::string Expected =
211 "[[[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 ] ] ]";
212 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
213 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
216 TEST(OCRepresentationValueToString, DoubleVector)
218 static const std::string AttrName = "VectorTest";
219 OCRepresentation rep;
221 vector<double> vect {3.12, -5.3, 7.5, 1.110};
222 vector<double> vect2 {2.1, -555.5, 0.0001, -0.2};
223 rep.setValue(AttrName, vect);
224 EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
226 rep.setValue(AttrName, vect2);
227 EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
230 TEST(OCRepresentationValueToString, DoubleVectorVector)
232 static const std::string AttrName = "VectorTest";
233 OCRepresentation rep;
234 vector<double> vect1 {30.1,5.88,-22.0,0};
235 vector<double> vect2 {2.1,-55.5,0.1100,-.2};
236 vector<vector<double>> vect{vect1, vect2};
238 rep.setValue(AttrName, vect);
239 EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
242 TEST(OCRepresentationValueToString, DoubleVectorVectorVector)
244 static const std::string AttrName = "VectorTest";
245 OCRepresentation rep;
247 vector<double> vect11 {3.01, 5.88, -22.0, 0.0};
248 vector<double> vect12 {99.3,8.0,.01236,-.22};
249 vector<vector<double>> vect1{vect11, vect12};
250 vector<double> vect21 {9.0,-1};
251 vector<double> vect22 {-99.2};
252 vector<vector<double>> vect2{vect21, vect22};
253 vector<vector<vector<double>>> vect{vect1, vect2};
254 rep.setValue(AttrName, vect);
255 EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
258 TEST(OCRepresentationValueToString, BooleanVector)
260 static const std::string AttrName = "VectorTest";
261 OCRepresentation rep;
263 vector<bool> vect {true, false, false, true};
264 vector<bool> vect2 {false, false, false, true};
265 rep.setValue(AttrName, vect);
266 EXPECT_EQ("[true false false true ]", rep.getValueToString(AttrName));
267 EXPECT_EQ("[true false false true ]", rep[AttrName].getValueToString());
269 rep.setValue(AttrName, vect2);
270 EXPECT_EQ("[false false false true ]", rep.getValueToString(AttrName));
271 EXPECT_EQ("[false false false true ]", rep[AttrName].getValueToString());
274 TEST(OCRepresentationValueToString, BooleanVectorVector)
276 static const std::string AttrName = "VectorTest";
277 OCRepresentation rep;
279 vector<bool> vect1 {true, false, false, true};
280 vector<bool> vect2 {false, false, false, true};
281 vector<vector<bool>> vect{vect1, vect2};
283 rep.setValue(AttrName, vect);
284 static const string Expected="[[true false false true ] [false false false true ] ]";
286 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
287 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
290 TEST(OCRepresentationValueToString, BooleanVectorVectorVector)
292 static const std::string AttrName = "VectorTest";
293 OCRepresentation rep;
295 vector<bool> vect11 {true, false, false, true};
296 vector<bool> vect12 {false, false, false, true};
297 vector<vector<bool>> vect1{vect11, vect12};
298 vector<bool> vect21 {false, true, true, false};
299 vector<bool> vect22 {true, true, true, false};
300 vector<vector<bool>> vect2{vect21, vect22};
301 vector<vector<vector<bool>>> vect{vect1, vect2};
302 rep.setValue(AttrName, vect);
303 static const std::string Expected =
304 "[[[true false false true ] [false false false true ] ]"
305 " [[false true true false ] [true true true false ] ] ]";
306 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
307 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
310 TEST(OCRepresentationValueToString, StringVector)
312 static const std::string AttrName = "VectorTest";
313 OCRepresentation rep;
315 vector<string> vect {"s1", "s2", "s3"};
316 vector<string> vect2 {"s4", "s5", "s6"};
317 rep.setValue(AttrName, vect);
318 EXPECT_EQ("[s1 s2 s3 ]", rep.getValueToString(AttrName));
319 EXPECT_EQ("[s1 s2 s3 ]", rep[AttrName].getValueToString());
321 rep.setValue(AttrName, vect2);
322 EXPECT_EQ("[s4 s5 s6 ]", rep.getValueToString(AttrName));
323 EXPECT_EQ("[s4 s5 s6 ]", rep[AttrName].getValueToString());
326 TEST(OCRepresentationValueToString, StringVectorVector)
328 static const std::string AttrName = "VectorTest";
329 OCRepresentation rep;
331 vector<string> vect1 {"s1", "s2", "s3"};
332 vector<string> vect2 {"s4", "s5", "s6"};
333 vector<vector<string>> vect{vect1, vect2};
335 rep.setValue(AttrName, vect);
336 static const string Expected="[[s1 s2 s3 ] [s4 s5 s6 ] ]";
338 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
339 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
342 TEST(OCRepresentationValueToString, StringVectorVectorVector)
344 static const std::string AttrName = "VectorTest";
345 OCRepresentation rep;
347 vector<string> vect11 {"s1", "s2", "s3"};
348 vector<string> vect12 {"s4", "s5", "s6"};
349 vector<vector<string>> vect1{vect11, vect12};
350 vector<string> vect21 {"s7", "s8"};
351 vector<string> vect22 {"s9"};
352 vector<vector<string>> vect2{vect21, vect22};
353 vector<vector<vector<string>>> vect{vect1, vect2};
354 rep.setValue(AttrName, vect);
355 static const std::string Expected =
356 "[[[s1 s2 s3 ] [s4 s5 s6 ] ]"
357 " [[s7 s8 ] [s9 ] ] ]";
358 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
359 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
362 TEST(OCRepresentationValueToByteString, ByteStringVector)
364 static const std::string AttrName = "VectorTest";
365 OCRepresentation rep;
367 uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
368 OCByteString s1 {binval1, sizeof(binval1)};
369 uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
370 OCByteString s2 {binval2, sizeof(binval2)};
371 uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
372 OCByteString s3 {binval3, sizeof(binval3)};
373 vector<OCByteString> vect {s1, s2, s3};
375 uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
376 OCByteString s4 {binval4, sizeof(binval4)};
377 uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
378 OCByteString s5 {binval5, sizeof(binval5)};
379 uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
380 OCByteString s6 {binval6, sizeof(binval6)};
381 vector<OCByteString> vect2 {s4, s5, s6};
383 rep.setValue(AttrName, vect);
384 const char *expected1tob = "[\\x1\\x2\\x3\\x4 \\x5\\x6\\x7\\x8 \\x9\\x0\\xa\\xb ]";
385 EXPECT_EQ(expected1tob, rep.getValueToString(AttrName));
386 EXPECT_EQ(expected1tob, rep[AttrName].getValueToString());
388 rep.setValue(AttrName, vect2);
389 const char *expectedcto18 = "[\\xc\\xd\\xe\\xf \\x11\\x12\\x13\\x14 \\x15\\x16\\x17\\x18 ]";
390 EXPECT_EQ(expectedcto18, rep.getValueToString(AttrName));
391 EXPECT_EQ(expectedcto18, rep[AttrName].getValueToString());
394 TEST(OCRepresentationValueToByteString, ByteStringVectorVector)
396 static const std::string AttrName = "VectorTest";
397 OCRepresentation rep;
399 uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
400 OCByteString s1 {binval1, sizeof(binval1)};
401 uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
402 OCByteString s2 {binval2, sizeof(binval2)};
403 uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
404 OCByteString s3 {binval3, sizeof(binval3)};
405 vector<OCByteString> vect1 {s1, s2, s3};
407 uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
408 OCByteString s4 {binval4, sizeof(binval4)};
409 uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
410 OCByteString s5 {binval5, sizeof(binval5)};
411 uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
412 OCByteString s6 {binval6, sizeof(binval6)};
413 vector<OCByteString> vect2 {s4, s5, s6};
415 vector<vector<OCByteString>> vect {vect1, vect2};
417 rep.setValue(AttrName, vect);
419 const char *expected =
421 "\\x1\\x2\\x3\\x4 \\x5\\x6\\x7\\x8 \\x9\\x0\\xa\\xb "
423 "\\xc\\xd\\xe\\xf \\x11\\x12\\x13\\x14 \\x15\\x16\\x17\\x18 "
427 EXPECT_EQ(expected, rep.getValueToString(AttrName));
428 EXPECT_EQ(expected, rep[AttrName].getValueToString());
431 TEST(OCRepresentationValueToByteString, ByteStringVectorVectorVector)
433 static const std::string AttrName = "VectorTest";
434 OCRepresentation rep;
436 uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
437 OCByteString s1 {binval1, sizeof(binval1)};
438 uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
439 OCByteString s2 {binval2, sizeof(binval2)};
440 uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
441 OCByteString s3 {binval3, sizeof(binval3)};
442 vector<OCByteString> vect11 {s1, s2, s3};
444 uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
445 OCByteString s4 {binval4, sizeof(binval4)};
446 uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
447 OCByteString s5 {binval5, sizeof(binval5)};
448 uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
449 OCByteString s6 {binval6, sizeof(binval6)};
450 vector<OCByteString> vect12 {s4, s5, s6};
452 uint8_t binval7[] = {0x19, 0x10, 0x1A, 0x1B};
453 OCByteString s7 {binval7, sizeof(binval7)};
454 uint8_t binval8[] = {0x1C, 0x1D, 0x1E, 0x1F};
455 OCByteString s8 {binval8, sizeof(binval8)};
456 vector<OCByteString> vect21 {s7, s8};
458 uint8_t binval9[] = {0x21, 0x22, 0x23, 0x24};
459 OCByteString s9 {binval9, sizeof(binval9)};
460 vector<OCByteString> vect22 {s9};
462 vector<vector<OCByteString>> vect1 {vect11, vect12};
463 vector<vector<OCByteString>> vect2 {vect21, vect22};
464 vector<vector<vector<OCByteString>>> vect {vect1, vect2};
465 rep.setValue(AttrName, vect);
466 static const std::string expected =
468 "\\x1\\x2\\x3\\x4 \\x5\\x6\\x7\\x8 \\x9\\x0\\xa\\xb "
470 "\\xc\\xd\\xe\\xf \\x11\\x12\\x13\\x14 \\x15\\x16\\x17\\x18 "
472 "\\x19\\x10\\x1a\\x1b \\x1c\\x1d\\x1e\\x1f "
474 "\\x21\\x22\\x23\\x24 "
477 EXPECT_EQ(expected, rep.getValueToString(AttrName));
478 EXPECT_EQ(expected, rep[AttrName].getValueToString());
481 TEST(OCRepresentationValueToString, SubRepresentationVector)
483 static const std::string AttrName = "VectorTest";
484 OCRepresentation rep;
486 OCRepresentation sub1;
487 OCRepresentation sub2;
488 vector<OCRepresentation> vect {sub1, sub2};
489 rep.setValue(AttrName, vect);
490 EXPECT_EQ("[OC::OCRepresentation OC::OCRepresentation ]", rep.getValueToString(AttrName));
491 EXPECT_EQ("[OC::OCRepresentation OC::OCRepresentation ]", rep[AttrName].getValueToString());
494 TEST(OCRepresentationValueToString, SubRepresentationVectorVector)
496 static const std::string AttrName = "VectorTest";
497 OCRepresentation rep;
499 OCRepresentation sub1;
500 OCRepresentation sub2;
501 OCRepresentation sub3;
502 OCRepresentation sub4;
503 vector<OCRepresentation> vect1 {sub1, sub2};
504 vector<OCRepresentation> vect2 {sub3, sub4};
505 vector<vector<OCRepresentation>> vect{vect1, vect2};
506 rep.setValue(AttrName, vect);
507 static const string Expected = "[[OC::OCRepresentation OC::OCRepresentation ]"
508 " [OC::OCRepresentation OC::OCRepresentation ] ]";
509 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
510 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
513 TEST(OCRepresentationValueToString, SubRepresentationVectorVectorVector)
515 static const std::string AttrName = "VectorTest";
516 OCRepresentation rep;
518 OCRepresentation sub1;
519 OCRepresentation sub2;
520 OCRepresentation sub3;
521 OCRepresentation sub4;
522 OCRepresentation sub5;
523 OCRepresentation sub6;
525 vector<OCRepresentation> vect11 {sub1, sub2};
526 vector<OCRepresentation> vect12 {sub3, sub4};
527 vector<vector<OCRepresentation>> vect1{vect11, vect12};
528 vector<OCRepresentation> vect21 {sub5};
529 vector<OCRepresentation> vect22 {sub6};
530 vector<vector<OCRepresentation>> vect2{vect21, vect22};
531 vector<vector<vector<OCRepresentation>>> vect{vect1, vect2};
533 rep.setValue(AttrName, vect);
534 static const string Expected =
535 "[[[OC::OCRepresentation OC::OCRepresentation ] "
536 "[OC::OCRepresentation OC::OCRepresentation ] ] "
537 "[[OC::OCRepresentation ] [OC::OCRepresentation ] ] ]";
538 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
539 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
542 // Subscript get/set (all types)
543 TEST(OCRepresentationSubscript, NullPtr)
545 static const std::string AttrName = "NullTest";
546 OCRepresentation rep;
547 rep[AttrName] = nullptr;
548 EXPECT_TRUE(rep.isNULL(AttrName));
550 std::nullptr_t repout = rep[AttrName];
551 std::nullptr_t repout2;
552 repout2 = rep[AttrName];
554 EXPECT_EQ(nullptr, repout);
555 EXPECT_EQ(nullptr, repout2);
558 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
560 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
565 TEST(OCRepresentationSubscript, Integer)
567 static const std::string AttrName = "IntTest";
568 OCRepresentation rep;
570 rep[AttrName] = repsource;
571 int repout = rep[AttrName];
573 repout2 = rep[AttrName];
575 EXPECT_EQ(repsource, repout);
576 EXPECT_EQ(repsource, repout2);
579 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
581 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
586 TEST(OCRepresentationSubscript, Double)
588 static const std::string AttrName = "DoubleTest";
589 OCRepresentation rep;
590 double repsource = -5.33;
591 rep[AttrName] = repsource;
592 double repout = rep[AttrName];
594 repout2 = rep[AttrName];
596 EXPECT_EQ(repsource, repout);
597 EXPECT_EQ(repsource, repout2);
600 EXPECT_FALSE(rep.getValue<int>(AttrName, badout));
602 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
607 //Disabled this test due to older GCC v4.6 fails for this test.
608 //We will enable it when we have a fix for it.
609 TEST(OCRepresentationSubscript, DISABLED_Boolean)
611 static const std::string AttrName = "BooleanTest";
612 OCRepresentation rep;
613 bool repsource = true;
614 rep[AttrName] = repsource;
615 bool repout = rep[AttrName];
617 repout2 = rep[AttrName];
619 EXPECT_EQ(repsource, repout);
620 EXPECT_EQ(repsource, repout2);
623 rep[AttrName] = repsource;
624 repout = rep[AttrName];
626 EXPECT_EQ(repsource, repout);
629 EXPECT_FALSE(rep.getValue<int>(AttrName, badout));
631 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
636 TEST(OCRepresentationSubscript, String)
638 static const std::string AttrName = "StringTest";
639 OCRepresentation rep;
640 string repsource = "This is a string!";
641 rep[AttrName] = repsource;
642 string repout = rep[AttrName];
644 repout2 = rep[AttrName];
646 EXPECT_EQ(repsource, repout);
647 EXPECT_EQ(repsource, repout2);
650 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
654 TEST(OCRepresentationSubscript, SubRepresentation)
656 static const std::string AttrName = "SubRepresentationTest";
657 OCRepresentation rep;
658 OCRepresentation repsource;
659 repsource.setUri("This is a uri");
661 rep[AttrName] = repsource;
662 OCRepresentation repout = rep[AttrName];
663 OCRepresentation repout2;
664 repout2 = rep[AttrName];
666 //OCRepresentation doesn't overload equality, so this just compares
667 //the value we set to ensure we got the same one out;
668 EXPECT_EQ(repsource.getUri(), repout.getUri());
669 EXPECT_EQ(repsource.getUri(), repout2.getUri());
672 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
674 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
679 TEST(OCRepresentationSubscript, IntegerVector)
681 static const std::string AttrName = "VectorTest";
682 OCRepresentation rep;
683 vector<int> repsource {1,2,3,4};
684 rep[AttrName] = repsource;
685 vector<int> repout = rep[AttrName];
687 repout2 = rep[AttrName];
689 EXPECT_EQ(repsource, repout);
690 EXPECT_EQ(repsource, repout2);
693 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
695 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
700 TEST(OCRepresentationSubscript, IntegerVectorVector)
702 static const std::string AttrName = "VectorTest";
703 OCRepresentation rep;
704 vector<vector<int>> repsource {{1,2,3,4},{5,6,7,8}};
705 rep[AttrName] = repsource;
706 vector<vector<int>> repout = rep[AttrName];
707 vector<vector<int>> repout2;
708 repout2 = rep[AttrName];
710 EXPECT_EQ(repsource, repout);
711 EXPECT_EQ(repsource, repout2);
714 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
716 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
721 TEST(OCRepresentationSubscript, IntegerVectorVectorVector)
723 static const std::string AttrName = "VectorTest";
724 OCRepresentation rep;
725 vector<vector<vector<int>>> repsource {{{1,2,3,4},{5,6,7,8}},{{9,10,11},{21,13}}};
726 rep[AttrName] = repsource;
727 vector<vector<vector<int>>> repout = rep[AttrName];
728 vector<vector<vector<int>>> repout2;
729 repout2 = rep[AttrName];
731 EXPECT_EQ(repsource, repout);
732 EXPECT_EQ(repsource, repout2);
735 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
737 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
742 TEST(OCRepresentationSubscript, DoubleVector)
744 static const std::string AttrName = "VectorTest";
745 OCRepresentation rep;
746 vector<double> repsource {1.1,2.2,3.2,4.2};
747 rep[AttrName] = repsource;
748 vector<double> repout = rep[AttrName];
749 vector<double> repout2;
750 repout2 = rep[AttrName];
752 EXPECT_EQ(repsource, repout);
753 EXPECT_EQ(repsource, repout2);
756 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
758 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
763 TEST(OCRepresentationSubscript, DoubleVectorVector)
765 static const std::string AttrName = "VectorTest";
766 OCRepresentation rep;
767 vector<vector<double>> repsource {{1.1,2.2,3.2,4.3},{5.5,6.6,7.8,.8}};
768 rep[AttrName] = repsource;
769 vector<vector<double>> repout = rep[AttrName];
770 vector<vector<double>> repout2;
771 repout2 = rep[AttrName];
773 EXPECT_EQ(repsource, repout);
774 EXPECT_EQ(repsource, repout2);
777 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
779 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
784 TEST(OCRepresentationSubscript, DoubleVectorVectorVector)
786 static const std::string AttrName = "VectorTest";
787 OCRepresentation rep;
788 vector<vector<vector<double>>> repsource {{{1.1,2.5,3.5,4.4},{.5,.6,7.8,8.9}},
789 {{9.8,10.8,11.8},{2.1,1.3}}};
790 rep[AttrName] = repsource;
791 vector<vector<vector<double>>> repout = rep[AttrName];
792 vector<vector<vector<double>>> repout2;
793 repout2 = rep[AttrName];
795 EXPECT_EQ(repsource, repout);
796 EXPECT_EQ(repsource, repout2);
799 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
801 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
806 TEST(OCRepresentationSubscript, BooleanVector)
808 static const std::string AttrName = "VectorTest";
809 OCRepresentation rep;
810 vector<bool> repsource {false, false, true};
811 rep[AttrName] = repsource;
812 vector<bool> repout = rep[AttrName];
813 vector<bool> repout2;
814 repout2 = rep[AttrName];
816 EXPECT_EQ(repsource, repout);
817 EXPECT_EQ(repsource, repout2);
820 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
822 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
827 TEST(OCRepresentationSubscript, BooleanVectorVector)
829 static const std::string AttrName = "VectorTest";
830 OCRepresentation rep;
831 vector<vector<bool>> repsource {{true, true},{false, true}};
832 rep[AttrName] = repsource;
833 vector<vector<bool>> repout = rep[AttrName];
834 vector<vector<bool>> repout2;
835 repout2 = rep[AttrName];
837 EXPECT_EQ(repsource, repout);
838 EXPECT_EQ(repsource, repout2);
841 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
843 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
848 TEST(OCRepresentationSubscript, BooleanVectorVectorVector)
850 static const std::string AttrName = "VectorTest";
851 OCRepresentation rep;
852 vector<vector<vector<bool>>> repsource {{{true, true, false},{true}},
853 {{true, false, false},{false, true, true}}};
854 rep[AttrName] = repsource;
855 vector<vector<vector<bool>>> repout = rep[AttrName];
856 vector<vector<vector<bool>>> repout2;
857 repout2 = rep[AttrName];
859 EXPECT_EQ(repsource, repout);
860 EXPECT_EQ(repsource, repout2);
863 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
865 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
870 TEST(OCRepresentationSubscript, StringVector)
872 static const std::string AttrName = "VectorTest";
873 OCRepresentation rep;
874 vector<string> repsource {"str1", "str2"};
875 rep[AttrName] = repsource;
876 vector<string> repout = rep[AttrName];
877 vector<string> repout2;
878 repout2 = rep[AttrName];
880 EXPECT_EQ(repsource, repout);
881 EXPECT_EQ(repsource, repout2);
884 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
886 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
891 TEST(OCRepresentationSubscript, StringVectorVector)
893 static const std::string AttrName = "VectorTest";
894 OCRepresentation rep;
895 vector<vector<string>> repsource {{"str1", "str2"},{"str3", "str4"}};
896 rep[AttrName] = repsource;
897 vector<vector<string>> repout = rep[AttrName];
898 vector<vector<string>> repout2;
899 repout2 = rep[AttrName];
901 EXPECT_EQ(repsource, repout);
902 EXPECT_EQ(repsource, repout2);
905 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
907 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
912 TEST(OCRepresentationSubscript, StringVectorVectorVector)
914 static const std::string AttrName = "VectorTest";
915 OCRepresentation rep;
916 vector<vector<vector<string>>> repsource {{{"str1", "str2"},{"str3", "str4"}},
917 {{"str5"},{"str6"}}};
918 rep[AttrName] = repsource;
919 vector<vector<vector<string>>> repout = rep[AttrName];
920 vector<vector<vector<string>>> repout2;
921 repout2 = rep[AttrName];
923 EXPECT_EQ(repsource, repout);
924 EXPECT_EQ(repsource, repout2);
927 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
929 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
934 TEST(OCRepresentationSubscript, SubRepresentationVector)
936 static const std::string AttrName = "VectorTest";
937 OCRepresentation rep;
938 OCRepresentation inner1, inner2;
939 inner1.setUri("inner1");
940 inner2.setUri("inner2");
941 vector<OCRepresentation> repsource {inner1, inner2};
942 rep[AttrName] = repsource;
943 vector<OCRepresentation> repout = rep[AttrName];
944 vector<OCRepresentation> repout2;
945 repout2 = rep[AttrName];
947 EXPECT_EQ(2u, repout.size());
948 EXPECT_EQ(inner1.getUri(), repout[0].getUri());
949 EXPECT_EQ(inner2.getUri(), repout[1].getUri());
950 EXPECT_EQ(2u, repout2.size());
951 EXPECT_EQ(inner1.getUri(), repout2[0].getUri());
952 EXPECT_EQ(inner2.getUri(), repout2[1].getUri());
955 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
957 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
962 TEST(OCRepresentationSubscript, SubRepresentationVectorVector)
964 static const std::string AttrName = "VectorTest";
965 OCRepresentation rep;
966 OCRepresentation inner1, inner2, inner3, inner4;
967 inner1.setUri("inner1");
968 inner2.setUri("inner2");
969 inner3.setUri("inner3");
970 inner4.setUri("inner4");
972 vector<vector<OCRepresentation>> repsource {{inner1, inner2}, {inner3, inner4}};
973 rep[AttrName] = repsource;
974 vector<vector<OCRepresentation>> repout = rep[AttrName];
975 vector<vector<OCRepresentation>> repout2;
976 repout2 = rep[AttrName];
978 EXPECT_EQ(2u, repout.size());
979 EXPECT_EQ(2u, repout[0].size());
980 EXPECT_EQ(inner1.getUri(), repout[0][0].getUri());
981 EXPECT_EQ(inner2.getUri(), repout[0][1].getUri());
982 EXPECT_EQ(2u, repout.size());
983 EXPECT_EQ(2u, repout[1].size());
984 EXPECT_EQ(inner3.getUri(), repout[1][0].getUri());
985 EXPECT_EQ(inner4.getUri(), repout[1][1].getUri());
987 EXPECT_EQ(2u, repout2.size());
988 EXPECT_EQ(2u, repout2[0].size());
989 EXPECT_EQ(inner1.getUri(), repout2[0][0].getUri());
990 EXPECT_EQ(inner2.getUri(), repout2[0][1].getUri());
991 EXPECT_EQ(2u, repout2.size());
992 EXPECT_EQ(2u, repout2[1].size());
993 EXPECT_EQ(inner3.getUri(), repout2[1][0].getUri());
994 EXPECT_EQ(inner4.getUri(), repout2[1][1].getUri());
997 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
999 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
1004 TEST(OCRepresentationSubscript, SubRepresentationVectorVectorVector)
1006 static const std::string AttrName = "VectorTest";
1007 OCRepresentation rep;
1008 OCRepresentation inner1, inner2, inner3, inner4, inner5, inner6, inner7, inner8;
1009 inner1.setUri("inner1");
1010 inner2.setUri("inner2");
1011 inner3.setUri("inner3");
1012 inner4.setUri("inner4");
1013 inner5.setUri("inner5");
1014 inner6.setUri("inner6");
1015 inner7.setUri("inner7");
1016 inner8.setUri("inner8");
1018 vector<vector<vector<OCRepresentation>>> repsource
1019 {{{inner1, inner2},{inner3, inner4}},{{inner5, inner6},{inner7,inner8}}};
1021 rep[AttrName] = repsource;
1022 vector<vector<vector<OCRepresentation>>> repout = rep[AttrName];
1023 vector<vector<vector<OCRepresentation>>> repout2;
1024 repout2 = rep[AttrName];
1026 EXPECT_EQ(2u, repout.size());
1027 EXPECT_EQ(2u, repout[0].size());
1028 EXPECT_EQ(2u, repout[0][0].size());
1029 EXPECT_EQ(inner1.getUri(), repout[0][0][0].getUri());
1030 EXPECT_EQ(inner2.getUri(), repout[0][0][1].getUri());
1031 EXPECT_EQ(2u, repout[0][1].size());
1032 EXPECT_EQ(inner3.getUri(), repout[0][1][0].getUri());
1033 EXPECT_EQ(inner4.getUri(), repout[0][1][1].getUri());
1034 EXPECT_EQ(2u, repout[1].size());
1035 EXPECT_EQ(2u, repout[1][0].size());
1036 EXPECT_EQ(inner5.getUri(), repout[1][0][0].getUri());
1037 EXPECT_EQ(inner6.getUri(), repout[1][0][1].getUri());
1038 EXPECT_EQ(2u, repout[1][1].size());
1039 EXPECT_EQ(inner7.getUri(), repout[1][1][0].getUri());
1040 EXPECT_EQ(inner8.getUri(), repout[1][1][1].getUri());
1042 EXPECT_EQ(2u, repout2.size());
1043 EXPECT_EQ(2u, repout2[0].size());
1044 EXPECT_EQ(2u, repout2[0][0].size());
1045 EXPECT_EQ(inner1.getUri(), repout2[0][0][0].getUri());
1046 EXPECT_EQ(inner2.getUri(), repout2[0][0][1].getUri());
1047 EXPECT_EQ(2u, repout[0][1].size());
1048 EXPECT_EQ(inner3.getUri(), repout2[0][1][0].getUri());
1049 EXPECT_EQ(inner4.getUri(), repout2[0][1][1].getUri());
1050 EXPECT_EQ(2u, repout[1].size());
1051 EXPECT_EQ(2u, repout[1][0].size());
1052 EXPECT_EQ(inner5.getUri(), repout2[1][0][0].getUri());
1053 EXPECT_EQ(inner6.getUri(), repout2[1][0][1].getUri());
1054 EXPECT_EQ(2u, repout[1][1].size());
1055 EXPECT_EQ(inner7.getUri(), repout2[1][1][0].getUri());
1056 EXPECT_EQ(inner8.getUri(), repout2[1][1][1].getUri());
1059 EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
1061 EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
1066 TEST(OCRepresentationIterator, constiterator)
1068 OCRepresentation rep;
1070 EXPECT_TRUE(rep.empty());
1071 rep.setValue("int", 8);
1072 EXPECT_FALSE(rep.empty());
1073 rep.setValue("double", 8.8);
1074 rep.setValue("bool", true);
1075 rep.setValue("string", std::string("this is a string"));
1077 EXPECT_EQ(4u, rep.size());
1078 EXPECT_FALSE(rep.empty());
1080 OCRepresentation::const_iterator itr = rep.cbegin();
1081 OCRepresentation::const_iterator endItr = rep.cend();
1082 for(;itr!=endItr;++itr);
1084 const OCRepresentation& rep2(rep);
1085 OCRepresentation::const_iterator itr2 = rep2.begin();
1086 OCRepresentation::const_iterator endItr2 = rep2.end();
1087 for(;itr2!=endItr2;++itr2);
1091 TEST(OCRepresentationIterator, constautoiterator)
1093 OCRepresentation rep;
1095 EXPECT_TRUE(rep.empty());
1096 rep.setValue("int", 8);
1097 EXPECT_FALSE(rep.empty());
1098 rep.setValue("double", 8.8);
1099 rep.setValue("bool", true);
1100 rep.setValue("string", std::string("this is a string"));
1102 EXPECT_EQ(4u, rep.size());
1103 EXPECT_FALSE(rep.empty());
1105 for(const auto& a : rep)
1110 const OCRepresentation& rep2(rep);
1111 for(const auto& a : rep2)
1116 TEST(OCRepresentationIterator, autoiterator)
1118 OCRepresentation rep;
1120 EXPECT_TRUE(rep.empty());
1121 rep.setValue("int", 8);
1122 EXPECT_FALSE(rep.empty());
1123 rep.setValue("double", 8.8);
1124 rep.setValue("bool", true);
1125 rep.setValue("string", std::string("this is a string"));
1127 EXPECT_EQ(4u, rep.size());
1128 EXPECT_FALSE(rep.empty());
1130 for(auto& cur : rep)
1132 if(cur.attrname() == "int")
1134 EXPECT_EQ("int", cur.attrname());
1135 EXPECT_EQ(AttributeType::Integer, cur.type());
1136 EXPECT_EQ(AttributeType::Integer, cur.base_type());
1137 EXPECT_EQ(0u, cur.depth());
1138 int curInt = cur.getValue<int>();
1139 EXPECT_EQ(8, curInt);
1141 if(cur.attrname() == "double")
1143 EXPECT_EQ("double", cur.attrname());
1144 EXPECT_EQ(AttributeType::Double, cur.type());
1145 EXPECT_EQ(AttributeType::Double, cur.base_type());
1146 EXPECT_EQ(0u, cur.depth());
1147 double curDouble = cur.getValue<double>();
1148 EXPECT_EQ(8.8, curDouble);
1150 if(cur.attrname() == "bool")
1152 EXPECT_EQ("bool", cur.attrname());
1153 EXPECT_EQ(AttributeType::Boolean, cur.type());
1154 EXPECT_EQ(AttributeType::Boolean, cur.base_type());
1155 EXPECT_EQ(0u, cur.depth());
1156 bool curBool = cur.getValue<bool>();
1157 EXPECT_EQ(true, curBool);
1159 if(cur.attrname() == "string")
1161 EXPECT_EQ("string", cur.attrname());
1162 EXPECT_EQ(AttributeType::String, cur.type());
1163 EXPECT_EQ(AttributeType::String, cur.base_type());
1164 EXPECT_EQ(0u, cur.depth());
1165 string curStr = cur.getValue<string>();
1166 EXPECT_EQ("this is a string", curStr);
1171 TEST(OCRepresentationIterator, iterator)
1173 OCRepresentation rep;
1174 OCRepresentation sub1;
1175 sub1.setUri("sub rep1 URI");
1176 OCRepresentation sub2;
1177 sub2.setUri("sub rep2 URI");
1178 OCRepresentation sub3;
1179 sub3.setUri("sub rep3 URI");
1180 OCRepresentation sub4;
1181 sub4.setUri("sub rep4 URI");
1182 OCRepresentation sub5;
1183 sub5.setUri("sub rep5 URI");
1184 OCRepresentation sub6;
1185 sub6.setUri("sub rep6 URI");
1188 EXPECT_TRUE(rep.empty());
1189 rep.setValue("int", 8);
1190 EXPECT_FALSE(rep.empty());
1191 rep.setValue("double", 8.8);
1192 rep.setValue("bool", true);
1193 rep.setValue("string", std::string("this is a string"));
1194 rep.setValue("rep", sub1);
1196 vector<int> intv {1,2,3,4};
1197 rep.setValue("intv", intv);
1198 vector<double> doublev {1.1,2.2,3.3,4.4};
1199 rep.setValue("doublev", doublev);
1200 vector<bool> boolv{false, false, true};
1201 rep.setValue("boolv", boolv);
1202 vector<string> strv{"abc", "def", "ghi"};
1203 rep.setValue("strv", strv);
1204 vector<OCRepresentation> repv { sub1, sub2 };
1205 rep.setValue("repv", repv);
1207 vector<vector<int>> intvv{{1,2,3},{4,5,6}};
1208 rep.setValue("intvv", intvv);
1209 vector<vector<vector<int>>> intvvv{{{1,2},{3,4}},{{5,6},{8,7}}};
1210 rep.setValue("intvvv", intvvv);
1212 vector<vector<double>> doublevv{{1.1,2.1,3},{4.4,5.4,6.4}};
1213 rep.setValue("doublevv", doublevv);
1214 vector<vector<vector<double>>> doublevvv{{{1.1,2.1},{3.1,4.1}},{{5.1,6.1},{8.1,7.1}}};
1215 rep.setValue("doublevvv", doublevvv);
1217 vector<vector<bool>> boolvv{{false, true},{true, false}};
1218 rep.setValue("boolvv", boolvv);
1219 vector<vector<vector<bool>>> boolvvv{{{true, false},{true}},{{false},{true}}};
1220 rep.setValue("boolvvv", boolvvv);
1222 vector<vector<string>> strvv{{"abc", "def"},{"wer", "qwer"}};
1223 rep.setValue("strvv", strvv);
1224 vector<vector<vector<string>>> strvvv{{{"wqr", "xcv"},{"234"}},{{"we"},{"wert"}}};
1225 rep.setValue("strvvv", strvvv);
1227 vector<vector<OCRepresentation>> repvv{{sub1, sub2},{sub3, sub4}};
1228 rep.setValue("repvv", repvv);
1229 vector<vector<vector<OCRepresentation>>> repvvv{{{sub5},{sub6}},{{sub3},{sub2}}};
1230 rep.setValue("repvvv", repvvv);
1232 EXPECT_EQ(20u, rep.size());
1233 EXPECT_FALSE(rep.empty());
1235 OCRepresentation::iterator itr= rep.begin();
1236 OCRepresentation::iterator endItr = rep.end();
1238 for(;itr!=endItr;++itr)
1240 if(itr->attrname() == "int")
1242 EXPECT_EQ("int", itr->attrname());
1243 EXPECT_EQ(AttributeType::Integer, itr->type());
1244 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1245 EXPECT_EQ(0u, itr->depth());
1246 int curInt = (*itr).getValue<int>();
1247 EXPECT_EQ(8, curInt);
1249 else if (itr->attrname() == "double")
1251 EXPECT_EQ("double", itr->attrname());
1252 EXPECT_EQ(AttributeType::Double, itr->type());
1253 EXPECT_EQ(AttributeType::Double, itr->base_type());
1254 EXPECT_EQ(0u, itr->depth());
1255 double curDouble = (*itr).getValue<double>();
1256 EXPECT_EQ(8.8, curDouble);
1258 else if (itr->attrname() == "bool")
1260 EXPECT_EQ("bool", itr->attrname());
1261 EXPECT_EQ(AttributeType::Boolean, itr->type());
1262 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1263 EXPECT_EQ(0u, itr->depth());
1264 bool curBool = (*itr).getValue<bool>();
1265 EXPECT_EQ(true, curBool);
1267 else if (itr->attrname() == "string")
1269 EXPECT_EQ("string", itr->attrname());
1270 EXPECT_EQ(AttributeType::String, itr->type());
1271 EXPECT_EQ(AttributeType::String, itr->base_type());
1272 EXPECT_EQ(0u, itr->depth());
1273 string curString = (*itr).getValue<string>();
1274 EXPECT_EQ("this is a string", curString);
1276 else if (itr->attrname() == "rep")
1278 EXPECT_EQ("rep", itr->attrname());
1279 EXPECT_EQ(AttributeType::OCRepresentation, itr->type());
1280 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1281 EXPECT_EQ(0u, itr->depth());
1282 OCRepresentation curRep = (*itr).getValue<OCRepresentation>();
1283 EXPECT_EQ(sub1.getUri(), curRep.getUri());
1285 else if (itr->attrname() == "intv")
1287 EXPECT_EQ("intv", itr->attrname());
1288 EXPECT_EQ(AttributeType::Vector, itr->type());
1289 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1290 EXPECT_EQ(1u, itr->depth());
1291 vector<int> curv = (*itr).getValue<vector<int>>();
1292 EXPECT_EQ(intv, curv);
1294 else if (itr->attrname() == "doublev")
1296 EXPECT_EQ("doublev", itr->attrname());
1297 EXPECT_EQ(AttributeType::Vector, itr->type());
1298 EXPECT_EQ(AttributeType::Double, itr->base_type());
1299 EXPECT_EQ(1u, itr->depth());
1300 vector<double> curv = (*itr).getValue<vector<double>>();
1301 EXPECT_EQ(doublev, curv);
1303 else if (itr->attrname() == "boolv")
1305 EXPECT_EQ("boolv", itr->attrname());
1306 EXPECT_EQ(AttributeType::Vector, itr->type());
1307 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1308 EXPECT_EQ(1u, itr->depth());
1309 vector<bool> curv = (*itr).getValue<vector<bool>>();
1310 EXPECT_EQ(boolv, curv);
1312 else if (itr->attrname() == "strv")
1314 EXPECT_EQ("strv", itr->attrname());
1315 EXPECT_EQ(AttributeType::Vector, itr->type());
1316 EXPECT_EQ(AttributeType::String, itr->base_type());
1317 EXPECT_EQ(1u, itr->depth());
1318 vector<string> curv = (*itr).getValue<vector<string>>();
1319 EXPECT_EQ(strv, curv);
1321 else if (itr->attrname() == "repv")
1323 EXPECT_EQ("repv", itr->attrname());
1324 EXPECT_EQ(AttributeType::Vector, itr->type());
1325 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1326 EXPECT_EQ(1u, itr->depth());
1327 vector<OCRepresentation> curv = (*itr).getValue<vector<OCRepresentation>>();
1328 EXPECT_EQ(2u, repv.size());
1329 EXPECT_EQ(sub1.getUri(), repv[0].getUri());
1330 EXPECT_EQ(sub2.getUri(), repv[1].getUri());
1332 else if (itr->attrname() == "intvv")
1334 EXPECT_EQ("intvv", itr->attrname());
1335 EXPECT_EQ(AttributeType::Vector, itr->type());
1336 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1337 EXPECT_EQ(2u, itr->depth());
1338 vector<vector<int>> curv = (*itr).getValue<vector<vector<int>>>();
1339 EXPECT_EQ(intvv, curv);
1341 else if (itr->attrname() == "intvvv")
1343 EXPECT_EQ("intvvv", itr->attrname());
1344 EXPECT_EQ(AttributeType::Vector, itr->type());
1345 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1346 EXPECT_EQ(3u, itr->depth());
1347 vector<vector<vector<int>>> curv = (*itr).getValue<vector<vector<vector<int>>>>();
1348 EXPECT_EQ(intvvv, curv);
1350 else if (itr->attrname() == "doublevv")
1352 EXPECT_EQ("doublevv", itr->attrname());
1353 EXPECT_EQ(AttributeType::Vector, itr->type());
1354 EXPECT_EQ(AttributeType::Double, itr->base_type());
1355 EXPECT_EQ(2u, itr->depth());
1356 vector<vector<double>> curv = (*itr).getValue<vector<vector<double>>>();
1357 EXPECT_EQ(doublevv, curv);
1359 else if (itr->attrname() == "doublevvv")
1361 EXPECT_EQ("doublevvv", itr->attrname());
1362 EXPECT_EQ(AttributeType::Vector, itr->type());
1363 EXPECT_EQ(AttributeType::Double, itr->base_type());
1364 EXPECT_EQ(3u, itr->depth());
1365 vector<vector<vector<double>>> curv =
1366 (*itr).getValue<vector<vector<vector<double>>>>();
1367 EXPECT_EQ(doublevvv, curv);
1369 else if (itr->attrname() == "boolvv")
1371 EXPECT_EQ("boolvv", itr->attrname());
1372 EXPECT_EQ(AttributeType::Vector, itr->type());
1373 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1374 EXPECT_EQ(2u, itr->depth());
1375 vector<vector<bool>> curv = (*itr).getValue<vector<vector<bool>>>();
1376 EXPECT_EQ(boolvv, curv);
1378 else if (itr->attrname() == "boolvvv")
1380 EXPECT_EQ("boolvvv", itr->attrname());
1381 EXPECT_EQ(AttributeType::Vector, itr->type());
1382 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1383 EXPECT_EQ(3u, itr->depth());
1384 vector<vector<vector<bool>>> curv = (*itr).getValue<vector<vector<vector<bool>>>>();
1385 EXPECT_EQ(boolvvv, curv);
1387 else if (itr->attrname() == "strvv")
1389 EXPECT_EQ("strvv", itr->attrname());
1390 EXPECT_EQ(AttributeType::Vector, itr->type());
1391 EXPECT_EQ(AttributeType::String, itr->base_type());
1392 EXPECT_EQ(2u, itr->depth());
1393 vector<vector<string>> curv = (*itr).getValue<vector<vector<string>>>();
1394 EXPECT_EQ(strvv, curv);
1396 else if (itr->attrname() == "strvvv")
1398 EXPECT_EQ("strvvv", itr->attrname());
1399 EXPECT_EQ(AttributeType::Vector, itr->type());
1400 EXPECT_EQ(AttributeType::String, itr->base_type());
1401 EXPECT_EQ(3u, itr->depth());
1402 vector<vector<vector<string>>> curv =
1403 (*itr).getValue<vector<vector<vector<string>>>>();
1404 EXPECT_EQ(strvvv, curv);
1406 else if (itr->attrname() == "repvv")
1408 EXPECT_EQ("repvv", itr->attrname());
1409 EXPECT_EQ(AttributeType::Vector, itr->type());
1410 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1411 EXPECT_EQ(2u, itr->depth());
1412 vector<vector<OCRepresentation>> curv =
1413 (*itr).getValue<vector<vector<OCRepresentation>>>();
1414 EXPECT_EQ(2u, curv.size());
1415 EXPECT_EQ(2u, curv[0].size());
1416 EXPECT_EQ(sub1.getUri(), curv[0][0].getUri());
1417 EXPECT_EQ(sub2.getUri(), curv[0][1].getUri());
1418 EXPECT_EQ(2u, curv[1].size());
1419 EXPECT_EQ(sub3.getUri(), curv[1][0].getUri());
1420 EXPECT_EQ(sub4.getUri(), curv[1][1].getUri());
1422 else if (itr->attrname() == "repvvv")
1424 EXPECT_EQ("repvvv", itr->attrname());
1425 EXPECT_EQ(AttributeType::Vector, itr->type());
1426 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1427 EXPECT_EQ(3u, itr->depth());
1428 vector<vector<vector<OCRepresentation>>> curv =
1429 (*itr).getValue<vector<vector<vector<OCRepresentation>>>>();
1430 EXPECT_EQ(2u, curv.size());
1431 EXPECT_EQ(2u, curv[0].size());
1432 EXPECT_EQ(1u, curv[0][0].size());
1433 EXPECT_EQ(sub5.getUri(), curv[0][0][0].getUri());
1434 EXPECT_EQ(1u, curv[0][1].size());
1435 EXPECT_EQ(sub6.getUri(), curv[0][1][0].getUri());
1436 EXPECT_EQ(1u, curv[1][0].size());
1437 EXPECT_EQ(sub3.getUri(), curv[1][0][0].getUri());
1438 EXPECT_EQ(1u, curv[1][1].size());
1439 EXPECT_EQ(sub2.getUri(), curv[1][1][0].getUri());
1443 EXPECT_TRUE(false) << itr->attrname();