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         std::nullptr_t repout = rep[AttrName];
 551         std::nullptr_t repout2;
 552         repout2 = rep[AttrName];
 553
 554         EXPECT_EQ(nullptr, repout);
 555         EXPECT_EQ(nullptr, repout2);
 556
 557         double badout;
 558         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 559         string badoutstr;
 560         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 561         (void)badout;
 562         (void)badoutstr;
 563     }
 564
 565     TEST(OCRepresentationSubscript, Integer)
 566     {
 567         static const std::string AttrName = "IntTest";
 568         OCRepresentation rep;
 569         int repsource = -5;
 570         rep[AttrName] = repsource;
 571         int repout = rep[AttrName];
 572         int repout2;
 573         repout2 = rep[AttrName];
 574
 575         EXPECT_EQ(repsource, repout);
 576         EXPECT_EQ(repsource, repout2);
 577
 578         double badout;
 579         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 580         string badoutstr;
 581         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 582         (void)badout;
 583         (void)badoutstr;
 584     }
 585
 586     TEST(OCRepresentationSubscript, Double)
 587     {
 588         static const std::string AttrName = "DoubleTest";
 589         OCRepresentation rep;
 590         double repsource = -5.33;
 591         rep[AttrName] = repsource;
 592         double repout = rep[AttrName];
 593         double repout2;
 594         repout2 = rep[AttrName];
 595
 596         EXPECT_EQ(repsource, repout);
 597         EXPECT_EQ(repsource, repout2);
 598
 599         int badout;
 600         EXPECT_FALSE(rep.getValue<int>(AttrName, badout));
 601         string badoutstr;
 602         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 603         (void)badout;
 604         (void)badoutstr;
 605     }
 606
 607     //Disabled this test due to older GCC v4.6 fails for this test.
 608     //We will enable it when we have a fix for it.
 609     TEST(OCRepresentationSubscript, DISABLED_Boolean)
 610     {
 611         static const std::string AttrName = "BooleanTest";
 612         OCRepresentation rep;
 613         bool repsource = true;
 614         rep[AttrName] = repsource;
 615         bool repout = rep[AttrName];
 616         bool repout2;
 617         repout2 = rep[AttrName];
 618
 619         EXPECT_EQ(repsource, repout);
 620         EXPECT_EQ(repsource, repout2);
 621
 622         repsource = false;
 623         rep[AttrName] = repsource;
 624         repout = rep[AttrName];
 625
 626         EXPECT_EQ(repsource, repout);
 627
 628         int badout;
 629         EXPECT_FALSE(rep.getValue<int>(AttrName, badout));
 630         string badoutstr;
 631         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 632         (void)badout;
 633         (void)badoutstr;
 634     }
 635
 636     TEST(OCRepresentationSubscript, String)
 637     {
 638         static const std::string AttrName = "StringTest";
 639         OCRepresentation rep;
 640         string repsource = "This is a string!";
 641         rep[AttrName] = repsource;
 642         string repout = rep[AttrName];
 643         string repout2;
 644         repout2 = rep[AttrName];
 645
 646         EXPECT_EQ(repsource, repout);
 647         EXPECT_EQ(repsource, repout2);
 648
 649         double badout;
 650         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 651         (void)badout;
 652     }
 653
 654     TEST(OCRepresentationSubscript, SubRepresentation)
 655     {
 656         static const std::string AttrName = "SubRepresentationTest";
 657         OCRepresentation rep;
 658         OCRepresentation repsource;
 659         repsource.setUri("This is a uri");
 660
 661         rep[AttrName] = repsource;
 662         OCRepresentation repout = rep[AttrName];
 663         OCRepresentation repout2;
 664         repout2 = rep[AttrName];
 665
 666         //OCRepresentation doesn't overload equality, so this just compares
 667         //the value we set to ensure we got the same one out;
 668         EXPECT_EQ(repsource.getUri(), repout.getUri());
 669         EXPECT_EQ(repsource.getUri(), repout2.getUri());
 670
 671         double badout;
 672         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 673         string badoutstr;
 674         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 675         (void)badout;
 676         (void)badoutstr;
 677     }
 678
 679     TEST(OCRepresentationSubscript, IntegerVector)
 680     {
 681         static const std::string AttrName = "VectorTest";
 682         OCRepresentation rep;
 683         vector<int> repsource {1,2,3,4};
 684         rep[AttrName] = repsource;
 685         vector<int> repout = rep[AttrName];
 686         vector<int> repout2;
 687         repout2 = rep[AttrName];
 688
 689         EXPECT_EQ(repsource, repout);
 690         EXPECT_EQ(repsource, repout2);
 691
 692         double badout;
 693         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 694         string badoutstr;
 695         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 696         (void)badout;
 697         (void)badoutstr;
 698     }
 699
 700     TEST(OCRepresentationSubscript, IntegerVectorVector)
 701     {
 702         static const std::string AttrName = "VectorTest";
 703         OCRepresentation rep;
 704         vector<vector<int>> repsource {{1,2,3,4},{5,6,7,8}};
 705         rep[AttrName] = repsource;
 706         vector<vector<int>> repout = rep[AttrName];
 707         vector<vector<int>> repout2;
 708         repout2 = rep[AttrName];
 709
 710         EXPECT_EQ(repsource, repout);
 711         EXPECT_EQ(repsource, repout2);
 712
 713         double badout;
 714         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 715         string badoutstr;
 716         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 717         (void)badout;
 718         (void)badoutstr;
 719     }
 720
 721     TEST(OCRepresentationSubscript, IntegerVectorVectorVector)
 722     {
 723         static const std::string AttrName = "VectorTest";
 724         OCRepresentation rep;
 725         vector<vector<vector<int>>> repsource {{{1,2,3,4},{5,6,7,8}},{{9,10,11},{21,13}}};
 726         rep[AttrName] = repsource;
 727         vector<vector<vector<int>>> repout = rep[AttrName];
 728         vector<vector<vector<int>>> repout2;
 729         repout2 = rep[AttrName];
 730
 731         EXPECT_EQ(repsource, repout);
 732         EXPECT_EQ(repsource, repout2);
 733
 734         double badout;
 735         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 736         string badoutstr;
 737         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 738         (void)badout;
 739         (void)badoutstr;
 740     }
 741
 742     TEST(OCRepresentationSubscript, DoubleVector)
 743     {
 744         static const std::string AttrName = "VectorTest";
 745         OCRepresentation rep;
 746         vector<double> repsource {1.1,2.2,3.2,4.2};
 747         rep[AttrName] = repsource;
 748         vector<double> repout = rep[AttrName];
 749         vector<double> repout2;
 750         repout2 = rep[AttrName];
 751
 752         EXPECT_EQ(repsource, repout);
 753         EXPECT_EQ(repsource, repout2);
 754
 755         double badout;
 756         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 757         string badoutstr;
 758         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 759         (void)badout;
 760         (void)badoutstr;
 761     }
 762
 763     TEST(OCRepresentationSubscript, DoubleVectorVector)
 764     {
 765         static const std::string AttrName = "VectorTest";
 766         OCRepresentation rep;
 767         vector<vector<double>> repsource {{1.1,2.2,3.2,4.3},{5.5,6.6,7.8,.8}};
 768         rep[AttrName] = repsource;
 769         vector<vector<double>> repout = rep[AttrName];
 770         vector<vector<double>> repout2;
 771         repout2 = rep[AttrName];
 772
 773         EXPECT_EQ(repsource, repout);
 774         EXPECT_EQ(repsource, repout2);
 775
 776         double badout;
 777         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 778         string badoutstr;
 779         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 780         (void)badout;
 781         (void)badoutstr;
 782     }
 783
 784     TEST(OCRepresentationSubscript, DoubleVectorVectorVector)
 785     {
 786         static const std::string AttrName = "VectorTest";
 787         OCRepresentation rep;
 788         vector<vector<vector<double>>> repsource {{{1.1,2.5,3.5,4.4},{.5,.6,7.8,8.9}},
 789             {{9.8,10.8,11.8},{2.1,1.3}}};
 790         rep[AttrName] = repsource;
 791         vector<vector<vector<double>>> repout = rep[AttrName];
 792         vector<vector<vector<double>>> repout2;
 793         repout2 = rep[AttrName];
 794
 795         EXPECT_EQ(repsource, repout);
 796         EXPECT_EQ(repsource, repout2);
 797
 798         double badout;
 799         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 800         string badoutstr;
 801         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 802         (void)badout;
 803         (void)badoutstr;
 804     }
 805
 806     TEST(OCRepresentationSubscript, BooleanVector)
 807     {
 808         static const std::string AttrName = "VectorTest";
 809         OCRepresentation rep;
 810         vector<bool> repsource {false, false, true};
 811         rep[AttrName] = repsource;
 812         vector<bool> repout = rep[AttrName];
 813         vector<bool> repout2;
 814         repout2 = rep[AttrName];
 815
 816         EXPECT_EQ(repsource, repout);
 817         EXPECT_EQ(repsource, repout2);
 818
 819         double badout;
 820         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 821         string badoutstr;
 822         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 823         (void)badout;
 824         (void)badoutstr;
 825     }
 826
 827     TEST(OCRepresentationSubscript, BooleanVectorVector)
 828     {
 829         static const std::string AttrName = "VectorTest";
 830         OCRepresentation rep;
 831         vector<vector<bool>> repsource {{true, true},{false, true}};
 832         rep[AttrName] = repsource;
 833         vector<vector<bool>> repout = rep[AttrName];
 834         vector<vector<bool>> repout2;
 835         repout2 = rep[AttrName];
 836
 837         EXPECT_EQ(repsource, repout);
 838         EXPECT_EQ(repsource, repout2);
 839
 840         double badout;
 841         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 842         string badoutstr;
 843         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 844         (void)badout;
 845         (void)badoutstr;
 846     }
 847
 848     TEST(OCRepresentationSubscript, BooleanVectorVectorVector)
 849     {
 850         static const std::string AttrName = "VectorTest";
 851         OCRepresentation rep;
 852         vector<vector<vector<bool>>> repsource {{{true, true, false},{true}},
 853             {{true, false, false},{false, true, true}}};
 854         rep[AttrName] = repsource;
 855         vector<vector<vector<bool>>> repout = rep[AttrName];
 856         vector<vector<vector<bool>>> repout2;
 857         repout2 = rep[AttrName];
 858
 859         EXPECT_EQ(repsource, repout);
 860         EXPECT_EQ(repsource, repout2);
 861
 862         double badout;
 863         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 864         string badoutstr;
 865         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 866         (void)badout;
 867         (void)badoutstr;
 868     }
 869
 870     TEST(OCRepresentationSubscript, StringVector)
 871     {
 872         static const std::string AttrName = "VectorTest";
 873         OCRepresentation rep;
 874         vector<string> repsource {"str1", "str2"};
 875         rep[AttrName] = repsource;
 876         vector<string> repout = rep[AttrName];
 877         vector<string> repout2;
 878         repout2 = rep[AttrName];
 879
 880         EXPECT_EQ(repsource, repout);
 881         EXPECT_EQ(repsource, repout2);
 882
 883         double badout;
 884         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 885         string badoutstr;
 886         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 887         (void)badout;
 888         (void)badoutstr;
 889     }
 890
 891     TEST(OCRepresentationSubscript, StringVectorVector)
 892     {
 893         static const std::string AttrName = "VectorTest";
 894         OCRepresentation rep;
 895         vector<vector<string>> repsource {{"str1", "str2"},{"str3", "str4"}};
 896         rep[AttrName] = repsource;
 897         vector<vector<string>> repout = rep[AttrName];
 898         vector<vector<string>> repout2;
 899         repout2 = rep[AttrName];
 900
 901         EXPECT_EQ(repsource, repout);
 902         EXPECT_EQ(repsource, repout2);
 903
 904         double badout;
 905         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 906         string badoutstr;
 907         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 908         (void)badout;
 909         (void)badoutstr;
 910     }
 911
 912     TEST(OCRepresentationSubscript, StringVectorVectorVector)
 913     {
 914         static const std::string AttrName = "VectorTest";
 915         OCRepresentation rep;
 916         vector<vector<vector<string>>> repsource {{{"str1", "str2"},{"str3", "str4"}},
 917             {{"str5"},{"str6"}}};
 918         rep[AttrName] = repsource;
 919         vector<vector<vector<string>>> repout = rep[AttrName];
 920         vector<vector<vector<string>>> repout2;
 921         repout2 = rep[AttrName];
 922
 923         EXPECT_EQ(repsource, repout);
 924         EXPECT_EQ(repsource, repout2);
 925
 926         double badout;
 927         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 928         string badoutstr;
 929         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 930         (void)badout;
 931         (void)badoutstr;
 932     }
 933
 934     TEST(OCRepresentationSubscript, SubRepresentationVector)
 935     {
 936         static const std::string AttrName = "VectorTest";
 937         OCRepresentation rep;
 938         OCRepresentation inner1, inner2;
 939         inner1.setUri("inner1");
 940         inner2.setUri("inner2");
 941         vector<OCRepresentation> repsource {inner1, inner2};
 942         rep[AttrName] = repsource;
 943         vector<OCRepresentation> repout = rep[AttrName];
 944         vector<OCRepresentation> repout2;
 945         repout2 = rep[AttrName];
 946
 947         EXPECT_EQ(2u, repout.size());
 948         EXPECT_EQ(inner1.getUri(), repout[0].getUri());
 949         EXPECT_EQ(inner2.getUri(), repout[1].getUri());
 950         EXPECT_EQ(2u, repout2.size());
 951         EXPECT_EQ(inner1.getUri(), repout2[0].getUri());
 952         EXPECT_EQ(inner2.getUri(), repout2[1].getUri());
 953
 954         double badout;
 955         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 956         string badoutstr;
 957         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
 958         (void)badout;
 959         (void)badoutstr;
 960     }
 961
 962     TEST(OCRepresentationSubscript, SubRepresentationVectorVector)
 963     {
 964         static const std::string AttrName = "VectorTest";
 965         OCRepresentation rep;
 966         OCRepresentation inner1, inner2, inner3, inner4;
 967         inner1.setUri("inner1");
 968         inner2.setUri("inner2");
 969         inner3.setUri("inner3");
 970         inner4.setUri("inner4");
 971
 972         vector<vector<OCRepresentation>> repsource {{inner1, inner2}, {inner3, inner4}};
 973         rep[AttrName] = repsource;
 974         vector<vector<OCRepresentation>> repout = rep[AttrName];
 975         vector<vector<OCRepresentation>> repout2;
 976         repout2 = rep[AttrName];
 977
 978         EXPECT_EQ(2u, repout.size());
 979         EXPECT_EQ(2u, repout[0].size());
 980         EXPECT_EQ(inner1.getUri(), repout[0][0].getUri());
 981         EXPECT_EQ(inner2.getUri(), repout[0][1].getUri());
 982         EXPECT_EQ(2u, repout.size());
 983         EXPECT_EQ(2u, repout[1].size());
 984         EXPECT_EQ(inner3.getUri(), repout[1][0].getUri());
 985         EXPECT_EQ(inner4.getUri(), repout[1][1].getUri());
 986
 987         EXPECT_EQ(2u, repout2.size());
 988         EXPECT_EQ(2u, repout2[0].size());
 989         EXPECT_EQ(inner1.getUri(), repout2[0][0].getUri());
 990         EXPECT_EQ(inner2.getUri(), repout2[0][1].getUri());
 991         EXPECT_EQ(2u, repout2.size());
 992         EXPECT_EQ(2u, repout2[1].size());
 993         EXPECT_EQ(inner3.getUri(), repout2[1][0].getUri());
 994         EXPECT_EQ(inner4.getUri(), repout2[1][1].getUri());
 995
 996         double badout;
 997         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
 998         string badoutstr;
 999         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
1000         (void)badout;
1001         (void)badoutstr;
1002     }
1003
1004     TEST(OCRepresentationSubscript, SubRepresentationVectorVectorVector)
1005     {
1006         static const std::string AttrName = "VectorTest";
1007         OCRepresentation rep;
1008         OCRepresentation inner1, inner2, inner3, inner4, inner5, inner6, inner7, inner8;
1009         inner1.setUri("inner1");
1010         inner2.setUri("inner2");
1011         inner3.setUri("inner3");
1012         inner4.setUri("inner4");
1013         inner5.setUri("inner5");
1014         inner6.setUri("inner6");
1015         inner7.setUri("inner7");
1016         inner8.setUri("inner8");
1017
1018         vector<vector<vector<OCRepresentation>>> repsource
1019             {{{inner1, inner2},{inner3, inner4}},{{inner5, inner6},{inner7,inner8}}};
1020
1021         rep[AttrName] = repsource;
1022         vector<vector<vector<OCRepresentation>>> repout = rep[AttrName];
1023         vector<vector<vector<OCRepresentation>>> repout2;
1024         repout2 = rep[AttrName];
1025
1026         EXPECT_EQ(2u, repout.size());
1027         EXPECT_EQ(2u, repout[0].size());
1028         EXPECT_EQ(2u, repout[0][0].size());
1029         EXPECT_EQ(inner1.getUri(), repout[0][0][0].getUri());
1030         EXPECT_EQ(inner2.getUri(), repout[0][0][1].getUri());
1031         EXPECT_EQ(2u, repout[0][1].size());
1032         EXPECT_EQ(inner3.getUri(), repout[0][1][0].getUri());
1033         EXPECT_EQ(inner4.getUri(), repout[0][1][1].getUri());
1034         EXPECT_EQ(2u, repout[1].size());
1035         EXPECT_EQ(2u, repout[1][0].size());
1036         EXPECT_EQ(inner5.getUri(), repout[1][0][0].getUri());
1037         EXPECT_EQ(inner6.getUri(), repout[1][0][1].getUri());
1038         EXPECT_EQ(2u, repout[1][1].size());
1039         EXPECT_EQ(inner7.getUri(), repout[1][1][0].getUri());
1040         EXPECT_EQ(inner8.getUri(), repout[1][1][1].getUri());
1041
1042         EXPECT_EQ(2u, repout2.size());
1043         EXPECT_EQ(2u, repout2[0].size());
1044         EXPECT_EQ(2u, repout2[0][0].size());
1045         EXPECT_EQ(inner1.getUri(), repout2[0][0][0].getUri());
1046         EXPECT_EQ(inner2.getUri(), repout2[0][0][1].getUri());
1047         EXPECT_EQ(2u, repout[0][1].size());
1048         EXPECT_EQ(inner3.getUri(), repout2[0][1][0].getUri());
1049         EXPECT_EQ(inner4.getUri(), repout2[0][1][1].getUri());
1050         EXPECT_EQ(2u, repout[1].size());
1051         EXPECT_EQ(2u, repout[1][0].size());
1052         EXPECT_EQ(inner5.getUri(), repout2[1][0][0].getUri());
1053         EXPECT_EQ(inner6.getUri(), repout2[1][0][1].getUri());
1054         EXPECT_EQ(2u, repout[1][1].size());
1055         EXPECT_EQ(inner7.getUri(), repout2[1][1][0].getUri());
1056         EXPECT_EQ(inner8.getUri(), repout2[1][1][1].getUri());
1057
1058         double badout;
1059         EXPECT_FALSE(rep.getValue<double>(AttrName, badout));
1060         string badoutstr;
1061         EXPECT_FALSE(rep.getValue<string>(AttrName, badoutstr));
1062         (void)badout;
1063         (void)badoutstr;
1064     }
1065
1066     TEST(OCRepresentationIterator, constiterator)
1067     {
1068         OCRepresentation rep;
1069
1070         EXPECT_TRUE(rep.empty());
1071         rep.setValue("int", 8);
1072         EXPECT_FALSE(rep.empty());
1073         rep.setValue("double", 8.8);
1074         rep.setValue("bool", true);
1075         rep.setValue("string", std::string("this is a string"));
1076
1077         EXPECT_EQ(4u, rep.size());
1078         EXPECT_FALSE(rep.empty());
1079
1080         OCRepresentation::const_iterator itr = rep.cbegin();
1081         OCRepresentation::const_iterator endItr = rep.cend();
1082         for(;itr!=endItr;++itr);
1083
1084         const OCRepresentation& rep2(rep);
1085         OCRepresentation::const_iterator itr2 = rep2.begin();
1086         OCRepresentation::const_iterator endItr2 = rep2.end();
1087         for(;itr2!=endItr2;++itr2);
1088
1089     }
1090
1091     TEST(OCRepresentationIterator, constautoiterator)
1092     {
1093         OCRepresentation rep;
1094
1095         EXPECT_TRUE(rep.empty());
1096         rep.setValue("int", 8);
1097         EXPECT_FALSE(rep.empty());
1098         rep.setValue("double", 8.8);
1099         rep.setValue("bool", true);
1100         rep.setValue("string", std::string("this is a string"));
1101
1102         EXPECT_EQ(4u, rep.size());
1103         EXPECT_FALSE(rep.empty());
1104
1105         for(const auto& a : rep)
1106         {
1107             (void)a;
1108         }
1109
1110         const OCRepresentation& rep2(rep);
1111         for(const auto& a : rep2)
1112         {
1113             (void)a;
1114         }
1115     }
1116     TEST(OCRepresentationIterator, autoiterator)
1117     {
1118         OCRepresentation rep;
1119
1120         EXPECT_TRUE(rep.empty());
1121         rep.setValue("int", 8);
1122         EXPECT_FALSE(rep.empty());
1123         rep.setValue("double", 8.8);
1124         rep.setValue("bool", true);
1125         rep.setValue("string", std::string("this is a string"));
1126
1127         EXPECT_EQ(4u, rep.size());
1128         EXPECT_FALSE(rep.empty());
1129
1130         for(auto& cur : rep)
1131         {
1132             if(cur.attrname() == "int")
1133             {
1134                 EXPECT_EQ("int", cur.attrname());
1135                 EXPECT_EQ(AttributeType::Integer, cur.type());
1136                 EXPECT_EQ(AttributeType::Integer, cur.base_type());
1137                 EXPECT_EQ(0u, cur.depth());
1138                 int curInt = cur.getValue<int>();
1139                 EXPECT_EQ(8, curInt);
1140             }
1141             if(cur.attrname() == "double")
1142             {
1143                 EXPECT_EQ("double", cur.attrname());
1144                 EXPECT_EQ(AttributeType::Double, cur.type());
1145                 EXPECT_EQ(AttributeType::Double, cur.base_type());
1146                 EXPECT_EQ(0u, cur.depth());
1147                 double curDouble = cur.getValue<double>();
1148                 EXPECT_EQ(8.8, curDouble);
1149             }
1150             if(cur.attrname() == "bool")
1151             {
1152                 EXPECT_EQ("bool", cur.attrname());
1153                 EXPECT_EQ(AttributeType::Boolean, cur.type());
1154                 EXPECT_EQ(AttributeType::Boolean, cur.base_type());
1155                 EXPECT_EQ(0u, cur.depth());
1156                 bool curBool = cur.getValue<bool>();
1157                 EXPECT_EQ(true, curBool);
1158             }
1159             if(cur.attrname() == "string")
1160             {
1161                 EXPECT_EQ("string", cur.attrname());
1162                 EXPECT_EQ(AttributeType::String, cur.type());
1163                 EXPECT_EQ(AttributeType::String, cur.base_type());
1164                 EXPECT_EQ(0u, cur.depth());
1165                 string curStr = cur.getValue<string>();
1166                 EXPECT_EQ("this is a string", curStr);
1167             }
1168         }
1169     }
1170     // Iterator usage
1171     TEST(OCRepresentationIterator, iterator)
1172     {
1173         OCRepresentation rep;
1174         OCRepresentation sub1;
1175         sub1.setUri("sub rep1 URI");
1176         OCRepresentation sub2;
1177         sub2.setUri("sub rep2 URI");
1178         OCRepresentation sub3;
1179         sub3.setUri("sub rep3 URI");
1180         OCRepresentation sub4;
1181         sub4.setUri("sub rep4 URI");
1182         OCRepresentation sub5;
1183         sub5.setUri("sub rep5 URI");
1184         OCRepresentation sub6;
1185         sub6.setUri("sub rep6 URI");
1186
1187
1188         EXPECT_TRUE(rep.empty());
1189         rep.setValue("int", 8);
1190         EXPECT_FALSE(rep.empty());
1191         rep.setValue("double", 8.8);
1192         rep.setValue("bool", true);
1193         rep.setValue("string", std::string("this is a string"));
1194         rep.setValue("rep", sub1);
1195
1196         vector<int> intv {1,2,3,4};
1197         rep.setValue("intv", intv);
1198         vector<double> doublev {1.1,2.2,3.3,4.4};
1199         rep.setValue("doublev", doublev);
1200         vector<bool> boolv{false, false, true};
1201         rep.setValue("boolv", boolv);
1202         vector<string> strv{"abc", "def", "ghi"};
1203         rep.setValue("strv", strv);
1204         vector<OCRepresentation> repv { sub1, sub2 };
1205         rep.setValue("repv", repv);
1206
1207         vector<vector<int>> intvv{{1,2,3},{4,5,6}};
1208         rep.setValue("intvv", intvv);
1209         vector<vector<vector<int>>> intvvv{{{1,2},{3,4}},{{5,6},{8,7}}};
1210         rep.setValue("intvvv", intvvv);
1211
1212         vector<vector<double>> doublevv{{1.1,2.1,3},{4.4,5.4,6.4}};
1213         rep.setValue("doublevv", doublevv);
1214         vector<vector<vector<double>>> doublevvv{{{1.1,2.1},{3.1,4.1}},{{5.1,6.1},{8.1,7.1}}};
1215         rep.setValue("doublevvv", doublevvv);
1216
1217         vector<vector<bool>> boolvv{{false, true},{true, false}};
1218         rep.setValue("boolvv", boolvv);
1219         vector<vector<vector<bool>>> boolvvv{{{true, false},{true}},{{false},{true}}};
1220         rep.setValue("boolvvv", boolvvv);
1221
1222         vector<vector<string>> strvv{{"abc", "def"},{"wer", "qwer"}};
1223         rep.setValue("strvv", strvv);
1224         vector<vector<vector<string>>> strvvv{{{"wqr", "xcv"},{"234"}},{{"we"},{"wert"}}};
1225         rep.setValue("strvvv", strvvv);
1226
1227         vector<vector<OCRepresentation>> repvv{{sub1, sub2},{sub3, sub4}};
1228         rep.setValue("repvv", repvv);
1229         vector<vector<vector<OCRepresentation>>> repvvv{{{sub5},{sub6}},{{sub3},{sub2}}};
1230         rep.setValue("repvvv", repvvv);
1231
1232         EXPECT_EQ(20u, rep.size());
1233         EXPECT_FALSE(rep.empty());
1234
1235         OCRepresentation::iterator itr= rep.begin();
1236         OCRepresentation::iterator endItr = rep.end();
1237
1238         for(;itr!=endItr;++itr)
1239         {
1240             if(itr->attrname() == "int")
1241             {
1242                 EXPECT_EQ("int", itr->attrname());
1243                 EXPECT_EQ(AttributeType::Integer, itr->type());
1244                 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1245                 EXPECT_EQ(0u, itr->depth());
1246                 int curInt = (*itr).getValue<int>();
1247                 EXPECT_EQ(8, curInt);
1248             }
1249             else if (itr->attrname() == "double")
1250             {
1251                 EXPECT_EQ("double", itr->attrname());
1252                 EXPECT_EQ(AttributeType::Double, itr->type());
1253                 EXPECT_EQ(AttributeType::Double, itr->base_type());
1254                 EXPECT_EQ(0u, itr->depth());
1255                 double curDouble = (*itr).getValue<double>();
1256                 EXPECT_EQ(8.8, curDouble);
1257             }
1258             else if (itr->attrname() == "bool")
1259             {
1260                 EXPECT_EQ("bool", itr->attrname());
1261                 EXPECT_EQ(AttributeType::Boolean, itr->type());
1262                 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1263                 EXPECT_EQ(0u, itr->depth());
1264                 bool curBool = (*itr).getValue<bool>();
1265                 EXPECT_EQ(true, curBool);
1266             }
1267             else if (itr->attrname() == "string")
1268             {
1269                 EXPECT_EQ("string", itr->attrname());
1270                 EXPECT_EQ(AttributeType::String, itr->type());
1271                 EXPECT_EQ(AttributeType::String, itr->base_type());
1272                 EXPECT_EQ(0u, itr->depth());
1273                 string curString = (*itr).getValue<string>();
1274                 EXPECT_EQ("this is a string", curString);
1275             }
1276             else if (itr->attrname() == "rep")
1277             {
1278                 EXPECT_EQ("rep", itr->attrname());
1279                 EXPECT_EQ(AttributeType::OCRepresentation, itr->type());
1280                 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1281                 EXPECT_EQ(0u, itr->depth());
1282                 OCRepresentation curRep = (*itr).getValue<OCRepresentation>();
1283                 EXPECT_EQ(sub1.getUri(), curRep.getUri());
1284             }
1285             else if (itr->attrname() == "intv")
1286             {
1287                 EXPECT_EQ("intv", itr->attrname());
1288                 EXPECT_EQ(AttributeType::Vector, itr->type());
1289                 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1290                 EXPECT_EQ(1u, itr->depth());
1291                 vector<int> curv = (*itr).getValue<vector<int>>();
1292                 EXPECT_EQ(intv, curv);
1293             }
1294             else if (itr->attrname() == "doublev")
1295             {
1296                 EXPECT_EQ("doublev", itr->attrname());
1297                 EXPECT_EQ(AttributeType::Vector, itr->type());
1298                 EXPECT_EQ(AttributeType::Double, itr->base_type());
1299                 EXPECT_EQ(1u, itr->depth());
1300                 vector<double> curv = (*itr).getValue<vector<double>>();
1301                 EXPECT_EQ(doublev, curv);
1302             }
1303             else if (itr->attrname() == "boolv")
1304             {
1305                 EXPECT_EQ("boolv", itr->attrname());
1306                 EXPECT_EQ(AttributeType::Vector, itr->type());
1307                 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1308                 EXPECT_EQ(1u, itr->depth());
1309                 vector<bool> curv = (*itr).getValue<vector<bool>>();
1310                 EXPECT_EQ(boolv, curv);
1311             }
1312             else if (itr->attrname() == "strv")
1313             {
1314                 EXPECT_EQ("strv", itr->attrname());
1315                 EXPECT_EQ(AttributeType::Vector, itr->type());
1316                 EXPECT_EQ(AttributeType::String, itr->base_type());
1317                 EXPECT_EQ(1u, itr->depth());
1318                 vector<string> curv = (*itr).getValue<vector<string>>();
1319                 EXPECT_EQ(strv, curv);
1320             }
1321             else if (itr->attrname() == "repv")
1322             {
1323                 EXPECT_EQ("repv", itr->attrname());
1324                 EXPECT_EQ(AttributeType::Vector, itr->type());
1325                 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1326                 EXPECT_EQ(1u, itr->depth());
1327                 vector<OCRepresentation> curv = (*itr).getValue<vector<OCRepresentation>>();
1328                 EXPECT_EQ(2u, repv.size());
1329                 EXPECT_EQ(sub1.getUri(), repv[0].getUri());
1330                 EXPECT_EQ(sub2.getUri(), repv[1].getUri());
1331             }
1332             else if (itr->attrname() == "intvv")
1333             {
1334                 EXPECT_EQ("intvv", itr->attrname());
1335                 EXPECT_EQ(AttributeType::Vector, itr->type());
1336                 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1337                 EXPECT_EQ(2u, itr->depth());
1338                 vector<vector<int>> curv = (*itr).getValue<vector<vector<int>>>();
1339                 EXPECT_EQ(intvv, curv);
1340             }
1341             else if (itr->attrname() == "intvvv")
1342             {
1343                 EXPECT_EQ("intvvv", itr->attrname());
1344                 EXPECT_EQ(AttributeType::Vector, itr->type());
1345                 EXPECT_EQ(AttributeType::Integer, itr->base_type());
1346                 EXPECT_EQ(3u, itr->depth());
1347                 vector<vector<vector<int>>> curv = (*itr).getValue<vector<vector<vector<int>>>>();
1348                 EXPECT_EQ(intvvv, curv);
1349             }
1350             else if (itr->attrname() == "doublevv")
1351             {
1352                 EXPECT_EQ("doublevv", itr->attrname());
1353                 EXPECT_EQ(AttributeType::Vector, itr->type());
1354                 EXPECT_EQ(AttributeType::Double, itr->base_type());
1355                 EXPECT_EQ(2u, itr->depth());
1356                 vector<vector<double>> curv = (*itr).getValue<vector<vector<double>>>();
1357                 EXPECT_EQ(doublevv, curv);
1358             }
1359             else if (itr->attrname() == "doublevvv")
1360             {
1361                 EXPECT_EQ("doublevvv", itr->attrname());
1362                 EXPECT_EQ(AttributeType::Vector, itr->type());
1363                 EXPECT_EQ(AttributeType::Double, itr->base_type());
1364                 EXPECT_EQ(3u, itr->depth());
1365                 vector<vector<vector<double>>> curv =
1366                     (*itr).getValue<vector<vector<vector<double>>>>();
1367                 EXPECT_EQ(doublevvv, curv);
1368             }
1369             else if (itr->attrname() == "boolvv")
1370             {
1371                 EXPECT_EQ("boolvv", itr->attrname());
1372                 EXPECT_EQ(AttributeType::Vector, itr->type());
1373                 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1374                 EXPECT_EQ(2u, itr->depth());
1375                 vector<vector<bool>> curv = (*itr).getValue<vector<vector<bool>>>();
1376                 EXPECT_EQ(boolvv, curv);
1377             }
1378             else if (itr->attrname() == "boolvvv")
1379             {
1380                 EXPECT_EQ("boolvvv", itr->attrname());
1381                 EXPECT_EQ(AttributeType::Vector, itr->type());
1382                 EXPECT_EQ(AttributeType::Boolean, itr->base_type());
1383                 EXPECT_EQ(3u, itr->depth());
1384                 vector<vector<vector<bool>>> curv = (*itr).getValue<vector<vector<vector<bool>>>>();
1385                 EXPECT_EQ(boolvvv, curv);
1386             }
1387             else if (itr->attrname() == "strvv")
1388             {
1389                 EXPECT_EQ("strvv", itr->attrname());
1390                 EXPECT_EQ(AttributeType::Vector, itr->type());
1391                 EXPECT_EQ(AttributeType::String, itr->base_type());
1392                 EXPECT_EQ(2u, itr->depth());
1393                 vector<vector<string>> curv = (*itr).getValue<vector<vector<string>>>();
1394                 EXPECT_EQ(strvv, curv);
1395             }
1396             else if (itr->attrname() == "strvvv")
1397             {
1398                 EXPECT_EQ("strvvv", itr->attrname());
1399                 EXPECT_EQ(AttributeType::Vector, itr->type());
1400                 EXPECT_EQ(AttributeType::String, itr->base_type());
1401                 EXPECT_EQ(3u, itr->depth());
1402                 vector<vector<vector<string>>> curv =
1403                     (*itr).getValue<vector<vector<vector<string>>>>();
1404                 EXPECT_EQ(strvvv, curv);
1405             }
1406             else if (itr->attrname() == "repvv")
1407             {
1408                 EXPECT_EQ("repvv", itr->attrname());
1409                 EXPECT_EQ(AttributeType::Vector, itr->type());
1410                 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1411                 EXPECT_EQ(2u, itr->depth());
1412                 vector<vector<OCRepresentation>> curv =
1413                     (*itr).getValue<vector<vector<OCRepresentation>>>();
1414                 EXPECT_EQ(2u, curv.size());
1415                 EXPECT_EQ(2u, curv[0].size());
1416                 EXPECT_EQ(sub1.getUri(), curv[0][0].getUri());
1417                 EXPECT_EQ(sub2.getUri(), curv[0][1].getUri());
1418                 EXPECT_EQ(2u, curv[1].size());
1419                 EXPECT_EQ(sub3.getUri(), curv[1][0].getUri());
1420                 EXPECT_EQ(sub4.getUri(), curv[1][1].getUri());
1421             }
1422             else if (itr->attrname() == "repvvv")
1423             {
1424                 EXPECT_EQ("repvvv", itr->attrname());
1425                 EXPECT_EQ(AttributeType::Vector, itr->type());
1426                 EXPECT_EQ(AttributeType::OCRepresentation, itr->base_type());
1427                 EXPECT_EQ(3u, itr->depth());
1428                 vector<vector<vector<OCRepresentation>>> curv =
1429                     (*itr).getValue<vector<vector<vector<OCRepresentation>>>>();
1430                 EXPECT_EQ(2u, curv.size());
1431                 EXPECT_EQ(2u, curv[0].size());
1432                 EXPECT_EQ(1u, curv[0][0].size());
1433                 EXPECT_EQ(sub5.getUri(), curv[0][0][0].getUri());
1434                 EXPECT_EQ(1u, curv[0][1].size());
1435                 EXPECT_EQ(sub6.getUri(), curv[0][1][0].getUri());
1436                 EXPECT_EQ(1u, curv[1][0].size());
1437                 EXPECT_EQ(sub3.getUri(), curv[1][0][0].getUri());
1438                 EXPECT_EQ(1u, curv[1][1].size());
1439                 EXPECT_EQ(sub2.getUri(), curv[1][1][0].getUri());
1440             }
1441             else
1442             {
1443                 EXPECT_TRUE(false) << itr->attrname();
1444             }
1445         }
1446     }
1447
1448     TEST(OCRepresentationHostTest, ValidHost)
1449     {
1450         OCDevAddr addr = {OC_DEFAULT_ADAPTER, OC_IP_USE_V6};
1451         addr.port = 5000;
1452         strcpy(addr.addr, "fe80::1%eth0");
1453
1454         OCRepresentation rep;
1455         rep.setDevAddr(addr);
1456         std::string host = rep.getHost();
1457         std::string expected = "coap://[fe80::1%25eth0]:5000";
1458         EXPECT_EQ(host, expected);
1459     }
1460
1461     TEST(OCRepresentationHostTest, InvalidHost)
1462     {
1463         OCDevAddr addr = {OC_DEFAULT_ADAPTER, OC_IP_USE_V6};
1464         addr.port = 5000;
1465         strcpy(addr.addr, "fe80::1%%");
1466
1467         OCRepresentation rep;
1468         EXPECT_ANY_THROW(rep.setDevAddr(addr));
1469     }
1470
1471 }