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