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
33 void parsedEqual(T expected, const std::string& actualStr)
35 T actual = boost::lexical_cast<T>(actualStr);
36 EXPECT_LT(std::abs(expected - actual), std::numeric_limits<T>::epsilon());
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, IntegerVector)
153 static const std::string AttrName = "VectorTest";
154 OCRepresentation rep;
156 vector<int> vect {1,2,3,4,5,6,7,8,9};
157 vector<int> vect2 {-5,-3,-1,0,5,3,2};
158 rep.setValue(AttrName, vect);
159 EXPECT_EQ("[1 2 3 4 5 6 7 8 9 ]", rep.getValueToString(AttrName));
160 EXPECT_EQ("[1 2 3 4 5 6 7 8 9 ]", rep[AttrName].getValueToString());
162 rep.setValue(AttrName, vect2);
163 EXPECT_EQ("[-5 -3 -1 0 5 3 2 ]", rep.getValueToString(AttrName));
164 EXPECT_EQ("[-5 -3 -1 0 5 3 2 ]", rep[AttrName].getValueToString());
167 TEST(OCRepresentationValueToString, IntegerVectorVector)
169 static const std::string AttrName = "VectorTest";
170 OCRepresentation rep;
172 vector<int> vect1 {1,2,3,4,5,6,7,8,9};
173 vector<int> vect2 {-5,-3,-1,0,5,3,2};
174 vector<vector<int>> vect{vect1, vect2};
176 rep.setValue(AttrName, vect);
177 static const string Expected = "[[1 2 3 4 5 6 7 8 9 ] [-5 -3 -1 0 5 3 2 ] ]";
178 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
179 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
182 TEST(OCRepresentationValueToString, IntegerVectorVectorVector)
184 static const std::string AttrName = "VectorTest";
185 OCRepresentation rep;
187 vector<int> vect11 {1,2,3,4,5,6,7,8,9};
188 vector<int> vect12 {-5,-3,-1,0,5,3,2};
189 vector<vector<int>> vect1{vect11, vect12};
190 vector<int> vect21 {2,0,1,6,9,3,8};
191 vector<int> vect22 {9,7,8,100003};
192 vector<vector<int>> vect2{vect21, vect22};
193 vector<vector<vector<int>>> vect{vect1, vect2};
194 rep.setValue(AttrName, vect);
195 static const std::string Expected =
196 "[[[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 ] ] ]";
197 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
198 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
201 TEST(OCRepresentationValueToString, DoubleVector)
203 static const std::string AttrName = "VectorTest";
204 OCRepresentation rep;
206 vector<double> vect {3.12, -5.3, 7.5, 1.110};
207 vector<double> vect2 {2.1, -555.5, 0.0001, -0.2};
208 rep.setValue(AttrName, vect);
209 EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
211 rep.setValue(AttrName, vect2);
212 EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
215 TEST(OCRepresentationValueToString, DoubleVectorVector)
217 static const std::string AttrName = "VectorTest";
218 OCRepresentation rep;
219 vector<double> vect1 {30.1,5.88,-22.0,0};
220 vector<double> vect2 {2.1,-55.5,0.1100,-.2};
221 vector<vector<double>> vect{vect1, vect2};
223 rep.setValue(AttrName, vect);
224 EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
227 TEST(OCRepresentationValueToString, DoubleVectorVectorVector)
229 static const std::string AttrName = "VectorTest";
230 OCRepresentation rep;
232 vector<double> vect11 {3.01, 5.88, -22.0, 0.0};
233 vector<double> vect12 {99.3,8.0,.01236,-.22};
234 vector<vector<double>> vect1{vect11, vect12};
235 vector<double> vect21 {9.0,-1};
236 vector<double> vect22 {-99.2};
237 vector<vector<double>> vect2{vect21, vect22};
238 vector<vector<vector<double>>> vect{vect1, vect2};
239 rep.setValue(AttrName, vect);
240 EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
243 TEST(OCRepresentationValueToString, BooleanVector)
245 static const std::string AttrName = "VectorTest";
246 OCRepresentation rep;
248 vector<bool> vect {true, false, false, true};
249 vector<bool> vect2 {false, false, false, true};
250 rep.setValue(AttrName, vect);
251 EXPECT_EQ("[true false false true ]", rep.getValueToString(AttrName));
252 EXPECT_EQ("[true false false true ]", rep[AttrName].getValueToString());
254 rep.setValue(AttrName, vect2);
255 EXPECT_EQ("[false false false true ]", rep.getValueToString(AttrName));
256 EXPECT_EQ("[false false false true ]", rep[AttrName].getValueToString());
259 TEST(OCRepresentationValueToString, BooleanVectorVector)
261 static const std::string AttrName = "VectorTest";
262 OCRepresentation rep;
264 vector<bool> vect1 {true, false, false, true};
265 vector<bool> vect2 {false, false, false, true};
266 vector<vector<bool>> vect{vect1, vect2};
268 rep.setValue(AttrName, vect);
269 static const string Expected="[[true false false true ] [false false false true ] ]";
271 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
272 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
275 TEST(OCRepresentationValueToString, BooleanVectorVectorVector)
277 static const std::string AttrName = "VectorTest";
278 OCRepresentation rep;
280 vector<bool> vect11 {true, false, false, true};
281 vector<bool> vect12 {false, false, false, true};
282 vector<vector<bool>> vect1{vect11, vect12};
283 vector<bool> vect21 {false, true, true, false};
284 vector<bool> vect22 {true, true, true, false};
285 vector<vector<bool>> vect2{vect21, vect22};
286 vector<vector<vector<bool>>> vect{vect1, vect2};
287 rep.setValue(AttrName, vect);
288 static const std::string Expected =
289 "[[[true false false true ] [false false false true ] ]"
290 " [[false true true false ] [true true true false ] ] ]";
291 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
292 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
295 TEST(OCRepresentationValueToString, StringVector)
297 static const std::string AttrName = "VectorTest";
298 OCRepresentation rep;
300 vector<string> vect {"s1", "s2", "s3"};
301 vector<string> vect2 {"s4", "s5", "s6"};
302 rep.setValue(AttrName, vect);
303 EXPECT_EQ("[s1 s2 s3 ]", rep.getValueToString(AttrName));
304 EXPECT_EQ("[s1 s2 s3 ]", rep[AttrName].getValueToString());
306 rep.setValue(AttrName, vect2);
307 EXPECT_EQ("[s4 s5 s6 ]", rep.getValueToString(AttrName));
308 EXPECT_EQ("[s4 s5 s6 ]", rep[AttrName].getValueToString());
311 TEST(OCRepresentationValueToString, StringVectorVector)
313 static const std::string AttrName = "VectorTest";
314 OCRepresentation rep;
316 vector<string> vect1 {"s1", "s2", "s3"};
317 vector<string> vect2 {"s4", "s5", "s6"};
318 vector<vector<string>> vect{vect1, vect2};
320 rep.setValue(AttrName, vect);
321 static const string Expected="[[s1 s2 s3 ] [s4 s5 s6 ] ]";
323 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
324 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
327 TEST(OCRepresentationValueToString, StringVectorVectorVector)
329 static const std::string AttrName = "VectorTest";
330 OCRepresentation rep;
332 vector<string> vect11 {"s1", "s2", "s3"};
333 vector<string> vect12 {"s4", "s5", "s6"};
334 vector<vector<string>> vect1{vect11, vect12};
335 vector<string> vect21 {"s7", "s8"};
336 vector<string> vect22 {"s9"};
337 vector<vector<string>> vect2{vect21, vect22};
338 vector<vector<vector<string>>> vect{vect1, vect2};
339 rep.setValue(AttrName, vect);
340 static const std::string Expected =
341 "[[[s1 s2 s3 ] [s4 s5 s6 ] ]"
342 " [[s7 s8 ] [s9 ] ] ]";
343 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
344 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
347 TEST(OCRepresentationValueToString, SubRepresentationVector)
349 static const std::string AttrName = "VectorTest";
350 OCRepresentation rep;
352 OCRepresentation sub1;
353 OCRepresentation sub2;
354 vector<OCRepresentation> vect {sub1, sub2};
355 rep.setValue(AttrName, vect);
356 EXPECT_EQ("[OC::OCRepresentation OC::OCRepresentation ]", rep.getValueToString(AttrName));
357 EXPECT_EQ("[OC::OCRepresentation OC::OCRepresentation ]", rep[AttrName].getValueToString());
360 TEST(OCRepresentationValueToString, SubRepresentationVectorVector)
362 static const std::string AttrName = "VectorTest";
363 OCRepresentation rep;
365 OCRepresentation sub1;
366 OCRepresentation sub2;
367 OCRepresentation sub3;
368 OCRepresentation sub4;
369 vector<OCRepresentation> vect1 {sub1, sub2};
370 vector<OCRepresentation> vect2 {sub3, sub4};
371 vector<vector<OCRepresentation>> vect{vect1, vect2};
372 rep.setValue(AttrName, vect);
373 static const string Expected = "[[OC::OCRepresentation OC::OCRepresentation ]"
374 " [OC::OCRepresentation OC::OCRepresentation ] ]";
375 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
376 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
379 TEST(OCRepresentationValueToString, SubRepresentationVectorVectorVector)
381 static const std::string AttrName = "VectorTest";
382 OCRepresentation rep;
384 OCRepresentation sub1;
385 OCRepresentation sub2;
386 OCRepresentation sub3;
387 OCRepresentation sub4;
388 OCRepresentation sub5;
389 OCRepresentation sub6;
391 vector<OCRepresentation> vect11 {sub1, sub2};
392 vector<OCRepresentation> vect12 {sub3, sub4};
393 vector<vector<OCRepresentation>> vect1{vect11, vect12};
394 vector<OCRepresentation> vect21 {sub5};
395 vector<OCRepresentation> vect22 {sub6};
396 vector<vector<OCRepresentation>> vect2{vect21, vect22};
397 vector<vector<vector<OCRepresentation>>> vect{vect1, vect2};
399 rep.setValue(AttrName, vect);
400 static const string Expected =
401 "[[[OC::OCRepresentation OC::OCRepresentation ] "
402 "[OC::OCRepresentation OC::OCRepresentation ] ] "
403 "[[OC::OCRepresentation ] [OC::OCRepresentation ] ] ]";
404 EXPECT_EQ(Expected, rep.getValueToString(AttrName));
405 EXPECT_EQ(Expected, rep[AttrName].getValueToString());
408 // Subscript get/set (all types)
409 TEST(OCRepresentationSubscript, NullPtr)
411 static const std::string AttrName = "NullTest";
412 OCRepresentation rep;
413 rep[AttrName] = nullptr;
414 EXPECT_TRUE(rep.isNULL(AttrName));
416 std::nullptr_t repout = rep[AttrName];
417 std::nullptr_t repout2;
418 repout2 = rep[AttrName];
420 EXPECT_EQ(nullptr, repout);
421 EXPECT_EQ(nullptr, repout2);
424 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
426 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
431 TEST(OCRepresentationSubscript, Integer)
433 static const std::string AttrName = "IntTest";
434 OCRepresentation rep;
436 rep[AttrName] = repsource;
437 int repout = rep[AttrName];
439 repout2 = rep[AttrName];
441 EXPECT_EQ(repsource, repout);
442 EXPECT_EQ(repsource, repout2);
445 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
447 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
452 TEST(OCRepresentationSubscript, Double)
454 static const std::string AttrName = "DoubleTest";
455 OCRepresentation rep;
456 double repsource = -5.33;
457 rep[AttrName] = repsource;
458 double repout = rep[AttrName];
460 repout2 = rep[AttrName];
462 EXPECT_EQ(repsource, repout);
463 EXPECT_EQ(repsource, repout2);
466 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
468 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
473 TEST(OCRepresentationSubscript, Boolean)
475 static const std::string AttrName = "BooleanTest";
476 OCRepresentation rep;
477 bool repsource = true;
478 rep[AttrName] = repsource;
479 bool repout = rep[AttrName];
481 repout2 = rep[AttrName];
483 EXPECT_EQ(repsource, repout);
484 EXPECT_EQ(repsource, repout2);
487 rep[AttrName] = repsource;
488 repout = rep[AttrName];
490 EXPECT_EQ(repsource, repout);
493 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
495 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
500 TEST(OCRepresentationSubscript, String)
502 static const std::string AttrName = "StringTest";
503 OCRepresentation rep;
504 string repsource = "This is a string!";
505 rep[AttrName] = repsource;
506 string repout = rep[AttrName];
508 repout2 = rep[AttrName];
510 EXPECT_EQ(repsource, repout);
511 EXPECT_EQ(repsource, repout2);
514 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
518 TEST(OCRepresentationSubscript, SubRepresentation)
520 static const std::string AttrName = "SubRepresentationTest";
521 OCRepresentation rep;
522 OCRepresentation repsource;
523 repsource.setUri("This is a uri");
525 rep[AttrName] = repsource;
526 OCRepresentation repout = rep[AttrName];
527 OCRepresentation repout2;
528 repout2 = rep[AttrName];
530 //OCRepresentation doesn't overload equality, so this just compares
531 //the value we set to ensure we got the same one out;
532 EXPECT_EQ(repsource.getUri(), repout.getUri());
533 EXPECT_EQ(repsource.getUri(), repout2.getUri());
536 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
538 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
543 TEST(OCRepresentationSubscript, IntegerVector)
545 static const std::string AttrName = "VectorTest";
546 OCRepresentation rep;
547 vector<int> repsource {1,2,3,4};
548 rep[AttrName] = repsource;
549 vector<int> repout = rep[AttrName];
551 repout2 = rep[AttrName];
553 EXPECT_EQ(repsource, repout);
554 EXPECT_EQ(repsource, repout2);
557 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
559 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
564 TEST(OCRepresentationSubscript, IntegerVectorVector)
566 static const std::string AttrName = "VectorTest";
567 OCRepresentation rep;
568 vector<vector<int>> repsource {{1,2,3,4},{5,6,7,8}};
569 rep[AttrName] = repsource;
570 vector<vector<int>> repout = rep[AttrName];
571 vector<vector<int>> repout2;
572 repout2 = rep[AttrName];
574 EXPECT_EQ(repsource, repout);
575 EXPECT_EQ(repsource, repout2);
578 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
580 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
585 TEST(OCRepresentationSubscript, IntegerVectorVectorVector)
587 static const std::string AttrName = "VectorTest";
588 OCRepresentation rep;
589 vector<vector<vector<int>>> repsource {{{1,2,3,4},{5,6,7,8}},{{9,10,11},{21,13}}};
590 rep[AttrName] = repsource;
591 vector<vector<vector<int>>> repout = rep[AttrName];
592 vector<vector<vector<int>>> repout2;
593 repout2 = rep[AttrName];
595 EXPECT_EQ(repsource, repout);
596 EXPECT_EQ(repsource, repout2);
599 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
601 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
606 TEST(OCRepresentationSubscript, DoubleVector)
608 static const std::string AttrName = "VectorTest";
609 OCRepresentation rep;
610 vector<double> repsource {1.1,2.2,3.2,4.2};
611 rep[AttrName] = repsource;
612 vector<double> repout = rep[AttrName];
613 vector<double> repout2;
614 repout2 = rep[AttrName];
616 EXPECT_EQ(repsource, repout);
617 EXPECT_EQ(repsource, repout2);
620 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
622 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
627 TEST(OCRepresentationSubscript, DoubleVectorVector)
629 static const std::string AttrName = "VectorTest";
630 OCRepresentation rep;
631 vector<vector<double>> repsource {{1.1,2.2,3.2,4.3},{5.5,6.6,7.8,.8}};
632 rep[AttrName] = repsource;
633 vector<vector<double>> repout = rep[AttrName];
634 vector<vector<double>> repout2;
635 repout2 = rep[AttrName];
637 EXPECT_EQ(repsource, repout);
638 EXPECT_EQ(repsource, repout2);
641 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
643 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
648 TEST(OCRepresentationSubscript, DoubleVectorVectorVector)
650 static const std::string AttrName = "VectorTest";
651 OCRepresentation rep;
652 vector<vector<vector<double>>> repsource {{{1.1,2.5,3.5,4.4},{.5,.6,7.8,8.9}},
653 {{9.8,10.8,11.8},{2.1,1.3}}};
654 rep[AttrName] = repsource;
655 vector<vector<vector<double>>> repout = rep[AttrName];
656 vector<vector<vector<double>>> repout2;
657 repout2 = rep[AttrName];
659 EXPECT_EQ(repsource, repout);
660 EXPECT_EQ(repsource, repout2);
663 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
665 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
670 TEST(OCRepresentationSubscript, BooleanVector)
672 static const std::string AttrName = "VectorTest";
673 OCRepresentation rep;
674 vector<bool> repsource {false, false, true};
675 rep[AttrName] = repsource;
676 vector<bool> repout = rep[AttrName];
677 vector<bool> repout2;
678 repout2 = rep[AttrName];
680 EXPECT_EQ(repsource, repout);
681 EXPECT_EQ(repsource, repout2);
684 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
686 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
691 TEST(OCRepresentationSubscript, BooleanVectorVector)
693 static const std::string AttrName = "VectorTest";
694 OCRepresentation rep;
695 vector<vector<bool>> repsource {{true, true},{false, true}};
696 rep[AttrName] = repsource;
697 vector<vector<bool>> repout = rep[AttrName];
698 vector<vector<bool>> repout2;
699 repout2 = rep[AttrName];
701 EXPECT_EQ(repsource, repout);
702 EXPECT_EQ(repsource, repout2);
705 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
707 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
712 TEST(OCRepresentationSubscript, BooleanVectorVectorVector)
714 static const std::string AttrName = "VectorTest";
715 OCRepresentation rep;
716 vector<vector<vector<bool>>> repsource {{{true, true, false},{true}},
717 {{true, false, false},{false, true, true}}};
718 rep[AttrName] = repsource;
719 vector<vector<vector<bool>>> repout = rep[AttrName];
720 vector<vector<vector<bool>>> repout2;
721 repout2 = rep[AttrName];
723 EXPECT_EQ(repsource, repout);
724 EXPECT_EQ(repsource, repout2);
727 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
729 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
734 TEST(OCRepresentationSubscript, StringVector)
736 static const std::string AttrName = "VectorTest";
737 OCRepresentation rep;
738 vector<string> repsource {"str1", "str2"};
739 rep[AttrName] = repsource;
740 vector<string> repout = rep[AttrName];
741 vector<string> repout2;
742 repout2 = rep[AttrName];
744 EXPECT_EQ(repsource, repout);
745 EXPECT_EQ(repsource, repout2);
748 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
750 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
755 TEST(OCRepresentationSubscript, StringVectorVector)
757 static const std::string AttrName = "VectorTest";
758 OCRepresentation rep;
759 vector<vector<string>> repsource {{"str1", "str2"},{"str3", "str4"}};
760 rep[AttrName] = repsource;
761 vector<vector<string>> repout = rep[AttrName];
762 vector<vector<string>> repout2;
763 repout2 = rep[AttrName];
765 EXPECT_EQ(repsource, repout);
766 EXPECT_EQ(repsource, repout2);
769 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
771 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
776 TEST(OCRepresentationSubscript, StringVectorVectorVector)
778 static const std::string AttrName = "VectorTest";
779 OCRepresentation rep;
780 vector<vector<vector<string>>> repsource {{{"str1", "str2"},{"str3", "str4"}},
781 {{"str5"},{"str6"}}};
782 rep[AttrName] = repsource;
783 vector<vector<vector<string>>> repout = rep[AttrName];
784 vector<vector<vector<string>>> repout2;
785 repout2 = rep[AttrName];
787 EXPECT_EQ(repsource, repout);
788 EXPECT_EQ(repsource, repout2);
791 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
793 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
798 TEST(OCRepresentationSubscript, SubRepresentationVector)
800 static const std::string AttrName = "VectorTest";
801 OCRepresentation rep;
802 OCRepresentation inner1, inner2;
803 inner1.setUri("inner1");
804 inner2.setUri("inner2");
805 vector<OCRepresentation> repsource {inner1, inner2};
806 rep[AttrName] = repsource;
807 vector<OCRepresentation> repout = rep[AttrName];
808 vector<OCRepresentation> repout2;
809 repout2 = rep[AttrName];
811 EXPECT_EQ(2, repout.size());
812 EXPECT_EQ(inner1.getUri(), repout[0].getUri());
813 EXPECT_EQ(inner2.getUri(), repout[1].getUri());
814 EXPECT_EQ(2, repout2.size());
815 EXPECT_EQ(inner1.getUri(), repout2[0].getUri());
816 EXPECT_EQ(inner2.getUri(), repout2[1].getUri());
819 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
821 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
826 TEST(OCRepresentationSubscript, SubRepresentationVectorVector)
828 static const std::string AttrName = "VectorTest";
829 OCRepresentation rep;
830 OCRepresentation inner1, inner2, inner3, inner4;
831 inner1.setUri("inner1");
832 inner2.setUri("inner2");
833 inner3.setUri("inner3");
834 inner4.setUri("inner4");
836 vector<vector<OCRepresentation>> repsource {{inner1, inner2}, {inner3, inner4}};
837 rep[AttrName] = repsource;
838 vector<vector<OCRepresentation>> repout = rep[AttrName];
839 vector<vector<OCRepresentation>> repout2;
840 repout2 = rep[AttrName];
842 EXPECT_EQ(2, repout.size());
843 EXPECT_EQ(2, repout[0].size());
844 EXPECT_EQ(inner1.getUri(), repout[0][0].getUri());
845 EXPECT_EQ(inner2.getUri(), repout[0][1].getUri());
846 EXPECT_EQ(2, repout.size());
847 EXPECT_EQ(2, repout[1].size());
848 EXPECT_EQ(inner3.getUri(), repout[1][0].getUri());
849 EXPECT_EQ(inner4.getUri(), repout[1][1].getUri());
851 EXPECT_EQ(2, repout2.size());
852 EXPECT_EQ(2, repout2[0].size());
853 EXPECT_EQ(inner1.getUri(), repout2[0][0].getUri());
854 EXPECT_EQ(inner2.getUri(), repout2[0][1].getUri());
855 EXPECT_EQ(2, repout2.size());
856 EXPECT_EQ(2, repout2[1].size());
857 EXPECT_EQ(inner3.getUri(), repout2[1][0].getUri());
858 EXPECT_EQ(inner4.getUri(), repout2[1][1].getUri());
861 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
863 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
868 TEST(OCRepresentationSubscript, SubRepresentationVectorVectorVector)
870 static const std::string AttrName = "VectorTest";
871 OCRepresentation rep;
872 OCRepresentation inner1, inner2, inner3, inner4, inner5, inner6, inner7, inner8;
873 inner1.setUri("inner1");
874 inner2.setUri("inner2");
875 inner3.setUri("inner3");
876 inner4.setUri("inner4");
877 inner5.setUri("inner5");
878 inner6.setUri("inner6");
879 inner7.setUri("inner7");
880 inner8.setUri("inner8");
882 vector<vector<vector<OCRepresentation>>> repsource
883 {{{inner1, inner2},{inner3, inner4}},{{inner5, inner6},{inner7,inner8}}};
885 rep[AttrName] = repsource;
886 vector<vector<vector<OCRepresentation>>> repout = rep[AttrName];
887 vector<vector<vector<OCRepresentation>>> repout2;
888 repout2 = rep[AttrName];
890 EXPECT_EQ(2, repout.size());
891 EXPECT_EQ(2, repout[0].size());
892 EXPECT_EQ(2, repout[0][0].size());
893 EXPECT_EQ(inner1.getUri(), repout[0][0][0].getUri());
894 EXPECT_EQ(inner2.getUri(), repout[0][0][1].getUri());
895 EXPECT_EQ(2, repout[0][1].size());
896 EXPECT_EQ(inner3.getUri(), repout[0][1][0].getUri());
897 EXPECT_EQ(inner4.getUri(), repout[0][1][1].getUri());
898 EXPECT_EQ(2, repout[1].size());
899 EXPECT_EQ(2, repout[1][0].size());
900 EXPECT_EQ(inner5.getUri(), repout[1][0][0].getUri());
901 EXPECT_EQ(inner6.getUri(), repout[1][0][1].getUri());
902 EXPECT_EQ(2, repout[1][1].size());
903 EXPECT_EQ(inner7.getUri(), repout[1][1][0].getUri());
904 EXPECT_EQ(inner8.getUri(), repout[1][1][1].getUri());
906 EXPECT_EQ(2, repout2.size());
907 EXPECT_EQ(2, repout2[0].size());
908 EXPECT_EQ(2, repout2[0][0].size());
909 EXPECT_EQ(inner1.getUri(), repout2[0][0][0].getUri());
910 EXPECT_EQ(inner2.getUri(), repout2[0][0][1].getUri());
911 EXPECT_EQ(2, repout[0][1].size());
912 EXPECT_EQ(inner3.getUri(), repout2[0][1][0].getUri());
913 EXPECT_EQ(inner4.getUri(), repout2[0][1][1].getUri());
914 EXPECT_EQ(2, repout[1].size());
915 EXPECT_EQ(2, repout[1][0].size());
916 EXPECT_EQ(inner5.getUri(), repout2[1][0][0].getUri());
917 EXPECT_EQ(inner6.getUri(), repout2[1][0][1].getUri());
918 EXPECT_EQ(2, repout[1][1].size());
919 EXPECT_EQ(inner7.getUri(), repout2[1][1][0].getUri());
920 EXPECT_EQ(inner8.getUri(), repout2[1][1][1].getUri());
923 EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
925 EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
930 TEST(OCRepresentationIterator, constiterator)
932 OCRepresentation rep;
934 EXPECT_TRUE(rep.empty());
935 rep.setValue("int", 8);
936 EXPECT_FALSE(rep.empty());
937 rep.setValue("double", 8.8);
938 rep.setValue("bool", true);
939 rep.setValue("string", std::string("this is a string"));
941 EXPECT_EQ(4, rep.size());
942 EXPECT_FALSE(rep.empty());
944 OCRepresentation::const_iterator itr = rep.cbegin();
945 OCRepresentation::const_iterator endItr = rep.cend();
946 for(;itr!=endItr;++itr);
948 const OCRepresentation& rep2(rep);
949 OCRepresentation::const_iterator itr2 = rep2.begin();
950 OCRepresentation::const_iterator endItr2 = rep2.end();
951 for(;itr2!=endItr2;++itr2);
955 TEST(OCRepresentationIterator, constautoiterator)
957 OCRepresentation rep;
959 EXPECT_TRUE(rep.empty());
960 rep.setValue("int", 8);
961 EXPECT_FALSE(rep.empty());
962 rep.setValue("double", 8.8);
963 rep.setValue("bool", true);
964 rep.setValue("string", std::string("this is a string"));
966 EXPECT_EQ(4, rep.size());
967 EXPECT_FALSE(rep.empty());
969 for(const auto& a : rep)
974 const OCRepresentation& rep2(rep);
975 for(const auto& a : rep2)
980 TEST(OCRepresentationIterator, autoiterator)
982 OCRepresentation rep;
984 EXPECT_TRUE(rep.empty());
985 rep.setValue("int", 8);
986 EXPECT_FALSE(rep.empty());
987 rep.setValue("double", 8.8);
988 rep.setValue("bool", true);
989 rep.setValue("string", std::string("this is a string"));
991 EXPECT_EQ(4, rep.size());
992 EXPECT_FALSE(rep.empty());
996 if(cur.attrname() == "int")
998 EXPECT_EQ("int", cur.attrname());
999 EXPECT_EQ(AttributeType::Integer, cur.type());
1000 EXPECT_EQ(AttributeType::Integer, cur.base_type());
1001 EXPECT_EQ(0, cur.depth());
1002 int curInt = cur.getValue<int>();
1003 EXPECT_EQ(8, curInt);
1005 if(cur.attrname() == "double")
1007 EXPECT_EQ("double", cur.attrname());
1008 EXPECT_EQ(AttributeType::Double, cur.type());
1009 EXPECT_EQ(AttributeType::Double, cur.base_type());
1010 EXPECT_EQ(0, cur.depth());
1011 double curDouble = cur.getValue<double>();
1012 EXPECT_EQ(8.8, curDouble);
1014 if(cur.attrname() == "bool")
1016 EXPECT_EQ("bool", cur.attrname());
1017 EXPECT_EQ(AttributeType::Boolean, cur.type());
1018 EXPECT_EQ(AttributeType::Boolean, cur.base_type());
1019 EXPECT_EQ(0, cur.depth());
1020 bool curBool = cur.getValue<bool>();
1021 EXPECT_EQ(true, curBool);
1023 if(cur.attrname() == "string")
1025 EXPECT_EQ("string", cur.attrname());
1026 EXPECT_EQ(AttributeType::String, cur.type());
1027 EXPECT_EQ(AttributeType::String, cur.base_type());
1028 EXPECT_EQ(0, cur.depth());
1029 string curStr = cur.getValue<string>();
1030 EXPECT_EQ("this is a string", curStr);
1035 TEST(OCRepresentationIterator, iterator)
1037 OCRepresentation rep;
1038 OCRepresentation sub1;
1039 sub1.setUri("sub rep1 URI");
1040 OCRepresentation sub2;
1041 sub2.setUri("sub rep2 URI");
1042 OCRepresentation sub3;
1043 sub3.setUri("sub rep3 URI");
1044 OCRepresentation sub4;
1045 sub4.setUri("sub rep4 URI");
1046 OCRepresentation sub5;
1047 sub5.setUri("sub rep5 URI");
1048 OCRepresentation sub6;
1049 sub6.setUri("sub rep6 URI");
1052 EXPECT_TRUE(rep.empty());
1053 rep.setValue("int", 8);
1054 EXPECT_FALSE(rep.empty());
1055 rep.setValue("double", 8.8);
1056 rep.setValue("bool", true);
1057 rep.setValue("string", std::string("this is a string"));
1058 rep.setValue("rep", sub1);
1060 vector<int> intv {1,2,3,4};
1061 rep.setValue("intv", intv);
1062 vector<double> doublev {1.1,2.2,3.3,4.4};
1063 rep.setValue("doublev", doublev);
1064 vector<bool> boolv{false, false, true};
1065 rep.setValue("boolv", boolv);
1066 vector<string> strv{"abc", "def", "ghi"};
1067 rep.setValue("strv", strv);
1068 vector<OCRepresentation> repv { sub1, sub2 };
1069 rep.setValue("repv", repv);
1071 vector<vector<int>> intvv{{1,2,3},{4,5,6}};
1072 rep.setValue("intvv", intvv);
1073 vector<vector<vector<int>>> intvvv{{{1,2},{3,4}},{{5,6},{8,7}}};
1074 rep.setValue("intvvv", intvvv);
1076 vector<vector<double>> doublevv{{1.1,2.1,3},{4.4,5.4,6.4}};
1077 rep.setValue("doublevv", doublevv);
1078 vector<vector<vector<double>>> doublevvv{{{1.1,2.1},{3.1,4.1}},{{5.1,6.1},{8.1,7.1}}};
1079 rep.setValue("doublevvv", doublevvv);
1081 vector<vector<bool>> boolvv{{false, true},{true, false}};
1082 rep.setValue("boolvv", boolvv);
1083 vector<vector<vector<bool>>> boolvvv{{{true, false},{true}},{{false},{true}}};
1084 rep.setValue("boolvvv", boolvvv);
1086 vector<vector<string>> strvv{{"abc", "def"},{"wer", "qwer"}};
1087 rep.setValue("strvv", strvv);
1088 vector<vector<vector<string>>> strvvv{{{"wqr", "xcv"},{"234"}},{{"we"},{"wert"}}};
1089 rep.setValue("strvvv", strvvv);
1091 vector<vector<OCRepresentation>> repvv{{sub1, sub2},{sub3, sub4}};
1092 rep.setValue("repvv", repvv);
1093 vector<vector<vector<OCRepresentation>>> repvvv{{{sub5},{sub6}},{{sub3},{sub2}}};
1094 rep.setValue("repvvv", repvvv);
1096 EXPECT_EQ(20, rep.size());
1097 EXPECT_FALSE(rep.empty());
1099 OCRepresentation::iterator itr= rep.begin();
1100 OCRepresentation::iterator endItr = rep.end();
1102 for(;itr!=endItr;++itr)
1104 if(itr->attrname() == "int")
1106 EXPECT_EQ("int", itr->attrname());
1107 EXPECT_EQ(AttributeType::Integer, itr->type());
1108 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1109 EXPECT_EQ(0, itr->depth());
1110 int curInt = (*itr).getValue<int>();
1111 EXPECT_EQ(8, curInt);
1113 else if (itr->attrname() == "double")
1115 EXPECT_EQ("double", itr->attrname());
1116 EXPECT_EQ(AttributeType::Double, itr->type());
1117 EXPECT_EQ(AttributeType::Double, itr->base_type());
1118 EXPECT_EQ(0, itr->depth());
1119 double curDouble = (*itr).getValue<double>();
1120 EXPECT_EQ(8.8, curDouble);
1122 else if (itr->attrname() == "bool")
1124 EXPECT_EQ("bool", itr->attrname());
1125 EXPECT_EQ(AttributeType::Boolean, itr->type());
1126 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1127 EXPECT_EQ(0, itr->depth());
1128 bool curBool = (*itr).getValue<bool>();
1129 EXPECT_EQ(true, curBool);
1131 else if (itr->attrname() == "string")
1133 EXPECT_EQ("string", itr->attrname());
1134 EXPECT_EQ(AttributeType::String, itr->type());
1135 EXPECT_EQ(AttributeType::String, itr->base_type());
1136 EXPECT_EQ(0, itr->depth());
1137 string curString = (*itr).getValue<string>();
1138 EXPECT_EQ("this is a string", curString);
1140 else if (itr->attrname() == "rep")
1142 EXPECT_EQ("rep", itr->attrname());
1143 EXPECT_EQ(AttributeType::OCRepresentation, itr->type());
1144 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1145 EXPECT_EQ(0, itr->depth());
1146 OCRepresentation curRep = (*itr).getValue<OCRepresentation>();
1147 EXPECT_EQ(sub1.getUri(), curRep.getUri());
1149 else if (itr->attrname() == "intv")
1151 EXPECT_EQ("intv", itr->attrname());
1152 EXPECT_EQ(AttributeType::Vector, itr->type());
1153 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1154 EXPECT_EQ(1, itr->depth());
1155 vector<int> curv = (*itr).getValue<vector<int>>();
1156 EXPECT_EQ(intv, curv);
1158 else if (itr->attrname() == "doublev")
1160 EXPECT_EQ("doublev", itr->attrname());
1161 EXPECT_EQ(AttributeType::Vector, itr->type());
1162 EXPECT_EQ(AttributeType::Double, itr->base_type());
1163 EXPECT_EQ(1, itr->depth());
1164 vector<double> curv = (*itr).getValue<vector<double>>();
1165 EXPECT_EQ(doublev, curv);
1167 else if (itr->attrname() == "boolv")
1169 EXPECT_EQ("boolv", itr->attrname());
1170 EXPECT_EQ(AttributeType::Vector, itr->type());
1171 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1172 EXPECT_EQ(1, itr->depth());
1173 vector<bool> curv = (*itr).getValue<vector<bool>>();
1174 EXPECT_EQ(boolv, curv);
1176 else if (itr->attrname() == "strv")
1178 EXPECT_EQ("strv", itr->attrname());
1179 EXPECT_EQ(AttributeType::Vector, itr->type());
1180 EXPECT_EQ(AttributeType::String, itr->base_type());
1181 EXPECT_EQ(1, itr->depth());
1182 vector<string> curv = (*itr).getValue<vector<string>>();
1183 EXPECT_EQ(strv, curv);
1185 else if (itr->attrname() == "repv")
1187 EXPECT_EQ("repv", itr->attrname());
1188 EXPECT_EQ(AttributeType::Vector, itr->type());
1189 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1190 EXPECT_EQ(1, itr->depth());
1191 vector<OCRepresentation> curv = (*itr).getValue<vector<OCRepresentation>>();
1192 EXPECT_EQ(2, repv.size());
1193 EXPECT_EQ(sub1.getUri(), repv[0].getUri());
1194 EXPECT_EQ(sub2.getUri(), repv[1].getUri());
1196 else if (itr->attrname() == "intvv")
1198 EXPECT_EQ("intvv", itr->attrname());
1199 EXPECT_EQ(AttributeType::Vector, itr->type());
1200 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1201 EXPECT_EQ(2, itr->depth());
1202 vector<vector<int>> curv = (*itr).getValue<vector<vector<int>>>();
1203 EXPECT_EQ(intvv, curv);
1205 else if (itr->attrname() == "intvvv")
1207 EXPECT_EQ("intvvv", itr->attrname());
1208 EXPECT_EQ(AttributeType::Vector, itr->type());
1209 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1210 EXPECT_EQ(3, itr->depth());
1211 vector<vector<vector<int>>> curv = (*itr).getValue<vector<vector<vector<int>>>>();
1212 EXPECT_EQ(intvvv, curv);
1214 else if (itr->attrname() == "doublevv")
1216 EXPECT_EQ("doublevv", itr->attrname());
1217 EXPECT_EQ(AttributeType::Vector, itr->type());
1218 EXPECT_EQ(AttributeType::Double, itr->base_type());
1219 EXPECT_EQ(2, itr->depth());
1220 vector<vector<double>> curv = (*itr).getValue<vector<vector<double>>>();
1221 EXPECT_EQ(doublevv, curv);
1223 else if (itr->attrname() == "doublevvv")
1225 EXPECT_EQ("doublevvv", itr->attrname());
1226 EXPECT_EQ(AttributeType::Vector, itr->type());
1227 EXPECT_EQ(AttributeType::Double, itr->base_type());
1228 EXPECT_EQ(3, itr->depth());
1229 vector<vector<vector<double>>> curv =
1230 (*itr).getValue<vector<vector<vector<double>>>>();
1231 EXPECT_EQ(doublevvv, curv);
1233 else if (itr->attrname() == "boolvv")
1235 EXPECT_EQ("boolvv", itr->attrname());
1236 EXPECT_EQ(AttributeType::Vector, itr->type());
1237 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1238 EXPECT_EQ(2, itr->depth());
1239 vector<vector<bool>> curv = (*itr).getValue<vector<vector<bool>>>();
1240 EXPECT_EQ(boolvv, curv);
1242 else if (itr->attrname() == "boolvvv")
1244 EXPECT_EQ("boolvvv", itr->attrname());
1245 EXPECT_EQ(AttributeType::Vector, itr->type());
1246 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1247 EXPECT_EQ(3, itr->depth());
1248 vector<vector<vector<bool>>> curv = (*itr).getValue<vector<vector<vector<bool>>>>();
1249 EXPECT_EQ(boolvvv, curv);
1251 else if (itr->attrname() == "strvv")
1253 EXPECT_EQ("strvv", itr->attrname());
1254 EXPECT_EQ(AttributeType::Vector, itr->type());
1255 EXPECT_EQ(AttributeType::String, itr->base_type());
1256 EXPECT_EQ(2, itr->depth());
1257 vector<vector<string>> curv = (*itr).getValue<vector<vector<string>>>();
1258 EXPECT_EQ(strvv, curv);
1260 else if (itr->attrname() == "strvvv")
1262 EXPECT_EQ("strvvv", itr->attrname());
1263 EXPECT_EQ(AttributeType::Vector, itr->type());
1264 EXPECT_EQ(AttributeType::String, itr->base_type());
1265 EXPECT_EQ(3, itr->depth());
1266 vector<vector<vector<string>>> curv =
1267 (*itr).getValue<vector<vector<vector<string>>>>();
1268 EXPECT_EQ(strvvv, curv);
1270 else if (itr->attrname() == "repvv")
1272 EXPECT_EQ("repvv", itr->attrname());
1273 EXPECT_EQ(AttributeType::Vector, itr->type());
1274 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1275 EXPECT_EQ(2, itr->depth());
1276 vector<vector<OCRepresentation>> curv =
1277 (*itr).getValue<vector<vector<OCRepresentation>>>();
1278 EXPECT_EQ(2, curv.size());
1279 EXPECT_EQ(2, curv[0].size());
1280 EXPECT_EQ(sub1.getUri(), curv[0][0].getUri());
1281 EXPECT_EQ(sub2.getUri(), curv[0][1].getUri());
1282 EXPECT_EQ(2, curv[1].size());
1283 EXPECT_EQ(sub3.getUri(), curv[1][0].getUri());
1284 EXPECT_EQ(sub4.getUri(), curv[1][1].getUri());
1286 else if (itr->attrname() == "repvvv")
1288 EXPECT_EQ("repvvv", itr->attrname());
1289 EXPECT_EQ(AttributeType::Vector, itr->type());
1290 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1291 EXPECT_EQ(3, itr->depth());
1292 vector<vector<vector<OCRepresentation>>> curv =
1293 (*itr).getValue<vector<vector<vector<OCRepresentation>>>>();
1294 EXPECT_EQ(2, curv.size());
1295 EXPECT_EQ(2, curv[0].size());
1296 EXPECT_EQ(1, curv[0][0].size());
1297 EXPECT_EQ(sub5.getUri(), curv[0][0][0].getUri());
1298 EXPECT_EQ(1, curv[0][1].size());
1299 EXPECT_EQ(sub6.getUri(), curv[0][1][0].getUri());
1300 EXPECT_EQ(1, curv[1][0].size());
1301 EXPECT_EQ(sub3.getUri(), curv[1][0][0].getUri());
1302 EXPECT_EQ(1, curv[1][1].size());
1303 EXPECT_EQ(sub2.getUri(), curv[1][1][0].getUri());
1307 EXPECT_TRUE(false) << itr->attrname();