resource/unittests/OCRepresentationTest.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2014 Intel Mobile Communications GmbH All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   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
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  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.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include <gtest/gtest.h>
  22 #include <OCApi.h>
  23 #include <string>
  24 #include <limits>
  25 #include <boost/lexical_cast.hpp>
  26 namespace OCRepresentationTest
  27 {
  28     using namespace OC;
  29     using std::string;
  30     using std::vector;
  31
  32     template<typename T>
  33     void parsedEqual(T expected, const std::string& actualStr)
  34     {
  35         T actual = boost::lexical_cast<T>(actualStr);
  36         EXPECT_LT(std::abs(expected - actual), std::numeric_limits<T>::epsilon());
  37     }
  38
  39     // getValueToString(all types)
  40     TEST(OCRepresentationValueToString, Null)
  41     {
  42         static const std::string AttrName = "NullTest";
  43         OCRepresentation rep;
  44         rep.setNULL(AttrName);
  45
  46         EXPECT_TRUE(rep.isNULL(AttrName));
  47         EXPECT_EQ("(null)", rep.getValueToString(AttrName));
  48         EXPECT_EQ("(null)", rep[AttrName].getValueToString());
  49     }
  50
  51     TEST(OCRepresentationValueToString, Integer)
  52     {
  53         static const std::string AttrName = "IntTest";
  54         OCRepresentation rep;
  55
  56         rep.setValue(AttrName, -5);
  57         EXPECT_EQ("-5", rep.getValueToString(AttrName));
  58         EXPECT_EQ("-5", rep[AttrName].getValueToString());
  59
  60         rep.setValue(AttrName, 0);
  61         EXPECT_EQ("0", rep.getValueToString(AttrName));
  62         EXPECT_EQ("0", rep[AttrName].getValueToString());
  63
  64         rep.setValue(AttrName, 5);
  65         EXPECT_EQ("5", rep.getValueToString(AttrName));
  66         EXPECT_EQ("5", rep[AttrName].getValueToString());
  67
  68         rep.setValue(AttrName, 54321);
  69         EXPECT_EQ("54321", rep.getValueToString(AttrName));
  70         EXPECT_EQ("54321", rep[AttrName].getValueToString());
  71     }
  72
  73     TEST(OCRepresentationValueToString, Double)
  74     {
  75         static const std::string AttrName = "DoubleTest";
  76         OCRepresentation rep;
  77
  78         rep.setValue(AttrName, -5.0);
  79         parsedEqual(-5.0, rep.getValueToString(AttrName));
  80         parsedEqual(-5.0, rep[AttrName].getValueToString());
  81
  82         rep.setValue(AttrName, 0.0);
  83         parsedEqual(0.0, rep.getValueToString(AttrName));
  84         parsedEqual(0.0, rep[AttrName].getValueToString());
  85
  86         rep.setValue(AttrName, 5.0);
  87         parsedEqual(5.0, rep.getValueToString(AttrName));
  88         parsedEqual(5.0, rep[AttrName].getValueToString());
  89
  90         rep.setValue(AttrName, 54321.0);
  91         parsedEqual(54321.0, rep.getValueToString(AttrName));
  92         parsedEqual(54321.0, rep[AttrName].getValueToString());
  93
  94         rep.setValue(AttrName, 3.55);
  95         parsedEqual(3.55, rep.getValueToString(AttrName));
  96         parsedEqual(3.55, rep[AttrName].getValueToString());
  97
  98         rep.setValue(AttrName, -4.95);
  99         parsedEqual(-4.95, rep.getValueToString(AttrName));
 100         parsedEqual(-4.95, rep[AttrName].getValueToString());
 101
 102         rep.setValue(AttrName, 99999.5555);
 103         parsedEqual(99999.5555, rep.getValueToString(AttrName));
 104         parsedEqual(99999.5555, rep[AttrName].getValueToString());
 105     }
 106
 107     TEST(OCRepresentationValueToString, Boolean)
 108     {
 109         static const std::string AttrName = "BooleanTest";
 110         OCRepresentation rep;
 111
 112         rep.setValue(AttrName, false);
 113         EXPECT_EQ("false", rep.getValueToString(AttrName));
 114         EXPECT_EQ("false", rep[AttrName].getValueToString());
 115
 116         rep.setValue(AttrName, true);
 117         EXPECT_EQ("true", rep.getValueToString(AttrName));
 118         EXPECT_EQ("true", rep[AttrName].getValueToString());
 119     }
 120
 121     TEST(OCRepresentationValueToString, String)
 122     {
 123         static const std::string AttrName = "StringTest";
 124         OCRepresentation rep;
 125
 126         rep.setValue(AttrName, std::string("test 1"));
 127         EXPECT_EQ("test 1", rep.getValueToString(AttrName));
 128         EXPECT_EQ("test 1", rep[AttrName].getValueToString());
 129
 130         rep.setValue(AttrName, std::string("test 2"));
 131         EXPECT_EQ("test 2", rep.getValueToString(AttrName));
 132         EXPECT_EQ("test 2", rep[AttrName].getValueToString());
 133     }
 134
 135     TEST(OCRepresentationValueToString, SubRepresentation)
 136     {
 137         static const std::string AttrName = "SubRepTest";
 138         OCRepresentation rep;
 139         OCRepresentation sub1;
 140         OCRepresentation sub2;
 141
 142         rep.setValue(AttrName, sub1);
 143         EXPECT_EQ("OC::OCRepresentation", rep.getValueToString(AttrName));
 144         EXPECT_EQ("OC::OCRepresentation", rep[AttrName].getValueToString());
 145
 146         rep.setValue(AttrName, sub2);
 147         EXPECT_EQ("OC::OCRepresentation", rep.getValueToString(AttrName));
 148         EXPECT_EQ("OC::OCRepresentation", rep[AttrName].getValueToString());
 149     }
 150
 151     TEST(OCRepresentationValueToString, IntegerVector)
 152     {
 153         static const std::string AttrName = "VectorTest";
 154         OCRepresentation rep;
 155
 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());
 161
 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());
 165     }
 166
 167     TEST(OCRepresentationValueToString, IntegerVectorVector)
 168     {
 169         static const std::string AttrName = "VectorTest";
 170         OCRepresentation rep;
 171
 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};
 175
 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());
 180     }
 181
 182     TEST(OCRepresentationValueToString, IntegerVectorVectorVector)
 183     {
 184         static const std::string AttrName = "VectorTest";
 185         OCRepresentation rep;
 186
 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());
 199     }
 200
 201     TEST(OCRepresentationValueToString, DoubleVector)
 202     {
 203         static const std::string AttrName = "VectorTest";
 204         OCRepresentation rep;
 205
 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());
 210
 211         rep.setValue(AttrName, vect2);
 212         EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
 213     }
 214
 215     TEST(OCRepresentationValueToString, DoubleVectorVector)
 216     {
 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};
 222
 223         rep.setValue(AttrName, vect);
 224         EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
 225     }
 226
 227     TEST(OCRepresentationValueToString, DoubleVectorVectorVector)
 228     {
 229         static const std::string AttrName = "VectorTest";
 230         OCRepresentation rep;
 231
 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());
 241     }
 242
 243     TEST(OCRepresentationValueToString, BooleanVector)
 244     {
 245         static const std::string AttrName = "VectorTest";
 246         OCRepresentation rep;
 247
 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());
 253
 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());
 257     }
 258
 259     TEST(OCRepresentationValueToString, BooleanVectorVector)
 260     {
 261         static const std::string AttrName = "VectorTest";
 262         OCRepresentation rep;
 263
 264         vector<bool> vect1 {true, false, false, true};
 265         vector<bool> vect2 {false, false, false, true};
 266         vector<vector<bool>> vect{vect1, vect2};
 267
 268         rep.setValue(AttrName, vect);
 269         static const string Expected="[[true false false true ] [false false false true ] ]";
 270
 271         EXPECT_EQ(Expected, rep.getValueToString(AttrName));
 272         EXPECT_EQ(Expected, rep[AttrName].getValueToString());
 273     }
 274
 275     TEST(OCRepresentationValueToString, BooleanVectorVectorVector)
 276     {
 277         static const std::string AttrName = "VectorTest";
 278         OCRepresentation rep;
 279
 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());
 293     }
 294
 295     TEST(OCRepresentationValueToString, StringVector)
 296     {
 297         static const std::string AttrName = "VectorTest";
 298         OCRepresentation rep;
 299
 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());
 305
 306         rep.setValue(AttrName, vect2);
 307         EXPECT_EQ("[s4 s5 s6 ]", rep.getValueToString(AttrName));
 308         EXPECT_EQ("[s4 s5 s6 ]", rep[AttrName].getValueToString());
 309     }
 310
 311     TEST(OCRepresentationValueToString, StringVectorVector)
 312     {
 313         static const std::string AttrName = "VectorTest";
 314         OCRepresentation rep;
 315
 316         vector<string> vect1 {"s1", "s2", "s3"};
 317         vector<string> vect2 {"s4", "s5", "s6"};
 318         vector<vector<string>> vect{vect1, vect2};
 319
 320         rep.setValue(AttrName, vect);
 321         static const string Expected="[[s1 s2 s3 ] [s4 s5 s6 ] ]";
 322
 323         EXPECT_EQ(Expected, rep.getValueToString(AttrName));
 324         EXPECT_EQ(Expected, rep[AttrName].getValueToString());
 325     }
 326
 327     TEST(OCRepresentationValueToString, StringVectorVectorVector)
 328     {
 329         static const std::string AttrName = "VectorTest";
 330         OCRepresentation rep;
 331
 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());
 345     }
 346
 347     TEST(OCRepresentationValueToString, SubRepresentationVector)
 348     {
 349         static const std::string AttrName = "VectorTest";
 350         OCRepresentation rep;
 351
 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());
 358     }
 359
 360     TEST(OCRepresentationValueToString, SubRepresentationVectorVector)
 361     {
 362         static const std::string AttrName = "VectorTest";
 363         OCRepresentation rep;
 364
 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());
 377     }
 378
 379     TEST(OCRepresentationValueToString, SubRepresentationVectorVectorVector)
 380     {
 381         static const std::string AttrName = "VectorTest";
 382         OCRepresentation rep;
 383
 384         OCRepresentation sub1;
 385         OCRepresentation sub2;
 386         OCRepresentation sub3;
 387         OCRepresentation sub4;
 388         OCRepresentation sub5;
 389         OCRepresentation sub6;
 390
 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};
 398
 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());
 406     }
 407
 408     // Subscript get/set (all types)
 409     TEST(OCRepresentationSubscript, NullPtr)
 410     {
 411         static const std::string AttrName = "NullTest";
 412         OCRepresentation rep;
 413         rep[AttrName] = nullptr;
 414         EXPECT_TRUE(rep.isNULL(AttrName));
 415
 416         std::nullptr_t repout = rep[AttrName];
 417         std::nullptr_t repout2;
 418         repout2 = rep[AttrName];
 419
 420         EXPECT_EQ(nullptr, repout);
 421         EXPECT_EQ(nullptr, repout2);
 422
 423         double badout;
 424         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 425         string badoutstr;
 426         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 427         (void)badout;
 428         (void)badoutstr;
 429     }
 430
 431     TEST(OCRepresentationSubscript, Integer)
 432     {
 433         static const std::string AttrName = "IntTest";
 434         OCRepresentation rep;
 435         int repsource = -5;
 436         rep[AttrName] = repsource;
 437         int repout = rep[AttrName];
 438         int repout2;
 439         repout2 = rep[AttrName];
 440
 441         EXPECT_EQ(repsource, repout);
 442         EXPECT_EQ(repsource, repout2);
 443
 444         double badout;
 445         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 446         string badoutstr;
 447         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 448         (void)badout;
 449         (void)badoutstr;
 450     }
 451
 452     TEST(OCRepresentationSubscript, Double)
 453     {
 454         static const std::string AttrName = "DoubleTest";
 455         OCRepresentation rep;
 456         double repsource = -5.33;
 457         rep[AttrName] = repsource;
 458         double repout = rep[AttrName];
 459         double repout2;
 460         repout2 = rep[AttrName];
 461
 462         EXPECT_EQ(repsource, repout);
 463         EXPECT_EQ(repsource, repout2);
 464
 465         int badout;
 466         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 467         string badoutstr;
 468         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 469         (void)badout;
 470         (void)badoutstr;
 471     }
 472
 473     TEST(OCRepresentationSubscript, Boolean)
 474     {
 475         static const std::string AttrName = "BooleanTest";
 476         OCRepresentation rep;
 477         bool repsource = true;
 478         rep[AttrName] = repsource;
 479         bool repout = rep[AttrName];
 480         bool repout2;
 481         repout2 = rep[AttrName];
 482
 483         EXPECT_EQ(repsource, repout);
 484         EXPECT_EQ(repsource, repout2);
 485
 486         repsource = false;
 487         rep[AttrName] = repsource;
 488         repout = rep[AttrName];
 489
 490         EXPECT_EQ(repsource, repout);
 491
 492         int badout;
 493         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 494         string badoutstr;
 495         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 496         (void)badout;
 497         (void)badoutstr;
 498     }
 499
 500     TEST(OCRepresentationSubscript, String)
 501     {
 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];
 507         string repout2;
 508         repout2 = rep[AttrName];
 509
 510         EXPECT_EQ(repsource, repout);
 511         EXPECT_EQ(repsource, repout2);
 512
 513         double badout;
 514         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 515         (void)badout;
 516     }
 517
 518     TEST(OCRepresentationSubscript, SubRepresentation)
 519     {
 520         static const std::string AttrName = "SubRepresentationTest";
 521         OCRepresentation rep;
 522         OCRepresentation repsource;
 523         repsource.setUri("This is a uri");
 524
 525         rep[AttrName] = repsource;
 526         OCRepresentation repout = rep[AttrName];
 527         OCRepresentation repout2;
 528         repout2 = rep[AttrName];
 529
 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());
 534
 535         double badout;
 536         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 537         string badoutstr;
 538         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 539         (void)badout;
 540         (void)badoutstr;
 541     }
 542
 543     TEST(OCRepresentationSubscript, IntegerVector)
 544     {
 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];
 550         vector<int> repout2;
 551         repout2 = rep[AttrName];
 552
 553         EXPECT_EQ(repsource, repout);
 554         EXPECT_EQ(repsource, repout2);
 555
 556         double badout;
 557         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 558         string badoutstr;
 559         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 560         (void)badout;
 561         (void)badoutstr;
 562     }
 563
 564     TEST(OCRepresentationSubscript, IntegerVectorVector)
 565     {
 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];
 573
 574         EXPECT_EQ(repsource, repout);
 575         EXPECT_EQ(repsource, repout2);
 576
 577         double badout;
 578         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 579         string badoutstr;
 580         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 581         (void)badout;
 582         (void)badoutstr;
 583     }
 584
 585     TEST(OCRepresentationSubscript, IntegerVectorVectorVector)
 586     {
 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];
 594
 595         EXPECT_EQ(repsource, repout);
 596         EXPECT_EQ(repsource, repout2);
 597
 598         double badout;
 599         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 600         string badoutstr;
 601         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 602         (void)badout;
 603         (void)badoutstr;
 604     }
 605
 606     TEST(OCRepresentationSubscript, DoubleVector)
 607     {
 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];
 615
 616         EXPECT_EQ(repsource, repout);
 617         EXPECT_EQ(repsource, repout2);
 618
 619         double badout;
 620         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 621         string badoutstr;
 622         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 623         (void)badout;
 624         (void)badoutstr;
 625     }
 626
 627     TEST(OCRepresentationSubscript, DoubleVectorVector)
 628     {
 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];
 636
 637         EXPECT_EQ(repsource, repout);
 638         EXPECT_EQ(repsource, repout2);
 639
 640         double badout;
 641         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 642         string badoutstr;
 643         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 644         (void)badout;
 645         (void)badoutstr;
 646     }
 647
 648     TEST(OCRepresentationSubscript, DoubleVectorVectorVector)
 649     {
 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];
 658
 659         EXPECT_EQ(repsource, repout);
 660         EXPECT_EQ(repsource, repout2);
 661
 662         double badout;
 663         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 664         string badoutstr;
 665         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 666         (void)badout;
 667         (void)badoutstr;
 668     }
 669
 670     TEST(OCRepresentationSubscript, BooleanVector)
 671     {
 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];
 679
 680         EXPECT_EQ(repsource, repout);
 681         EXPECT_EQ(repsource, repout2);
 682
 683         double badout;
 684         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 685         string badoutstr;
 686         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 687         (void)badout;
 688         (void)badoutstr;
 689     }
 690
 691     TEST(OCRepresentationSubscript, BooleanVectorVector)
 692     {
 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];
 700
 701         EXPECT_EQ(repsource, repout);
 702         EXPECT_EQ(repsource, repout2);
 703
 704         double badout;
 705         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 706         string badoutstr;
 707         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 708         (void)badout;
 709         (void)badoutstr;
 710     }
 711
 712     TEST(OCRepresentationSubscript, BooleanVectorVectorVector)
 713     {
 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];
 722
 723         EXPECT_EQ(repsource, repout);
 724         EXPECT_EQ(repsource, repout2);
 725
 726         double badout;
 727         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 728         string badoutstr;
 729         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 730         (void)badout;
 731         (void)badoutstr;
 732     }
 733
 734     TEST(OCRepresentationSubscript, StringVector)
 735     {
 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];
 743
 744         EXPECT_EQ(repsource, repout);
 745         EXPECT_EQ(repsource, repout2);
 746
 747         double badout;
 748         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 749         string badoutstr;
 750         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 751         (void)badout;
 752         (void)badoutstr;
 753     }
 754
 755     TEST(OCRepresentationSubscript, StringVectorVector)
 756     {
 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];
 764
 765         EXPECT_EQ(repsource, repout);
 766         EXPECT_EQ(repsource, repout2);
 767
 768         double badout;
 769         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 770         string badoutstr;
 771         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 772         (void)badout;
 773         (void)badoutstr;
 774     }
 775
 776     TEST(OCRepresentationSubscript, StringVectorVectorVector)
 777     {
 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];
 786
 787         EXPECT_EQ(repsource, repout);
 788         EXPECT_EQ(repsource, repout2);
 789
 790         double badout;
 791         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 792         string badoutstr;
 793         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 794         (void)badout;
 795         (void)badoutstr;
 796     }
 797
 798     TEST(OCRepresentationSubscript, SubRepresentationVector)
 799     {
 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];
 810
 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());
 817
 818         double badout;
 819         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 820         string badoutstr;
 821         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 822         (void)badout;
 823         (void)badoutstr;
 824     }
 825
 826     TEST(OCRepresentationSubscript, SubRepresentationVectorVector)
 827     {
 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");
 835
 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];
 841
 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());
 850
 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());
 859
 860         double badout;
 861         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 862         string badoutstr;
 863         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 864         (void)badout;
 865         (void)badoutstr;
 866     }
 867
 868     TEST(OCRepresentationSubscript, SubRepresentationVectorVectorVector)
 869     {
 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");
 881
 882         vector<vector<vector<OCRepresentation>>> repsource
 883             {{{inner1, inner2},{inner3, inner4}},{{inner5, inner6},{inner7,inner8}}};
 884
 885         rep[AttrName] = repsource;
 886         vector<vector<vector<OCRepresentation>>> repout = rep[AttrName];
 887         vector<vector<vector<OCRepresentation>>> repout2;
 888         repout2 = rep[AttrName];
 889
 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());
 905
 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());
 921
 922         double badout;
 923         EXPECT_THROW(badout = rep[AttrName], boost::bad_get);
 924         string badoutstr;
 925         EXPECT_THROW(badoutstr = rep[AttrName], boost::bad_get);
 926         (void)badout;
 927         (void)badoutstr;
 928     }
 929
 930     TEST(OCRepresentationIterator, constiterator)
 931     {
 932         OCRepresentation rep;
 933
 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"));
 940
 941         EXPECT_EQ(4, rep.size());
 942         EXPECT_FALSE(rep.empty());
 943
 944         OCRepresentation::const_iterator itr = rep.cbegin();
 945         OCRepresentation::const_iterator endItr = rep.cend();
 946         for(;itr!=endItr;++itr);
 947
 948         const OCRepresentation& rep2(rep);
 949         OCRepresentation::const_iterator itr2 = rep2.begin();
 950         OCRepresentation::const_iterator endItr2 = rep2.end();
 951         for(;itr2!=endItr2;++itr2);
 952
 953     }
 954
 955     TEST(OCRepresentationIterator, constautoiterator)
 956     {
 957         OCRepresentation rep;
 958
 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"));
 965
 966         EXPECT_EQ(4, rep.size());
 967         EXPECT_FALSE(rep.empty());
 968
 969         for(const auto& a : rep)
 970         {
 971             (void)a;
 972         }
 973
 974         const OCRepresentation& rep2(rep);
 975         for(const auto& a : rep2)
 976         {
 977             (void)a;
 978         }
 979     }
 980     TEST(OCRepresentationIterator, autoiterator)
 981     {
 982         OCRepresentation rep;
 983
 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"));
 990
 991         EXPECT_EQ(4, rep.size());
 992         EXPECT_FALSE(rep.empty());
 993
 994         for(auto& cur : rep)
 995         {
 996             if(cur.attrname() == "int")
 997             {
 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);
1004             }
1005             if(cur.attrname() == "double")
1006             {
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);
1013             }
1014             if(cur.attrname() == "bool")
1015             {
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);
1022             }
1023             if(cur.attrname() == "string")
1024             {
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);
1031             }
1032         }
1033     }
1034     // Iterator usage
1035     TEST(OCRepresentationIterator, iterator)
1036     {
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");
1050
1051
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);
1059
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);
1070
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);
1075
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);
1080
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);
1085
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);
1090
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);
1095
1096         EXPECT_EQ(20, rep.size());
1097         EXPECT_FALSE(rep.empty());
1098
1099         OCRepresentation::iterator itr= rep.begin();
1100         OCRepresentation::iterator endItr = rep.end();
1101
1102         for(;itr!=endItr;++itr)
1103         {
1104             if(itr->attrname() == "int")
1105             {
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);
1112             }
1113             else if (itr->attrname() == "double")
1114             {
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);
1121             }
1122             else if (itr->attrname() == "bool")
1123             {
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);
1130             }
1131             else if (itr->attrname() == "string")
1132             {
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);
1139             }
1140             else if (itr->attrname() == "rep")
1141             {
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());
1148             }
1149             else if (itr->attrname() == "intv")
1150             {
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);
1157             }
1158             else if (itr->attrname() == "doublev")
1159             {
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);
1166             }
1167             else if (itr->attrname() == "boolv")
1168             {
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);
1175             }
1176             else if (itr->attrname() == "strv")
1177             {
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);
1184             }
1185             else if (itr->attrname() == "repv")
1186             {
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());
1195             }
1196             else if (itr->attrname() == "intvv")
1197             {
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);
1204             }
1205             else if (itr->attrname() == "intvvv")
1206             {
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);
1213             }
1214             else if (itr->attrname() == "doublevv")
1215             {
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);
1222             }
1223             else if (itr->attrname() == "doublevvv")
1224             {
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);
1232             }
1233             else if (itr->attrname() == "boolvv")
1234             {
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);
1241             }
1242             else if (itr->attrname() == "boolvvv")
1243             {
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);
1250             }
1251             else if (itr->attrname() == "strvv")
1252             {
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);
1259             }
1260             else if (itr->attrname() == "strvvv")
1261             {
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);
1269             }
1270             else if (itr->attrname() == "repvv")
1271             {
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());
1285             }
1286             else if (itr->attrname() == "repvvv")
1287             {
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());
1304             }
1305             else
1306             {
1307                 EXPECT_TRUE(false) << itr->attrname();
1308             }
1309         }
1310     }
1311 }