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     void parsedEqual(double expected, const std::string& actualStr)
  33     {
  34         double actual = boost::lexical_cast<double>(actualStr);
  35         EXPECT_GE(actual, expected - .0000001);
  36         EXPECT_LE(actual, expected + .0000001);
  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, ByteString)
 152     {
 153         static const std::string AttrName = "ByteStringTest";
 154         static uint8_t binval[] = {0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8,
 155                                    0x9, 0x0, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF};
 156
 157         OCByteString bytestring {binval, sizeof(binval)};
 158         OCRepresentation rep;
 159
 160         rep.setValue(AttrName, bytestring);
 161         const char* expected = "\\x1\\x2\\x3\\x4\\x5\\x6\\x7\\x8"
 162                                "\\x9\\x0\\xa\\xb\\xc\\xd\\xe\\xf";
 163         EXPECT_STREQ(expected, rep.getValueToString(AttrName).c_str() );
 164     }
 165
 166     TEST(OCRepresentationValueToString, IntegerVector)
 167     {
 168         static const std::string AttrName = "VectorTest";
 169         OCRepresentation rep;
 170
 171         vector<int> vect {1,2,3,4,5,6,7,8,9};
 172         vector<int> vect2 {-5,-3,-1,0,5,3,2};
 173         rep.setValue(AttrName, vect);
 174         EXPECT_EQ("[1 2 3 4 5 6 7 8 9 ]", rep.getValueToString(AttrName));
 175         EXPECT_EQ("[1 2 3 4 5 6 7 8 9 ]", rep[AttrName].getValueToString());
 176
 177         rep.setValue(AttrName, vect2);
 178         EXPECT_EQ("[-5 -3 -1 0 5 3 2 ]", rep.getValueToString(AttrName));
 179         EXPECT_EQ("[-5 -3 -1 0 5 3 2 ]", rep[AttrName].getValueToString());
 180     }
 181
 182     TEST(OCRepresentationValueToString, IntegerVectorVector)
 183     {
 184         static const std::string AttrName = "VectorTest";
 185         OCRepresentation rep;
 186
 187         vector<int> vect1 {1,2,3,4,5,6,7,8,9};
 188         vector<int> vect2 {-5,-3,-1,0,5,3,2};
 189         vector<vector<int>> vect{vect1, vect2};
 190
 191         rep.setValue(AttrName, vect);
 192         static const string Expected = "[[1 2 3 4 5 6 7 8 9 ] [-5 -3 -1 0 5 3 2 ] ]";
 193         EXPECT_EQ(Expected, rep.getValueToString(AttrName));
 194         EXPECT_EQ(Expected, rep[AttrName].getValueToString());
 195     }
 196
 197     TEST(OCRepresentationValueToString, IntegerVectorVectorVector)
 198     {
 199         static const std::string AttrName = "VectorTest";
 200         OCRepresentation rep;
 201
 202         vector<int> vect11 {1,2,3,4,5,6,7,8,9};
 203         vector<int> vect12 {-5,-3,-1,0,5,3,2};
 204         vector<vector<int>> vect1{vect11, vect12};
 205         vector<int> vect21 {2,0,1,6,9,3,8};
 206         vector<int> vect22 {9,7,8,100003};
 207         vector<vector<int>> vect2{vect21, vect22};
 208         vector<vector<vector<int>>> vect{vect1, vect2};
 209         rep.setValue(AttrName, vect);
 210         static const std::string Expected =
 211             "[[[1 2 3 4 5 6 7 8 9 ] [-5 -3 -1 0 5 3 2 ] ] [[2 0 1 6 9 3 8 ] [9 7 8 100003 ] ] ]";
 212         EXPECT_EQ(Expected, rep.getValueToString(AttrName));
 213         EXPECT_EQ(Expected, rep[AttrName].getValueToString());
 214     }
 215
 216     TEST(OCRepresentationValueToString, DoubleVector)
 217     {
 218         static const std::string AttrName = "VectorTest";
 219         OCRepresentation rep;
 220
 221         vector<double> vect {3.12, -5.3, 7.5, 1.110};
 222         vector<double> vect2 {2.1, -555.5, 0.0001, -0.2};
 223         rep.setValue(AttrName, vect);
 224         EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
 225
 226         rep.setValue(AttrName, vect2);
 227         EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
 228     }
 229
 230     TEST(OCRepresentationValueToString, DoubleVectorVector)
 231     {
 232         static const std::string AttrName = "VectorTest";
 233         OCRepresentation rep;
 234         vector<double> vect1 {30.1,5.88,-22.0,0};
 235         vector<double> vect2 {2.1,-55.5,0.1100,-.2};
 236         vector<vector<double>> vect{vect1, vect2};
 237
 238         rep.setValue(AttrName, vect);
 239         EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
 240     }
 241
 242     TEST(OCRepresentationValueToString, DoubleVectorVectorVector)
 243     {
 244         static const std::string AttrName = "VectorTest";
 245         OCRepresentation rep;
 246
 247         vector<double> vect11 {3.01, 5.88, -22.0, 0.0};
 248         vector<double> vect12 {99.3,8.0,.01236,-.22};
 249         vector<vector<double>> vect1{vect11, vect12};
 250         vector<double> vect21 {9.0,-1};
 251         vector<double> vect22 {-99.2};
 252         vector<vector<double>> vect2{vect21, vect22};
 253         vector<vector<vector<double>>> vect{vect1, vect2};
 254         rep.setValue(AttrName, vect);
 255         EXPECT_EQ(rep.getValueToString(AttrName), rep[AttrName].getValueToString());
 256     }
 257
 258     TEST(OCRepresentationValueToString, BooleanVector)
 259     {
 260         static const std::string AttrName = "VectorTest";
 261         OCRepresentation rep;
 262
 263         vector<bool> vect {true, false, false, true};
 264         vector<bool> vect2 {false, false, false, true};
 265         rep.setValue(AttrName, vect);
 266         EXPECT_EQ("[true false false true ]", rep.getValueToString(AttrName));
 267         EXPECT_EQ("[true false false true ]", rep[AttrName].getValueToString());
 268
 269         rep.setValue(AttrName, vect2);
 270         EXPECT_EQ("[false false false true ]", rep.getValueToString(AttrName));
 271         EXPECT_EQ("[false false false true ]", rep[AttrName].getValueToString());
 272     }
 273
 274     TEST(OCRepresentationValueToString, BooleanVectorVector)
 275     {
 276         static const std::string AttrName = "VectorTest";
 277         OCRepresentation rep;
 278
 279         vector<bool> vect1 {true, false, false, true};
 280         vector<bool> vect2 {false, false, false, true};
 281         vector<vector<bool>> vect{vect1, vect2};
 282
 283         rep.setValue(AttrName, vect);
 284         static const string Expected="[[true false false true ] [false false false true ] ]";
 285
 286         EXPECT_EQ(Expected, rep.getValueToString(AttrName));
 287         EXPECT_EQ(Expected, rep[AttrName].getValueToString());
 288     }
 289
 290     TEST(OCRepresentationValueToString, BooleanVectorVectorVector)
 291     {
 292         static const std::string AttrName = "VectorTest";
 293         OCRepresentation rep;
 294
 295         vector<bool> vect11 {true, false, false, true};
 296         vector<bool> vect12 {false, false, false, true};
 297         vector<vector<bool>> vect1{vect11, vect12};
 298         vector<bool> vect21 {false, true, true, false};
 299         vector<bool> vect22 {true, true, true, false};
 300         vector<vector<bool>> vect2{vect21, vect22};
 301         vector<vector<vector<bool>>> vect{vect1, vect2};
 302         rep.setValue(AttrName, vect);
 303         static const std::string Expected =
 304             "[[[true false false true ] [false false false true ] ]"
 305             " [[false true true false ] [true true true false ] ] ]";
 306         EXPECT_EQ(Expected, rep.getValueToString(AttrName));
 307         EXPECT_EQ(Expected, rep[AttrName].getValueToString());
 308     }
 309
 310     TEST(OCRepresentationValueToString, StringVector)
 311     {
 312         static const std::string AttrName = "VectorTest";
 313         OCRepresentation rep;
 314
 315         vector<string> vect {"s1", "s2", "s3"};
 316         vector<string> vect2 {"s4", "s5", "s6"};
 317         rep.setValue(AttrName, vect);
 318         EXPECT_EQ("[s1 s2 s3 ]", rep.getValueToString(AttrName));
 319         EXPECT_EQ("[s1 s2 s3 ]", rep[AttrName].getValueToString());
 320
 321         rep.setValue(AttrName, vect2);
 322         EXPECT_EQ("[s4 s5 s6 ]", rep.getValueToString(AttrName));
 323         EXPECT_EQ("[s4 s5 s6 ]", rep[AttrName].getValueToString());
 324     }
 325
 326     TEST(OCRepresentationValueToString, StringVectorVector)
 327     {
 328         static const std::string AttrName = "VectorTest";
 329         OCRepresentation rep;
 330
 331         vector<string> vect1 {"s1", "s2", "s3"};
 332         vector<string> vect2 {"s4", "s5", "s6"};
 333         vector<vector<string>> vect{vect1, vect2};
 334
 335         rep.setValue(AttrName, vect);
 336         static const string Expected="[[s1 s2 s3 ] [s4 s5 s6 ] ]";
 337
 338         EXPECT_EQ(Expected, rep.getValueToString(AttrName));
 339         EXPECT_EQ(Expected, rep[AttrName].getValueToString());
 340     }
 341
 342     TEST(OCRepresentationValueToString, StringVectorVectorVector)
 343     {
 344         static const std::string AttrName = "VectorTest";
 345         OCRepresentation rep;
 346
 347         vector<string> vect11 {"s1", "s2", "s3"};
 348         vector<string> vect12 {"s4", "s5", "s6"};
 349         vector<vector<string>> vect1{vect11, vect12};
 350         vector<string> vect21 {"s7", "s8"};
 351         vector<string> vect22 {"s9"};
 352         vector<vector<string>> vect2{vect21, vect22};
 353         vector<vector<vector<string>>> vect{vect1, vect2};
 354         rep.setValue(AttrName, vect);
 355         static const std::string Expected =
 356             "[[[s1 s2 s3 ] [s4 s5 s6 ] ]"
 357             " [[s7 s8 ] [s9 ] ] ]";
 358         EXPECT_EQ(Expected, rep.getValueToString(AttrName));
 359         EXPECT_EQ(Expected, rep[AttrName].getValueToString());
 360     }
 361
 362     TEST(OCRepresentationValueToByteString, ByteStringVector)
 363     {
 364         static const std::string AttrName = "VectorTest";
 365         OCRepresentation rep;
 366
 367         uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
 368         OCByteString s1 {binval1, sizeof(binval1)};
 369         uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
 370         OCByteString s2 {binval2, sizeof(binval2)};
 371         uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
 372         OCByteString s3 {binval3, sizeof(binval3)};
 373         vector<OCByteString> vect {s1, s2, s3};
 374
 375         uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
 376         OCByteString s4 {binval4, sizeof(binval4)};
 377         uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
 378         OCByteString s5 {binval5, sizeof(binval5)};
 379         uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
 380         OCByteString s6 {binval6, sizeof(binval6)};
 381         vector<OCByteString> vect2 {s4, s5, s6};
 382
 383         rep.setValue(AttrName, vect);
 384         const char *expected1tob = "[\\x1\\x2\\x3\\x4 \\x5\\x6\\x7\\x8 \\x9\\x0\\xa\\xb ]";
 385         EXPECT_EQ(expected1tob, rep.getValueToString(AttrName));
 386         EXPECT_EQ(expected1tob, rep[AttrName].getValueToString());
 387
 388         rep.setValue(AttrName, vect2);
 389         const char *expectedcto18 = "[\\xc\\xd\\xe\\xf \\x11\\x12\\x13\\x14 \\x15\\x16\\x17\\x18 ]";
 390         EXPECT_EQ(expectedcto18, rep.getValueToString(AttrName));
 391         EXPECT_EQ(expectedcto18, rep[AttrName].getValueToString());
 392     }
 393
 394     TEST(OCRepresentationValueToByteString, ByteStringVectorVector)
 395     {
 396         static const std::string AttrName = "VectorTest";
 397         OCRepresentation rep;
 398
 399         uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
 400         OCByteString s1 {binval1, sizeof(binval1)};
 401         uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
 402         OCByteString s2 {binval2, sizeof(binval2)};
 403         uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
 404         OCByteString s3 {binval3, sizeof(binval3)};
 405         vector<OCByteString> vect1 {s1, s2, s3};
 406
 407         uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
 408         OCByteString s4 {binval4, sizeof(binval4)};
 409         uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
 410         OCByteString s5 {binval5, sizeof(binval5)};
 411         uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
 412         OCByteString s6 {binval6, sizeof(binval6)};
 413         vector<OCByteString> vect2 {s4, s5, s6};
 414
 415         vector<vector<OCByteString>> vect {vect1, vect2};
 416
 417         rep.setValue(AttrName, vect);
 418
 419         const char *expected =
 420             "[["
 421             "\\x1\\x2\\x3\\x4 \\x5\\x6\\x7\\x8 \\x9\\x0\\xa\\xb "
 422             "] ["
 423             "\\xc\\xd\\xe\\xf \\x11\\x12\\x13\\x14 \\x15\\x16\\x17\\x18 "
 424             "] ]"
 425             ;
 426
 427         EXPECT_EQ(expected, rep.getValueToString(AttrName));
 428         EXPECT_EQ(expected, rep[AttrName].getValueToString());
 429     }
 430
 431     TEST(OCRepresentationValueToByteString, ByteStringVectorVectorVector)
 432     {
 433         static const std::string AttrName = "VectorTest";
 434         OCRepresentation rep;
 435
 436         uint8_t binval1[] = {0x1, 0x2, 0x3, 0x4};
 437         OCByteString s1 {binval1, sizeof(binval1)};
 438         uint8_t binval2[] = {0x5, 0x6, 0x7, 0x8};
 439         OCByteString s2 {binval2, sizeof(binval2)};
 440         uint8_t binval3[] = {0x9, 0x0, 0xA, 0xB};
 441         OCByteString s3 {binval3, sizeof(binval3)};
 442         vector<OCByteString> vect11 {s1, s2, s3};
 443
 444         uint8_t binval4[] = {0xC, 0xD, 0xE, 0xF};
 445         OCByteString s4 {binval4, sizeof(binval4)};
 446         uint8_t binval5[] = {0x11, 0x12, 0x13, 0x14};
 447         OCByteString s5 {binval5, sizeof(binval5)};
 448         uint8_t binval6[] = {0x15, 0x16, 0x17, 0x18};
 449         OCByteString s6 {binval6, sizeof(binval6)};
 450         vector<OCByteString> vect12 {s4, s5, s6};
 451
 452         uint8_t binval7[] = {0x19, 0x10, 0x1A, 0x1B};
 453         OCByteString s7 {binval7, sizeof(binval7)};
 454         uint8_t binval8[] = {0x1C, 0x1D, 0x1E, 0x1F};
 455         OCByteString s8 {binval8, sizeof(binval8)};
 456         vector<OCByteString> vect21 {s7, s8};
 457
 458         uint8_t binval9[] = {0x21, 0x22, 0x23, 0x24};
 459         OCByteString s9 {binval9, sizeof(binval9)};
 460         vector<OCByteString> vect22 {s9};
 461
 462         vector<vector<OCByteString>> vect1 {vect11, vect12};
 463         vector<vector<OCByteString>> vect2 {vect21, vect22};
 464         vector<vector<vector<OCByteString>>> vect {vect1, vect2};
 465         rep.setValue(AttrName, vect);
 466         static const std::string expected =
 467             "[[["
 468             "\\x1\\x2\\x3\\x4 \\x5\\x6\\x7\\x8 \\x9\\x0\\xa\\xb "
 469             "] ["
 470             "\\xc\\xd\\xe\\xf \\x11\\x12\\x13\\x14 \\x15\\x16\\x17\\x18 "
 471             "] ] [["
 472             "\\x19\\x10\\x1a\\x1b \\x1c\\x1d\\x1e\\x1f "
 473             "] ["
 474             "\\x21\\x22\\x23\\x24 "
 475             "] ] ]";
 476
 477         EXPECT_EQ(expected, rep.getValueToString(AttrName));
 478         EXPECT_EQ(expected, rep[AttrName].getValueToString());
 479     }
 480
 481     TEST(OCRepresentationValueToString, SubRepresentationVector)
 482     {
 483         static const std::string AttrName = "VectorTest";
 484         OCRepresentation rep;
 485
 486         OCRepresentation sub1;
 487         OCRepresentation sub2;
 488         vector<OCRepresentation> vect {sub1, sub2};
 489         rep.setValue(AttrName, vect);
 490         EXPECT_EQ("[OC::OCRepresentation OC::OCRepresentation ]", rep.getValueToString(AttrName));
 491         EXPECT_EQ("[OC::OCRepresentation OC::OCRepresentation ]", rep[AttrName].getValueToString());
 492     }
 493
 494     TEST(OCRepresentationValueToString, SubRepresentationVectorVector)
 495     {
 496         static const std::string AttrName = "VectorTest";
 497         OCRepresentation rep;
 498
 499         OCRepresentation sub1;
 500         OCRepresentation sub2;
 501         OCRepresentation sub3;
 502         OCRepresentation sub4;
 503         vector<OCRepresentation> vect1 {sub1, sub2};
 504         vector<OCRepresentation> vect2 {sub3, sub4};
 505         vector<vector<OCRepresentation>> vect{vect1, vect2};
 506         rep.setValue(AttrName, vect);
 507         static const string Expected = "[[OC::OCRepresentation OC::OCRepresentation ]"
 508             " [OC::OCRepresentation OC::OCRepresentation ] ]";
 509         EXPECT_EQ(Expected, rep.getValueToString(AttrName));
 510         EXPECT_EQ(Expected, rep[AttrName].getValueToString());
 511     }
 512
 513     TEST(OCRepresentationValueToString, SubRepresentationVectorVectorVector)
 514     {
 515         static const std::string AttrName = "VectorTest";
 516         OCRepresentation rep;
 517
 518         OCRepresentation sub1;
 519         OCRepresentation sub2;
 520         OCRepresentation sub3;
 521         OCRepresentation sub4;
 522         OCRepresentation sub5;
 523         OCRepresentation sub6;
 524
 525         vector<OCRepresentation> vect11 {sub1, sub2};
 526         vector<OCRepresentation> vect12 {sub3, sub4};
 527         vector<vector<OCRepresentation>> vect1{vect11, vect12};
 528         vector<OCRepresentation> vect21 {sub5};
 529         vector<OCRepresentation> vect22 {sub6};
 530         vector<vector<OCRepresentation>> vect2{vect21, vect22};
 531         vector<vector<vector<OCRepresentation>>> vect{vect1, vect2};
 532
 533         rep.setValue(AttrName, vect);
 534         static const string Expected =
 535             "[[[OC::OCRepresentation OC::OCRepresentation ] "
 536             "[OC::OCRepresentation OC::OCRepresentation ] ] "
 537             "[[OC::OCRepresentation ] [OC::OCRepresentation ] ] ]";
 538         EXPECT_EQ(Expected, rep.getValueToString(AttrName));
 539         EXPECT_EQ(Expected, rep[AttrName].getValueToString());
 540     }
 541
 542     // Subscript get/set (all types)
 543     TEST(OCRepresentationSubscript, NullPtr)
 544     {
 545         static const std::string AttrName = "NullTest";
 546         OCRepresentation rep;
 547         rep[AttrName] = nullptr;
 548         EXPECT_TRUE(rep.isNULL(AttrName));
 549
 550 // @todo: Re-enable this part of the unit test. MSVC can't assign to nullptr_t.
 551 #ifndef _MSC_VER
 552         std::nullptr_t repout = rep[AttrName];
 553         std::nullptr_t repout2;
 554         repout2 = rep[AttrName];
 555
 556         EXPECT_EQ(nullptr, repout);
 557         EXPECT_EQ(nullptr, repout2);
 558 #endif
 559
 560         double badout;
 561         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 562         string badoutstr;
 563         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 564         (void)badout;
 565         (void)badoutstr;
 566     }
 567
 568     TEST(OCRepresentationSubscript, Integer)
 569     {
 570         static const std::string AttrName = "IntTest";
 571         OCRepresentation rep;
 572         int repsource = -5;
 573         rep[AttrName] = repsource;
 574         int repout = rep[AttrName];
 575         int repout2;
 576         repout2 = rep[AttrName];
 577
 578         EXPECT_EQ(repsource, repout);
 579         EXPECT_EQ(repsource, repout2);
 580
 581         double badout;
 582         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 583         string badoutstr;
 584         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 585         (void)badout;
 586         (void)badoutstr;
 587     }
 588
 589     TEST(OCRepresentationSubscript, Double)
 590     {
 591         static const std::string AttrName = "DoubleTest";
 592         OCRepresentation rep;
 593         double repsource = -5.33;
 594         rep[AttrName] = repsource;
 595         double repout = rep[AttrName];
 596         double repout2;
 597         repout2 = rep[AttrName];
 598
 599         EXPECT_EQ(repsource, repout);
 600         EXPECT_EQ(repsource, repout2);
 601
 602         int badout;
 603         EXPECT_FALSE(rep.getValue<int>(AttrName, badout));
 604         string badoutstr;
 605         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 606         (void)badout;
 607         (void)badoutstr;
 608     }
 609
 610     //Disabled this test due to older GCC v4.6 fails for this test.
 611     //We will enable it when we have a fix for it.
 612     TEST(OCRepresentationSubscript, DISABLED_Boolean)
 613     {
 614         static const std::string AttrName = "BooleanTest";
 615         OCRepresentation rep;
 616         bool repsource = true;
 617         rep[AttrName] = repsource;
 618         bool repout = rep[AttrName];
 619         bool repout2;
 620         repout2 = rep[AttrName];
 621
 622         EXPECT_EQ(repsource, repout);
 623         EXPECT_EQ(repsource, repout2);
 624
 625         repsource = false;
 626         rep[AttrName] = repsource;
 627         repout = rep[AttrName];
 628
 629         EXPECT_EQ(repsource, repout);
 630
 631         int badout;
 632         EXPECT_FALSE(rep.getValue<int>(AttrName, badout));
 633         string badoutstr;
 634         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 635         (void)badout;
 636         (void)badoutstr;
 637     }
 638
 639     TEST(OCRepresentationSubscript, String)
 640     {
 641         static const std::string AttrName = "StringTest";
 642         OCRepresentation rep;
 643         string repsource = "This is a string!";
 644         rep[AttrName] = repsource;
 645         string repout = rep[AttrName];
 646         string repout2;
 647         repout2 = rep[AttrName];
 648
 649         EXPECT_EQ(repsource, repout);
 650         EXPECT_EQ(repsource, repout2);
 651
 652         double badout;
 653         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 654         (void)badout;
 655     }
 656
 657     TEST(OCRepresentationSubscript, SubRepresentation)
 658     {
 659         static const std::string AttrName = "SubRepresentationTest";
 660         OCRepresentation rep;
 661         OCRepresentation repsource;
 662         repsource.setUri("This is a uri");
 663
 664         rep[AttrName] = repsource;
 665         OCRepresentation repout = rep[AttrName];
 666         OCRepresentation repout2;
 667         repout2 = rep[AttrName];
 668
 669         //OCRepresentation doesn't overload equality, so this just compares
 670         //the value we set to ensure we got the same one out;
 671         EXPECT_EQ(repsource.getUri(), repout.getUri());
 672         EXPECT_EQ(repsource.getUri(), repout2.getUri());
 673
 674         double badout;
 675         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 676         string badoutstr;
 677         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 678         (void)badout;
 679         (void)badoutstr;
 680     }
 681
 682     TEST(OCRepresentationSubscript, IntegerVector)
 683     {
 684         static const std::string AttrName = "VectorTest";
 685         OCRepresentation rep;
 686         vector<int> repsource {1,2,3,4};
 687         rep[AttrName] = repsource;
 688         vector<int> repout = rep[AttrName];
 689         vector<int> repout2;
 690         repout2 = rep[AttrName];
 691
 692         EXPECT_EQ(repsource, repout);
 693         EXPECT_EQ(repsource, repout2);
 694
 695         double badout;
 696         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 697         string badoutstr;
 698         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 699         (void)badout;
 700         (void)badoutstr;
 701     }
 702
 703     TEST(OCRepresentationSubscript, IntegerVectorVector)
 704     {
 705         static const std::string AttrName = "VectorTest";
 706         OCRepresentation rep;
 707         vector<vector<int>> repsource {{1,2,3,4},{5,6,7,8}};
 708         rep[AttrName] = repsource;
 709         vector<vector<int>> repout = rep[AttrName];
 710         vector<vector<int>> repout2;
 711         repout2 = rep[AttrName];
 712
 713         EXPECT_EQ(repsource, repout);
 714         EXPECT_EQ(repsource, repout2);
 715
 716         double badout;
 717         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 718         string badoutstr;
 719         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 720         (void)badout;
 721         (void)badoutstr;
 722     }
 723
 724     TEST(OCRepresentationSubscript, IntegerVectorVectorVector)
 725     {
 726         static const std::string AttrName = "VectorTest";
 727         OCRepresentation rep;
 728         vector<vector<vector<int>>> repsource {{{1,2,3,4},{5,6,7,8}},{{9,10,11},{21,13}}};
 729         rep[AttrName] = repsource;
 730         vector<vector<vector<int>>> repout = rep[AttrName];
 731         vector<vector<vector<int>>> repout2;
 732         repout2 = rep[AttrName];
 733
 734         EXPECT_EQ(repsource, repout);
 735         EXPECT_EQ(repsource, repout2);
 736
 737         double badout;
 738         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 739         string badoutstr;
 740         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 741         (void)badout;
 742         (void)badoutstr;
 743     }
 744
 745     TEST(OCRepresentationSubscript, DoubleVector)
 746     {
 747         static const std::string AttrName = "VectorTest";
 748         OCRepresentation rep;
 749         vector<double> repsource {1.1,2.2,3.2,4.2};
 750         rep[AttrName] = repsource;
 751         vector<double> repout = rep[AttrName];
 752         vector<double> repout2;
 753         repout2 = rep[AttrName];
 754
 755         EXPECT_EQ(repsource, repout);
 756         EXPECT_EQ(repsource, repout2);
 757
 758         double badout;
 759         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 760         string badoutstr;
 761         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 762         (void)badout;
 763         (void)badoutstr;
 764     }
 765
 766     TEST(OCRepresentationSubscript, DoubleVectorVector)
 767     {
 768         static const std::string AttrName = "VectorTest";
 769         OCRepresentation rep;
 770         vector<vector<double>> repsource {{1.1,2.2,3.2,4.3},{5.5,6.6,7.8,.8}};
 771         rep[AttrName] = repsource;
 772         vector<vector<double>> repout = rep[AttrName];
 773         vector<vector<double>> repout2;
 774         repout2 = rep[AttrName];
 775
 776         EXPECT_EQ(repsource, repout);
 777         EXPECT_EQ(repsource, repout2);
 778
 779         double badout;
 780         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 781         string badoutstr;
 782         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 783         (void)badout;
 784         (void)badoutstr;
 785     }
 786
 787     TEST(OCRepresentationSubscript, DoubleVectorVectorVector)
 788     {
 789         static const std::string AttrName = "VectorTest";
 790         OCRepresentation rep;
 791         vector<vector<vector<double>>> repsource {{{1.1,2.5,3.5,4.4},{.5,.6,7.8,8.9}},
 792             {{9.8,10.8,11.8},{2.1,1.3}}};
 793         rep[AttrName] = repsource;
 794         vector<vector<vector<double>>> repout = rep[AttrName];
 795         vector<vector<vector<double>>> repout2;
 796         repout2 = rep[AttrName];
 797
 798         EXPECT_EQ(repsource, repout);
 799         EXPECT_EQ(repsource, repout2);
 800
 801         double badout;
 802         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 803         string badoutstr;
 804         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 805         (void)badout;
 806         (void)badoutstr;
 807     }
 808
 809     TEST(OCRepresentationSubscript, BooleanVector)
 810     {
 811         static const std::string AttrName = "VectorTest";
 812         OCRepresentation rep;
 813         vector<bool> repsource {false, false, true};
 814         rep[AttrName] = repsource;
 815         vector<bool> repout = rep[AttrName];
 816         vector<bool> repout2;
 817         repout2 = rep[AttrName];
 818
 819         EXPECT_EQ(repsource, repout);
 820         EXPECT_EQ(repsource, repout2);
 821
 822         double badout;
 823         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 824         string badoutstr;
 825         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 826         (void)badout;
 827         (void)badoutstr;
 828     }
 829
 830     TEST(OCRepresentationSubscript, BooleanVectorVector)
 831     {
 832         static const std::string AttrName = "VectorTest";
 833         OCRepresentation rep;
 834         vector<vector<bool>> repsource {{true, true},{false, true}};
 835         rep[AttrName] = repsource;
 836         vector<vector<bool>> repout = rep[AttrName];
 837         vector<vector<bool>> repout2;
 838         repout2 = rep[AttrName];
 839
 840         EXPECT_EQ(repsource, repout);
 841         EXPECT_EQ(repsource, repout2);
 842
 843         double badout;
 844         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 845         string badoutstr;
 846         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 847         (void)badout;
 848         (void)badoutstr;
 849     }
 850
 851     TEST(OCRepresentationSubscript, BooleanVectorVectorVector)
 852     {
 853         static const std::string AttrName = "VectorTest";
 854         OCRepresentation rep;
 855         vector<vector<vector<bool>>> repsource {{{true, true, false},{true}},
 856             {{true, false, false},{false, true, true}}};
 857         rep[AttrName] = repsource;
 858         vector<vector<vector<bool>>> repout = rep[AttrName];
 859         vector<vector<vector<bool>>> repout2;
 860         repout2 = rep[AttrName];
 861
 862         EXPECT_EQ(repsource, repout);
 863         EXPECT_EQ(repsource, repout2);
 864
 865         double badout;
 866         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 867         string badoutstr;
 868         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 869         (void)badout;
 870         (void)badoutstr;
 871     }
 872
 873     TEST(OCRepresentationSubscript, StringVector)
 874     {
 875         static const std::string AttrName = "VectorTest";
 876         OCRepresentation rep;
 877         vector<string> repsource {"str1", "str2"};
 878         rep[AttrName] = repsource;
 879         vector<string> repout = rep[AttrName];
 880         vector<string> repout2;
 881         repout2 = rep[AttrName];
 882
 883         EXPECT_EQ(repsource, repout);
 884         EXPECT_EQ(repsource, repout2);
 885
 886         double badout;
 887         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 888         string badoutstr;
 889         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 890         (void)badout;
 891         (void)badoutstr;
 892     }
 893
 894     TEST(OCRepresentationSubscript, StringVectorVector)
 895     {
 896         static const std::string AttrName = "VectorTest";
 897         OCRepresentation rep;
 898         vector<vector<string>> repsource {{"str1", "str2"},{"str3", "str4"}};
 899         rep[AttrName] = repsource;
 900         vector<vector<string>> repout = rep[AttrName];
 901         vector<vector<string>> repout2;
 902         repout2 = rep[AttrName];
 903
 904         EXPECT_EQ(repsource, repout);
 905         EXPECT_EQ(repsource, repout2);
 906
 907         double badout;
 908         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 909         string badoutstr;
 910         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 911         (void)badout;
 912         (void)badoutstr;
 913     }
 914
 915     TEST(OCRepresentationSubscript, StringVectorVectorVector)
 916     {
 917         static const std::string AttrName = "VectorTest";
 918         OCRepresentation rep;
 919         vector<vector<vector<string>>> repsource {{{"str1", "str2"},{"str3", "str4"}},
 920             {{"str5"},{"str6"}}};
 921         rep[AttrName] = repsource;
 922         vector<vector<vector<string>>> repout = rep[AttrName];
 923         vector<vector<vector<string>>> repout2;
 924         repout2 = rep[AttrName];
 925
 926         EXPECT_EQ(repsource, repout);
 927         EXPECT_EQ(repsource, repout2);
 928
 929         double badout;
 930         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 931         string badoutstr;
 932         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 933         (void)badout;
 934         (void)badoutstr;
 935     }
 936
 937     TEST(OCRepresentationSubscript, SubRepresentationVector)
 938     {
 939         static const std::string AttrName = "VectorTest";
 940         OCRepresentation rep;
 941         OCRepresentation inner1, inner2;
 942         inner1.setUri("inner1");
 943         inner2.setUri("inner2");
 944         vector<OCRepresentation> repsource {inner1, inner2};
 945         rep[AttrName] = repsource;
 946         vector<OCRepresentation> repout = rep[AttrName];
 947         vector<OCRepresentation> repout2;
 948         repout2 = rep[AttrName];
 949
 950         EXPECT_EQ(2u, repout.size());
 951         EXPECT_EQ(inner1.getUri(), repout[0].getUri());
 952         EXPECT_EQ(inner2.getUri(), repout[1].getUri());
 953         EXPECT_EQ(2u, repout2.size());
 954         EXPECT_EQ(inner1.getUri(), repout2[0].getUri());
 955         EXPECT_EQ(inner2.getUri(), repout2[1].getUri());
 956
 957         double badout;
 958         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 959         string badoutstr;
 960         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 961         (void)badout;
 962         (void)badoutstr;
 963     }
 964
 965     TEST(OCRepresentationSubscript, SubRepresentationVectorVector)
 966     {
 967         static const std::string AttrName = "VectorTest";
 968         OCRepresentation rep;
 969         OCRepresentation inner1, inner2, inner3, inner4;
 970         inner1.setUri("inner1");
 971         inner2.setUri("inner2");
 972         inner3.setUri("inner3");
 973         inner4.setUri("inner4");
 974
 975         vector<vector<OCRepresentation>> repsource {{inner1, inner2}, {inner3, inner4}};
 976         rep[AttrName] = repsource;
 977         vector<vector<OCRepresentation>> repout = rep[AttrName];
 978         vector<vector<OCRepresentation>> repout2;
 979         repout2 = rep[AttrName];
 980
 981         EXPECT_EQ(2u, repout.size());
 982         EXPECT_EQ(2u, repout[0].size());
 983         EXPECT_EQ(inner1.getUri(), repout[0][0].getUri());
 984         EXPECT_EQ(inner2.getUri(), repout[0][1].getUri());
 985         EXPECT_EQ(2u, repout.size());
 986         EXPECT_EQ(2u, repout[1].size());
 987         EXPECT_EQ(inner3.getUri(), repout[1][0].getUri());
 988         EXPECT_EQ(inner4.getUri(), repout[1][1].getUri());
 989
 990         EXPECT_EQ(2u, repout2.size());
 991         EXPECT_EQ(2u, repout2[0].size());
 992         EXPECT_EQ(inner1.getUri(), repout2[0][0].getUri());
 993         EXPECT_EQ(inner2.getUri(), repout2[0][1].getUri());
 994         EXPECT_EQ(2u, repout2.size());
 995         EXPECT_EQ(2u, repout2[1].size());
 996         EXPECT_EQ(inner3.getUri(), repout2[1][0].getUri());
 997         EXPECT_EQ(inner4.getUri(), repout2[1][1].getUri());
 998
 999         double badout;
1000         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
1001         string badoutstr;
1002         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
1003         (void)badout;
1004         (void)badoutstr;
1005     }
1006
1007     TEST(OCRepresentationSubscript, SubRepresentationVectorVectorVector)
1008     {
1009         static const std::string AttrName = "VectorTest";
1010         OCRepresentation rep;
1011         OCRepresentation inner1, inner2, inner3, inner4, inner5, inner6, inner7, inner8;
1012         inner1.setUri("inner1");
1013         inner2.setUri("inner2");
1014         inner3.setUri("inner3");
1015         inner4.setUri("inner4");
1016         inner5.setUri("inner5");
1017         inner6.setUri("inner6");
1018         inner7.setUri("inner7");
1019         inner8.setUri("inner8");
1020
1021         vector<vector<vector<OCRepresentation>>> repsource
1022             {{{inner1, inner2},{inner3, inner4}},{{inner5, inner6},{inner7,inner8}}};
1023
1024         rep[AttrName] = repsource;
1025         vector<vector<vector<OCRepresentation>>> repout = rep[AttrName];
1026         vector<vector<vector<OCRepresentation>>> repout2;
1027         repout2 = rep[AttrName];
1028
1029         EXPECT_EQ(2u, repout.size());
1030         EXPECT_EQ(2u, repout[0].size());
1031         EXPECT_EQ(2u, repout[0][0].size());
1032         EXPECT_EQ(inner1.getUri(), repout[0][0][0].getUri());
1033         EXPECT_EQ(inner2.getUri(), repout[0][0][1].getUri());
1034         EXPECT_EQ(2u, repout[0][1].size());
1035         EXPECT_EQ(inner3.getUri(), repout[0][1][0].getUri());
1036         EXPECT_EQ(inner4.getUri(), repout[0][1][1].getUri());
1037         EXPECT_EQ(2u, repout[1].size());
1038         EXPECT_EQ(2u, repout[1][0].size());
1039         EXPECT_EQ(inner5.getUri(), repout[1][0][0].getUri());
1040         EXPECT_EQ(inner6.getUri(), repout[1][0][1].getUri());
1041         EXPECT_EQ(2u, repout[1][1].size());
1042         EXPECT_EQ(inner7.getUri(), repout[1][1][0].getUri());
1043         EXPECT_EQ(inner8.getUri(), repout[1][1][1].getUri());
1044
1045         EXPECT_EQ(2u, repout2.size());
1046         EXPECT_EQ(2u, repout2[0].size());
1047         EXPECT_EQ(2u, repout2[0][0].size());
1048         EXPECT_EQ(inner1.getUri(), repout2[0][0][0].getUri());
1049         EXPECT_EQ(inner2.getUri(), repout2[0][0][1].getUri());
1050         EXPECT_EQ(2u, repout[0][1].size());
1051         EXPECT_EQ(inner3.getUri(), repout2[0][1][0].getUri());
1052         EXPECT_EQ(inner4.getUri(), repout2[0][1][1].getUri());
1053         EXPECT_EQ(2u, repout[1].size());
1054         EXPECT_EQ(2u, repout[1][0].size());
1055         EXPECT_EQ(inner5.getUri(), repout2[1][0][0].getUri());
1056         EXPECT_EQ(inner6.getUri(), repout2[1][0][1].getUri());
1057         EXPECT_EQ(2u, repout[1][1].size());
1058         EXPECT_EQ(inner7.getUri(), repout2[1][1][0].getUri());
1059         EXPECT_EQ(inner8.getUri(), repout2[1][1][1].getUri());
1060
1061         double badout;
1062         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
1063         string badoutstr;
1064         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
1065         (void)badout;
1066         (void)badoutstr;
1067     }
1068
1069     TEST(OCRepresentationIterator, constiterator)
1070     {
1071         OCRepresentation rep;
1072
1073         EXPECT_TRUE(rep.empty());
1074         rep.setValue("int", 8);
1075         EXPECT_FALSE(rep.empty());
1076         rep.setValue("double", 8.8);
1077         rep.setValue("bool", true);
1078         rep.setValue("string", std::string("this is a string"));
1079
1080         EXPECT_EQ(4u, rep.size());
1081         EXPECT_FALSE(rep.empty());
1082
1083         OCRepresentation::const_iterator itr = rep.cbegin();
1084         OCRepresentation::const_iterator endItr = rep.cend();
1085         for(;itr!=endItr;++itr);
1086
1087         const OCRepresentation& rep2(rep);
1088         OCRepresentation::const_iterator itr2 = rep2.begin();
1089         OCRepresentation::const_iterator endItr2 = rep2.end();
1090         for(;itr2!=endItr2;++itr2);
1091
1092     }
1093
1094     TEST(OCRepresentationIterator, constautoiterator)
1095     {
1096         OCRepresentation rep;
1097
1098         EXPECT_TRUE(rep.empty());
1099         rep.setValue("int", 8);
1100         EXPECT_FALSE(rep.empty());
1101         rep.setValue("double", 8.8);
1102         rep.setValue("bool", true);
1103         rep.setValue("string", std::string("this is a string"));
1104
1105         EXPECT_EQ(4u, rep.size());
1106         EXPECT_FALSE(rep.empty());
1107
1108         for(const auto& a : rep)
1109         {
1110             (void)a;
1111         }
1112
1113         const OCRepresentation& rep2(rep);
1114         for(const auto& a : rep2)
1115         {
1116             (void)a;
1117         }
1118     }
1119     TEST(OCRepresentationIterator, autoiterator)
1120     {
1121         OCRepresentation rep;
1122
1123         EXPECT_TRUE(rep.empty());
1124         rep.setValue("int", 8);
1125         EXPECT_FALSE(rep.empty());
1126         rep.setValue("double", 8.8);
1127         rep.setValue("bool", true);
1128         rep.setValue("string", std::string("this is a string"));
1129
1130         EXPECT_EQ(4u, rep.size());
1131         EXPECT_FALSE(rep.empty());
1132
1133         for(auto& cur : rep)
1134         {
1135             if(cur.attrname() == "int")
1136             {
1137                 EXPECT_EQ("int", cur.attrname());
1138                 EXPECT_EQ(AttributeType::Integer, cur.type());
1139                 EXPECT_EQ(AttributeType::Integer, cur.base_type());
1140                 EXPECT_EQ(0u, cur.depth());
1141                 int curInt = cur.getValue<int>();
1142                 EXPECT_EQ(8, curInt);
1143             }
1144             if(cur.attrname() == "double")
1145             {
1146                 EXPECT_EQ("double", cur.attrname());
1147                 EXPECT_EQ(AttributeType::Double, cur.type());
1148                 EXPECT_EQ(AttributeType::Double, cur.base_type());
1149                 EXPECT_EQ(0u, cur.depth());
1150                 double curDouble = cur.getValue<double>();
1151                 EXPECT_EQ(8.8, curDouble);
1152             }
1153             if(cur.attrname() == "bool")
1154             {
1155                 EXPECT_EQ("bool", cur.attrname());
1156                 EXPECT_EQ(AttributeType::Boolean, cur.type());
1157                 EXPECT_EQ(AttributeType::Boolean, cur.base_type());
1158                 EXPECT_EQ(0u, cur.depth());
1159                 bool curBool = cur.getValue<bool>();
1160                 EXPECT_EQ(true, curBool);
1161             }
1162             if(cur.attrname() == "string")
1163             {
1164                 EXPECT_EQ("string", cur.attrname());
1165                 EXPECT_EQ(AttributeType::String, cur.type());
1166                 EXPECT_EQ(AttributeType::String, cur.base_type());
1167                 EXPECT_EQ(0u, cur.depth());
1168                 string curStr = cur.getValue<string>();
1169                 EXPECT_EQ("this is a string", curStr);
1170             }
1171         }
1172     }
1173     // Iterator usage
1174     TEST(OCRepresentationIterator, iterator)
1175     {
1176         OCRepresentation rep;
1177         OCRepresentation sub1;
1178         sub1.setUri("sub rep1 URI");
1179         OCRepresentation sub2;
1180         sub2.setUri("sub rep2 URI");
1181         OCRepresentation sub3;
1182         sub3.setUri("sub rep3 URI");
1183         OCRepresentation sub4;
1184         sub4.setUri("sub rep4 URI");
1185         OCRepresentation sub5;
1186         sub5.setUri("sub rep5 URI");
1187         OCRepresentation sub6;
1188         sub6.setUri("sub rep6 URI");
1189
1190
1191         EXPECT_TRUE(rep.empty());
1192         rep.setValue("int", 8);
1193         EXPECT_FALSE(rep.empty());
1194         rep.setValue("double", 8.8);
1195         rep.setValue("bool", true);
1196         rep.setValue("string", std::string("this is a string"));
1197         rep.setValue("rep", sub1);
1198
1199         vector<int> intv {1,2,3,4};
1200         rep.setValue("intv", intv);
1201         vector<double> doublev {1.1,2.2,3.3,4.4};
1202         rep.setValue("doublev", doublev);
1203         vector<bool> boolv{false, false, true};
1204         rep.setValue("boolv", boolv);
1205         vector<string> strv{"abc", "def", "ghi"};
1206         rep.setValue("strv", strv);
1207         vector<OCRepresentation> repv { sub1, sub2 };
1208         rep.setValue("repv", repv);
1209
1210         vector<vector<int>> intvv{{1,2,3},{4,5,6}};
1211         rep.setValue("intvv", intvv);
1212         vector<vector<vector<int>>> intvvv{{{1,2},{3,4}},{{5,6},{8,7}}};
1213         rep.setValue("intvvv", intvvv);
1214
1215         vector<vector<double>> doublevv{{1.1,2.1,3},{4.4,5.4,6.4}};
1216         rep.setValue("doublevv", doublevv);
1217         vector<vector<vector<double>>> doublevvv{{{1.1,2.1},{3.1,4.1}},{{5.1,6.1},{8.1,7.1}}};
1218         rep.setValue("doublevvv", doublevvv);
1219
1220         vector<vector<bool>> boolvv{{false, true},{true, false}};
1221         rep.setValue("boolvv", boolvv);
1222         vector<vector<vector<bool>>> boolvvv{{{true, false},{true}},{{false},{true}}};
1223         rep.setValue("boolvvv", boolvvv);
1224
1225         vector<vector<string>> strvv{{"abc", "def"},{"wer", "qwer"}};
1226         rep.setValue("strvv", strvv);
1227         vector<vector<vector<string>>> strvvv{{{"wqr", "xcv"},{"234"}},{{"we"},{"wert"}}};
1228         rep.setValue("strvvv", strvvv);
1229
1230         vector<vector<OCRepresentation>> repvv{{sub1, sub2},{sub3, sub4}};
1231         rep.setValue("repvv", repvv);
1232         vector<vector<vector<OCRepresentation>>> repvvv{{{sub5},{sub6}},{{sub3},{sub2}}};
1233         rep.setValue("repvvv", repvvv);
1234
1235         EXPECT_EQ(20u, rep.size());
1236         EXPECT_FALSE(rep.empty());
1237
1238         OCRepresentation::iterator itr= rep.begin();
1239         OCRepresentation::iterator endItr = rep.end();
1240
1241         for(;itr!=endItr;++itr)
1242         {
1243             if(itr->attrname() == "int")
1244             {
1245                 EXPECT_EQ("int", itr->attrname());
1246                 EXPECT_EQ(AttributeType::Integer, itr->type());
1247                 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1248                 EXPECT_EQ(0u, itr->depth());
1249                 int curInt = (*itr).getValue<int>();
1250                 EXPECT_EQ(8, curInt);
1251             }
1252             else if (itr->attrname() == "double")
1253             {
1254                 EXPECT_EQ("double", itr->attrname());
1255                 EXPECT_EQ(AttributeType::Double, itr->type());
1256                 EXPECT_EQ(AttributeType::Double, itr->base_type());
1257                 EXPECT_EQ(0u, itr->depth());
1258                 double curDouble = (*itr).getValue<double>();
1259                 EXPECT_EQ(8.8, curDouble);
1260             }
1261             else if (itr->attrname() == "bool")
1262             {
1263                 EXPECT_EQ("bool", itr->attrname());
1264                 EXPECT_EQ(AttributeType::Boolean, itr->type());
1265                 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1266                 EXPECT_EQ(0u, itr->depth());
1267                 bool curBool = (*itr).getValue<bool>();
1268                 EXPECT_EQ(true, curBool);
1269             }
1270             else if (itr->attrname() == "string")
1271             {
1272                 EXPECT_EQ("string", itr->attrname());
1273                 EXPECT_EQ(AttributeType::String, itr->type());
1274                 EXPECT_EQ(AttributeType::String, itr->base_type());
1275                 EXPECT_EQ(0u, itr->depth());
1276                 string curString = (*itr).getValue<string>();
1277                 EXPECT_EQ("this is a string", curString);
1278             }
1279             else if (itr->attrname() == "rep")
1280             {
1281                 EXPECT_EQ("rep", itr->attrname());
1282                 EXPECT_EQ(AttributeType::OCRepresentation, itr->type());
1283                 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1284                 EXPECT_EQ(0u, itr->depth());
1285                 OCRepresentation curRep = (*itr).getValue<OCRepresentation>();
1286                 EXPECT_EQ(sub1.getUri(), curRep.getUri());
1287             }
1288             else if (itr->attrname() == "intv")
1289             {
1290                 EXPECT_EQ("intv", itr->attrname());
1291                 EXPECT_EQ(AttributeType::Vector, itr->type());
1292                 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1293                 EXPECT_EQ(1u, itr->depth());
1294                 vector<int> curv = (*itr).getValue<vector<int>>();
1295                 EXPECT_EQ(intv, curv);
1296             }
1297             else if (itr->attrname() == "doublev")
1298             {
1299                 EXPECT_EQ("doublev", itr->attrname());
1300                 EXPECT_EQ(AttributeType::Vector, itr->type());
1301                 EXPECT_EQ(AttributeType::Double, itr->base_type());
1302                 EXPECT_EQ(1u, itr->depth());
1303                 vector<double> curv = (*itr).getValue<vector<double>>();
1304                 EXPECT_EQ(doublev, curv);
1305             }
1306             else if (itr->attrname() == "boolv")
1307             {
1308                 EXPECT_EQ("boolv", itr->attrname());
1309                 EXPECT_EQ(AttributeType::Vector, itr->type());
1310                 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1311                 EXPECT_EQ(1u, itr->depth());
1312                 vector<bool> curv = (*itr).getValue<vector<bool>>();
1313                 EXPECT_EQ(boolv, curv);
1314             }
1315             else if (itr->attrname() == "strv")
1316             {
1317                 EXPECT_EQ("strv", itr->attrname());
1318                 EXPECT_EQ(AttributeType::Vector, itr->type());
1319                 EXPECT_EQ(AttributeType::String, itr->base_type());
1320                 EXPECT_EQ(1u, itr->depth());
1321                 vector<string> curv = (*itr).getValue<vector<string>>();
1322                 EXPECT_EQ(strv, curv);
1323             }
1324             else if (itr->attrname() == "repv")
1325             {
1326                 EXPECT_EQ("repv", itr->attrname());
1327                 EXPECT_EQ(AttributeType::Vector, itr->type());
1328                 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1329                 EXPECT_EQ(1u, itr->depth());
1330                 vector<OCRepresentation> curv = (*itr).getValue<vector<OCRepresentation>>();
1331                 EXPECT_EQ(2u, repv.size());
1332                 EXPECT_EQ(sub1.getUri(), repv[0].getUri());
1333                 EXPECT_EQ(sub2.getUri(), repv[1].getUri());
1334             }
1335             else if (itr->attrname() == "intvv")
1336             {
1337                 EXPECT_EQ("intvv", itr->attrname());
1338                 EXPECT_EQ(AttributeType::Vector, itr->type());
1339                 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1340                 EXPECT_EQ(2u, itr->depth());
1341                 vector<vector<int>> curv = (*itr).getValue<vector<vector<int>>>();
1342                 EXPECT_EQ(intvv, curv);
1343             }
1344             else if (itr->attrname() == "intvvv")
1345             {
1346                 EXPECT_EQ("intvvv", itr->attrname());
1347                 EXPECT_EQ(AttributeType::Vector, itr->type());
1348                 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1349                 EXPECT_EQ(3u, itr->depth());
1350                 vector<vector<vector<int>>> curv = (*itr).getValue<vector<vector<vector<int>>>>();
1351                 EXPECT_EQ(intvvv, curv);
1352             }
1353             else if (itr->attrname() == "doublevv")
1354             {
1355                 EXPECT_EQ("doublevv", itr->attrname());
1356                 EXPECT_EQ(AttributeType::Vector, itr->type());
1357                 EXPECT_EQ(AttributeType::Double, itr->base_type());
1358                 EXPECT_EQ(2u, itr->depth());
1359                 vector<vector<double>> curv = (*itr).getValue<vector<vector<double>>>();
1360                 EXPECT_EQ(doublevv, curv);
1361             }
1362             else if (itr->attrname() == "doublevvv")
1363             {
1364                 EXPECT_EQ("doublevvv", itr->attrname());
1365                 EXPECT_EQ(AttributeType::Vector, itr->type());
1366                 EXPECT_EQ(AttributeType::Double, itr->base_type());
1367                 EXPECT_EQ(3u, itr->depth());
1368                 vector<vector<vector<double>>> curv =
1369                     (*itr).getValue<vector<vector<vector<double>>>>();
1370                 EXPECT_EQ(doublevvv, curv);
1371             }
1372             else if (itr->attrname() == "boolvv")
1373             {
1374                 EXPECT_EQ("boolvv", itr->attrname());
1375                 EXPECT_EQ(AttributeType::Vector, itr->type());
1376                 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1377                 EXPECT_EQ(2u, itr->depth());
1378                 vector<vector<bool>> curv = (*itr).getValue<vector<vector<bool>>>();
1379                 EXPECT_EQ(boolvv, curv);
1380             }
1381             else if (itr->attrname() == "boolvvv")
1382             {
1383                 EXPECT_EQ("boolvvv", itr->attrname());
1384                 EXPECT_EQ(AttributeType::Vector, itr->type());
1385                 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1386                 EXPECT_EQ(3u, itr->depth());
1387                 vector<vector<vector<bool>>> curv = (*itr).getValue<vector<vector<vector<bool>>>>();
1388                 EXPECT_EQ(boolvvv, curv);
1389             }
1390             else if (itr->attrname() == "strvv")
1391             {
1392                 EXPECT_EQ("strvv", itr->attrname());
1393                 EXPECT_EQ(AttributeType::Vector, itr->type());
1394                 EXPECT_EQ(AttributeType::String, itr->base_type());
1395                 EXPECT_EQ(2u, itr->depth());
1396                 vector<vector<string>> curv = (*itr).getValue<vector<vector<string>>>();
1397                 EXPECT_EQ(strvv, curv);
1398             }
1399             else if (itr->attrname() == "strvvv")
1400             {
1401                 EXPECT_EQ("strvvv", itr->attrname());
1402                 EXPECT_EQ(AttributeType::Vector, itr->type());
1403                 EXPECT_EQ(AttributeType::String, itr->base_type());
1404                 EXPECT_EQ(3u, itr->depth());
1405                 vector<vector<vector<string>>> curv =
1406                     (*itr).getValue<vector<vector<vector<string>>>>();
1407                 EXPECT_EQ(strvvv, curv);
1408             }
1409             else if (itr->attrname() == "repvv")
1410             {
1411                 EXPECT_EQ("repvv", itr->attrname());
1412                 EXPECT_EQ(AttributeType::Vector, itr->type());
1413                 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1414                 EXPECT_EQ(2u, itr->depth());
1415                 vector<vector<OCRepresentation>> curv =
1416                     (*itr).getValue<vector<vector<OCRepresentation>>>();
1417                 EXPECT_EQ(2u, curv.size());
1418                 EXPECT_EQ(2u, curv[0].size());
1419                 EXPECT_EQ(sub1.getUri(), curv[0][0].getUri());
1420                 EXPECT_EQ(sub2.getUri(), curv[0][1].getUri());
1421                 EXPECT_EQ(2u, curv[1].size());
1422                 EXPECT_EQ(sub3.getUri(), curv[1][0].getUri());
1423                 EXPECT_EQ(sub4.getUri(), curv[1][1].getUri());
1424             }
1425             else if (itr->attrname() == "repvvv")
1426             {
1427                 EXPECT_EQ("repvvv", itr->attrname());
1428                 EXPECT_EQ(AttributeType::Vector, itr->type());
1429                 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1430                 EXPECT_EQ(3u, itr->depth());
1431                 vector<vector<vector<OCRepresentation>>> curv =
1432                     (*itr).getValue<vector<vector<vector<OCRepresentation>>>>();
1433                 EXPECT_EQ(2u, curv.size());
1434                 EXPECT_EQ(2u, curv[0].size());
1435                 EXPECT_EQ(1u, curv[0][0].size());
1436                 EXPECT_EQ(sub5.getUri(), curv[0][0][0].getUri());
1437                 EXPECT_EQ(1u, curv[0][1].size());
1438                 EXPECT_EQ(sub6.getUri(), curv[0][1][0].getUri());
1439                 EXPECT_EQ(1u, curv[1][0].size());
1440                 EXPECT_EQ(sub3.getUri(), curv[1][0][0].getUri());
1441                 EXPECT_EQ(1u, curv[1][1].size());
1442                 EXPECT_EQ(sub2.getUri(), curv[1][1][0].getUri());
1443             }
1444             else
1445             {
1446                 EXPECT_TRUE(false) << itr->attrname();
1447             }
1448         }
1449     }
1450 }