src/test/DBusOutputStreamTest.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include <dbus/dbus.h>
   6 #include <gtest/gtest.h>
   7
   8 #include <CommonAPI/DBus/DBusMessage.h>
   9 #include <CommonAPI/DBus/DBusOutputStream.h>
  10 #include <CommonAPI/DBus/DBusInputStream.h>
  11 #include <CommonAPI/SerializableStruct.h>
  12
  13
  14 class OutputStreamTest: public ::testing::Test {
  15 protected:
  16   size_t numOfElements;
  17   CommonAPI::DBus::DBusMessage message;
  18   const char* busName;
  19   const char* objectPath;
  20   const char* interfaceName;
  21   const char* methodName;
  22
  23   void SetUp() {
  24     numOfElements = 10;
  25     busName = "no.bus.here";
  26     objectPath = "/no/object/here";
  27     interfaceName = "no.interface.here";
  28     methodName = "noMethodHere";
  29   }
  30
  31   void TearDown() {
  32   }
  33 };
  34
  35 TEST_F(OutputStreamTest, CanBeConstructed) {
  36   CommonAPI::DBus::DBusOutputStream outStream(message);
  37 }
  38
  39 TEST_F(OutputStreamTest, WritesBytes) {
  40   const char* signature = "yyyyyyyyyy";
  41   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
  42   CommonAPI::DBus::DBusOutputStream outStream(message);
  43
  44   outStream.reserveMemory(numOfElements);
  45   uint8_t val1 = 0xff;
  46   uint8_t val2 = 0x00;
  47   for (int i = 0; i < numOfElements; i += 2) {
  48     outStream << val1;
  49     outStream << val2;
  50   }
  51   outStream.flush();
  52
  53   EXPECT_EQ(numOfElements, message.getBodyLength());
  54
  55   CommonAPI::DBus::DBusInputStream inStream(message);
  56
  57   uint8_t verifyVal1;
  58   uint8_t verifyVal2;
  59   for (int i = 0; i < numOfElements; i += 2) {
  60     inStream >> verifyVal1;
  61     EXPECT_EQ(val1, verifyVal1);
  62
  63     inStream >> verifyVal2;
  64     EXPECT_EQ(val2, verifyVal2);
  65   }
  66 }
  67
  68 TEST_F(OutputStreamTest, WritesBools) {
  69   const char* signature = "bbbbbbbbbb";
  70   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
  71   CommonAPI::DBus::DBusOutputStream outStream(message);
  72
  73   outStream.reserveMemory(numOfElements * 4);
  74   bool val1 = TRUE;
  75   bool val2 = FALSE;
  76   for (int i = 0; i < numOfElements; i += 2) {
  77     outStream << val1;
  78     outStream << val2;
  79   }
  80   outStream.flush();
  81
  82   EXPECT_EQ(numOfElements*4, message.getBodyLength());
  83
  84   CommonAPI::DBus::DBusInputStream inStream(message);
  85
  86   bool verifyVal1;
  87   bool verifyVal2;
  88   for (int i = 0; i < numOfElements; i += 2) {
  89     inStream >> verifyVal1;
  90     EXPECT_EQ(val1, verifyVal1);
  91
  92     inStream >> verifyVal2;
  93     EXPECT_EQ(val2, verifyVal2);
  94   }
  95 }
  96
  97 TEST_F(OutputStreamTest, WritesUInt16) {
  98   const char* signature = "qqqqqqqqqq";
  99   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 100   CommonAPI::DBus::DBusOutputStream outStream(message);
 101
 102   outStream.reserveMemory(numOfElements * 2);
 103   uint16_t val1 = 0x0000;
 104   uint16_t val2 = 0xffff;
 105   for (int i = 0; i < numOfElements; i += 2) {
 106     outStream << val1;
 107     outStream << val2;
 108   }
 109   outStream.flush();
 110
 111   EXPECT_EQ(numOfElements*2, message.getBodyLength());
 112
 113   CommonAPI::DBus::DBusInputStream inStream(message);
 114
 115   uint16_t verifyVal1;
 116   uint16_t verifyVal2;
 117   for (int i = 0; i < numOfElements; i += 2) {
 118     inStream >> verifyVal1;
 119     EXPECT_EQ(val1, verifyVal1);
 120
 121     inStream >> verifyVal2;
 122     EXPECT_EQ(val2, verifyVal2);
 123   }
 124 }
 125
 126 TEST_F(OutputStreamTest, WritesInt16) {
 127   const char* signature = "nnnnnnnnnn";
 128   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 129   CommonAPI::DBus::DBusOutputStream outStream(message);
 130
 131   outStream.reserveMemory(numOfElements * 2);
 132   int16_t val1 = 0x7fff;
 133   int16_t val2 = 0xffff;
 134   for (int i = 0; i < numOfElements; i += 2) {
 135     outStream << val1;
 136     outStream << val2;
 137   }
 138   outStream.flush();
 139
 140   EXPECT_EQ(numOfElements*2, message.getBodyLength());
 141
 142   CommonAPI::DBus::DBusInputStream inStream(message);
 143
 144   int16_t verifyVal1;
 145   int16_t verifyVal2;
 146   for (int i = 0; i < numOfElements; i += 2) {
 147     inStream >> verifyVal1;
 148     EXPECT_EQ(val1, verifyVal1);
 149
 150     inStream >> verifyVal2;
 151     EXPECT_EQ(val2, verifyVal2);
 152   }
 153 }
 154
 155 TEST_F(OutputStreamTest, WritesUInt32) {
 156   const char* signature = "uuuuuuuuuu";
 157   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 158   CommonAPI::DBus::DBusOutputStream outStream(message);
 159
 160   outStream.reserveMemory(numOfElements * 4);
 161   uint32_t val1 = 0x00000000;
 162   uint32_t val2 = 0xffffffff;
 163   for (int i = 0; i < numOfElements; i += 2) {
 164     outStream << val1;
 165     outStream << val2;
 166   }
 167   outStream.flush();
 168
 169   EXPECT_EQ(numOfElements*4, message.getBodyLength());
 170
 171   CommonAPI::DBus::DBusInputStream inStream(message);
 172
 173   uint32_t verifyVal1;
 174   uint32_t verifyVal2;
 175   for (int i = 0; i < numOfElements; i += 2) {
 176     inStream >> verifyVal1;
 177     EXPECT_EQ(val1, verifyVal1);
 178
 179     inStream >> verifyVal2;
 180     EXPECT_EQ(val2, verifyVal2);
 181   }
 182 }
 183
 184 TEST_F(OutputStreamTest, WritesInt32) {
 185   const char* signature = "iiiiiiiiii";
 186   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 187   CommonAPI::DBus::DBusOutputStream outStream(message);
 188
 189   outStream.reserveMemory(numOfElements * 4);
 190   int32_t val1 = 0x7fffffff;
 191   int32_t val2 = 0xffffffff;
 192   for (int i = 0; i < numOfElements; i += 2) {
 193     outStream << val1;
 194     outStream << val2;
 195   }
 196   outStream.flush();
 197
 198   EXPECT_EQ(numOfElements*4, message.getBodyLength());
 199
 200   CommonAPI::DBus::DBusInputStream inStream(message);
 201
 202   int32_t verifyVal1;
 203   int32_t verifyVal2;
 204   for (int i = 0; i < numOfElements; i += 2) {
 205     inStream >> verifyVal1;
 206     EXPECT_EQ(val1, verifyVal1);
 207
 208     inStream >> verifyVal2;
 209     EXPECT_EQ(val2, verifyVal2);
 210   }
 211 }
 212
 213 TEST_F(OutputStreamTest, WritesUInt64) {
 214   const char* signature = "tttttttttt";
 215   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 216   CommonAPI::DBus::DBusOutputStream outStream(message);
 217
 218   outStream.reserveMemory(numOfElements * 8);
 219   uint64_t val1 = 0x0000000000000000;
 220   uint64_t val2 = 0xffffffffffffffff;
 221   for (int i = 0; i < numOfElements; i += 2) {
 222     outStream << val1;
 223     outStream << val2;
 224   }
 225   outStream.flush();
 226
 227   EXPECT_EQ(numOfElements*8, message.getBodyLength());
 228
 229   CommonAPI::DBus::DBusInputStream inStream(message);
 230
 231   uint64_t verifyVal1;
 232   uint64_t verifyVal2;
 233   for (int i = 0; i < numOfElements; i += 2) {
 234     inStream >> verifyVal1;
 235     EXPECT_EQ(val1, verifyVal1);
 236
 237     inStream >> verifyVal2;
 238     EXPECT_EQ(val2, verifyVal2);
 239   }
 240 }
 241
 242 TEST_F(OutputStreamTest, WritesInt64) {
 243   const char* signature = "xxxxxxxxxx";
 244   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 245   CommonAPI::DBus::DBusOutputStream outStream(message);
 246
 247   outStream.reserveMemory(numOfElements * 8);
 248   int64_t val1 = 0x7fffffffffffffff;
 249   int64_t val2 = 0xffffffffffffffff;
 250   for (int i = 0; i < numOfElements; i += 2) {
 251     outStream << val1;
 252     outStream << val2;
 253   }
 254   outStream.flush();
 255
 256   EXPECT_EQ(numOfElements*8, message.getBodyLength());
 257
 258   CommonAPI::DBus::DBusInputStream inStream(message);
 259
 260   int64_t verifyVal1;
 261   int64_t verifyVal2;
 262   for (int i = 0; i < numOfElements; i += 2) {
 263     inStream >> verifyVal1;
 264     EXPECT_EQ(val1, verifyVal1);
 265
 266     inStream >> verifyVal2;
 267     EXPECT_EQ(val2, verifyVal2);
 268   }
 269 }
 270
 271 TEST_F(OutputStreamTest, WritesDouble) {
 272   const char* signature = "dddddddddd";
 273   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 274   CommonAPI::DBus::DBusOutputStream outStream(message);
 275
 276   outStream.reserveMemory(numOfElements * 8);
 277   double val1 = 13.37;
 278   double val2 = 3.414;
 279   for (int i = 0; i < numOfElements; i += 2) {
 280     outStream << val1;
 281     outStream << val2;
 282   }
 283   outStream.flush();
 284
 285   EXPECT_EQ(numOfElements*8, message.getBodyLength());
 286
 287   CommonAPI::DBus::DBusInputStream inStream(message);
 288
 289   double verifyVal1;
 290   double verifyVal2;
 291   std::string verifySignature;
 292   for (int i = 0; i < numOfElements; i += 2) {
 293     inStream >> verifyVal1;
 294     EXPECT_EQ(val1, verifyVal1);
 295
 296     inStream >> verifyVal2;
 297     EXPECT_EQ(val2, verifyVal2);
 298   }
 299 }
 300
 301 TEST_F(OutputStreamTest, WritesStrings) {
 302   const char* signature = "sss";
 303   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 304   CommonAPI::DBus::DBusOutputStream outStream(message);
 305
 306   std::string val1 = "hai";
 307   std::string val2 = "ciao";
 308   std::string val3 = "salut";
 309
 310   //sizes of the strings + terminating null-bytes (each 1 byte) + length-fields (each 4 bytes)
 311   outStream.reserveMemory(val1.size() + val2.size() + val3.size() + 3 + 3 * 4);
 312   outStream << val1 << val2 << val3;
 313   outStream.flush();
 314
 315   //Length fields + actual strings + terminating '\0's + 3(padding)
 316   EXPECT_EQ(3*4 + 3 + 4 + 5 + 3 + 3, message.getBodyLength());
 317
 318   CommonAPI::DBus::DBusInputStream inStream(message);
 319
 320   std::string verifyVal1;
 321   std::string verifyVal2;
 322   std::string verifyVal3;
 323   std::string verifySignature;
 324
 325   inStream >> verifyVal1;
 326   inStream >> verifyVal2;
 327   inStream >> verifyVal3;
 328
 329   EXPECT_EQ(val1, verifyVal1);
 330   EXPECT_EQ(val2, verifyVal2);
 331   EXPECT_EQ(val3, verifyVal3);
 332 }
 333
 334 namespace bmw {
 335 namespace test {
 336
 337 struct myStruct: CommonAPI::SerializableStruct {
 338   ~myStruct();
 339
 340   uint32_t a;
 341   int16_t b;
 342   bool c;
 343   std::string d;
 344   double e;
 345
 346   virtual void readFromInputStream(CommonAPI::InputStream& inputMessageStream);
 347   virtual void writeToOutputStream(CommonAPI::OutputStream& outputMessageStream) const;
 348 };
 349
 350 myStruct::~myStruct() {
 351 }
 352
 353 void myStruct::readFromInputStream(CommonAPI::InputStream& inputMessageStream) {
 354   inputMessageStream >> a >> b >> c >> d >> e;
 355 }
 356
 357 void myStruct::writeToOutputStream(CommonAPI::OutputStream& outputMessageStream) const {
 358   outputMessageStream << a << b << c << d << e;
 359 }
 360
 361 } //namespace test
 362 } //namespace bmw
 363
 364 TEST_F(OutputStreamTest, WritesStructs) {
 365   const char* signature = "(unbsd)";
 366   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 367   CommonAPI::DBus::DBusOutputStream outStream(message);
 368
 369   bmw::test::myStruct testStruct;
 370   testStruct.a = 15;
 371   testStruct.b = -32;
 372   testStruct.c = FALSE;
 373   testStruct.d = "Hello all";
 374   testStruct.e = 3.414;
 375
 376   // 40(byte length of struct) = 4(uint32_t) + 2(int16_t) + 2(padding) + 4(bool) + 4(strlength)
 377   //                           + 9(string) + 1(terminating '\0' of string) + 6(padding) + 8 (double)
 378   outStream.reserveMemory(40);
 379   outStream << testStruct;
 380   outStream.flush();
 381
 382   EXPECT_EQ(40, message.getBodyLength());
 383
 384   CommonAPI::DBus::DBusInputStream inStream(message);
 385   bmw::test::myStruct verifyStruct;
 386   inStream >> verifyStruct;
 387
 388   EXPECT_EQ(testStruct.a, verifyStruct.a);
 389   EXPECT_EQ(testStruct.b, verifyStruct.b);
 390   EXPECT_EQ(testStruct.c, verifyStruct.c);
 391   EXPECT_EQ(testStruct.d, verifyStruct.d);
 392   EXPECT_EQ(testStruct.e, verifyStruct.e);
 393 }
 394
 395 TEST_F(OutputStreamTest, WritesArrays) {
 396   const char* signature = "ai";
 397   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 398   CommonAPI::DBus::DBusOutputStream outStream(message);
 399
 400   std::vector<int32_t> testVector;
 401   int32_t val1 = 0xffffffff;
 402   int32_t val2 = 0x7fffffff;
 403   for (int i = 0; i < numOfElements; i += 2) {
 404     testVector.push_back(val1);
 405     testVector.push_back(val2);
 406   }
 407
 408   outStream.reserveMemory(numOfElements * 4 + 4);
 409   outStream << testVector;
 410   outStream.flush();
 411
 412   EXPECT_EQ(numOfElements*4 + 4, message.getBodyLength());
 413
 414   CommonAPI::DBus::DBusInputStream inStream(message);
 415   std::vector<int32_t> verifyVector;
 416   inStream >> verifyVector;
 417
 418   int32_t res1;
 419   int32_t res2;
 420   for (int i = 0; i < numOfElements; i += 2) {
 421     res1 = verifyVector[i];
 422     EXPECT_EQ(val1, res1);
 423     res2 = verifyVector[i + 1];
 424     EXPECT_EQ(val2, res2);
 425   }
 426 }
 427
 428 TEST_F(OutputStreamTest, WritesArraysOfStrings) {
 429   const char* signature = "as";
 430   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 431   CommonAPI::DBus::DBusOutputStream outStream(message);
 432
 433   std::vector<std::string> testVector;
 434   std::string val1 = "Hai";
 435   std::string val2 = "Ciao";
 436   for (int i = 0; i < numOfElements; i += 2) {
 437     testVector.push_back(val1);
 438     testVector.push_back(val2);
 439   }
 440
 441   // 101 = 4(lengthFieldOfArray) +
 442   //       4*(4(lengthField1) + 4(string1 mit \0-byte) + 4(lengthField2) + 5(string2 mit \0-byte) + 3(paddingTo4)) +
 443   //         (4(lengthField1) + 4(string1 mit \0-byte) + 4(lengthField2) + 5(string2 mit \0-byte))
 444   size_t vectorLength = 101;
 445   outStream.reserveMemory(vectorLength);
 446   outStream << testVector;
 447   outStream.flush();
 448
 449   EXPECT_EQ(vectorLength, message.getBodyLength());
 450
 451   CommonAPI::DBus::DBusInputStream inStream(message);
 452   std::vector<std::string> verifyVector;
 453   inStream >> verifyVector;
 454
 455   std::string res1;
 456   std::string res2;
 457   for (int i = 0; i < numOfElements; i += 2) {
 458     res1 = verifyVector[i];
 459     EXPECT_EQ(val1, res1);
 460     res2 = verifyVector[i + 1];
 461     EXPECT_EQ(val2, res2);
 462   }
 463 }
 464
 465 TEST_F(OutputStreamTest, WritesArraysInArrays) {
 466   const char* signature = "aai";
 467   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 468   CommonAPI::DBus::DBusOutputStream outStream(message);
 469
 470   std::vector<std::vector<int32_t>> testVector;
 471   int32_t val1 = 0xffffffff;
 472   int32_t val2 = 0x7fffffff;
 473   for (int i = 0; i < numOfElements; i++) {
 474     std::vector<int32_t> inner;
 475     for (int j = 0; j < numOfElements; j += 2) {
 476       inner.push_back(val1);
 477       inner.push_back(val2);
 478     }
 479     testVector.push_back(inner);
 480   }
 481
 482   outStream.reserveMemory(numOfElements * numOfElements * 4 + numOfElements * 4 + 4);
 483   outStream << testVector;
 484   outStream.flush();
 485
 486   EXPECT_EQ(numOfElements*numOfElements*4 + numOfElements*4 + 4, message.getBodyLength());
 487
 488   CommonAPI::DBus::DBusInputStream inStream(message);
 489   std::vector<std::vector<int32_t>> verifyVector;
 490   inStream >> verifyVector;
 491
 492   int32_t res1;
 493   int32_t res2;
 494   for (int i = 0; i < numOfElements; i++) {
 495     std::vector<int32_t> innerVerify = verifyVector[i];
 496     for (int j = 0; j < numOfElements; j += 2) {
 497       res1 = innerVerify[j];
 498       EXPECT_EQ(val1, res1);
 499       res2 = innerVerify[j + 1];
 500       EXPECT_EQ(val2, res2);
 501     }
 502   }
 503 }
 504
 505 namespace com {
 506 namespace bmw {
 507 namespace test {
 508
 509 struct TestStruct: CommonAPI::SerializableStruct {
 510   TestStruct();
 511   TestStruct(int32_t v1, double v2, double v3, std::string v4);
 512   ~TestStruct();
 513
 514   int32_t val1;
 515   double val2;
 516   double val3;
 517   std::string val4;
 518
 519   virtual void readFromInputStream(CommonAPI::InputStream& inputMessageStream);
 520   virtual void writeToOutputStream(CommonAPI::OutputStream& outputMessageStream) const;
 521 };
 522
 523 typedef std::vector<TestStruct> TestStructList;
 524
 525 TestStruct::TestStruct() :
 526     val1(0), val2(0), val3(0), val4("") {
 527 }
 528
 529 TestStruct::TestStruct(int32_t v1, double v2, double v3, std::string v4) :
 530     val1(v1), val2(v2), val3(v3), val4(v4) {
 531 }
 532
 533 TestStruct::~TestStruct() {
 534 }
 535
 536 void TestStruct::readFromInputStream(CommonAPI::InputStream& inputMessageStream) {
 537   inputMessageStream >> val1 >> val2 >> val3 >> val4;
 538 }
 539
 540 void TestStruct::writeToOutputStream(CommonAPI::OutputStream& outputMessageStream) const {
 541   outputMessageStream << val1 << val2 << val3 << val4;
 542 }
 543
 544 } // namespace test
 545 } // namespace bmw
 546 } // namespace com
 547
 548
 549 TEST_F(OutputStreamTest, WritesTestStructs) {
 550   const char* signature = "(idds)";
 551   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 552   CommonAPI::DBus::DBusOutputStream outStream(message);
 553
 554   com::bmw::test::TestStruct testStruct(1, 12.6, 1e40, "XXXXXXXXXXXXXXXXXXXX");
 555
 556   //4(int32_t) + 4(padding) + 8(double) + 8(double) + 4(str_length) + 20(string) + 1(null-termination)
 557   uint32_t expectedSize = 49;
 558   outStream.reserveMemory(expectedSize);
 559   outStream << testStruct;
 560   outStream.flush();
 561
 562   EXPECT_EQ(expectedSize, message.getBodyLength());
 563
 564   CommonAPI::DBus::DBusInputStream inStream(message);
 565   com::bmw::test::TestStruct verifyStruct;
 566   inStream >> verifyStruct;
 567
 568   EXPECT_EQ(testStruct.val1, verifyStruct.val1);
 569   EXPECT_EQ(testStruct.val2, verifyStruct.val2);
 570   EXPECT_EQ(testStruct.val3, verifyStruct.val3);
 571   EXPECT_EQ(testStruct.val4, verifyStruct.val4);
 572 }
 573
 574 TEST_F(OutputStreamTest, WritesTestStructLists) {
 575   const char* signature = "a(idds)";
 576   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 577   CommonAPI::DBus::DBusOutputStream outStream(message);
 578
 579   com::bmw::test::TestStructList testList;
 580   for (int i = 0; i < numOfElements; i++) {
 581     testList.emplace_back(1, 12.6, 1e40, "XXXXXXXXXXXXXXXXXXXX");
 582   }
 583
 584   //struct size: 49 = 4(int32_t) + 4(padding) + 8(double) + 8(double) + 4(str_length) + 20(string) + 1(null-termination)
 585   //array size:  4(array_length) + 4(struct_padding) + (numElements-1)*(49(struct) + 7(struct_padding)) + 49(struct)
 586   uint32_t expectedSize = 8 + (numOfElements - 1) * (49 + 7) + 49;
 587   outStream.reserveMemory(expectedSize);
 588   outStream << testList;
 589   outStream.flush();
 590
 591   EXPECT_EQ(expectedSize, message.getBodyLength());
 592
 593   CommonAPI::DBus::DBusInputStream inStream(message);
 594   com::bmw::test::TestStructList verifyList;
 595   inStream >> verifyList;
 596
 597   EXPECT_EQ(numOfElements, verifyList.size());
 598 }
 599
 600
 601
 602 namespace com {
 603 namespace bmw {
 604 namespace test {
 605
 606 struct ArrayStruct: CommonAPI::SerializableStruct {
 607   ArrayStruct();
 608   ArrayStruct(std::vector<int64_t> v1, std::vector<std::string> v2, std::vector<double> v3, std::vector<std::string> v4, std::vector<uint16_t> v5);
 609   ~ArrayStruct();
 610
 611   std::vector<int64_t> val1;
 612   std::vector<std::string> val2;
 613   std::vector<double> val3;
 614   std::vector<std::string> val4;
 615   std::vector<uint16_t> val5;
 616
 617   virtual void readFromInputStream(CommonAPI::InputStream& inputMessageStream);
 618   virtual void writeToOutputStream(CommonAPI::OutputStream& outputMessageStream) const;
 619 };
 620
 621 typedef std::vector<TestStruct> TestStructList;
 622
 623 ArrayStruct::ArrayStruct() {
 624 }
 625
 626 ArrayStruct::ArrayStruct(std::vector<int64_t> v1, std::vector<std::string> v2, std::vector<double> v3, std::vector<std::string> v4, std::vector<uint16_t> v5) :
 627     val1(v1), val2(v2), val3(v3), val4(v4), val5(v5) {
 628 }
 629
 630 ArrayStruct::~ArrayStruct() {
 631 }
 632
 633 void ArrayStruct::readFromInputStream(CommonAPI::InputStream& inputMessageStream) {
 634   inputMessageStream >> val1 >> val2 >> val3 >> val4 >> val5;
 635 }
 636
 637 void ArrayStruct::writeToOutputStream(CommonAPI::OutputStream& outputMessageStream) const {
 638   outputMessageStream << val1 << val2 << val3 << val4 << val5;
 639 }
 640
 641 } // namespace test
 642 } // namespace bmw
 643 } // namespace com
 644
 645
 646 TEST_F(OutputStreamTest, WritesStructsOfArraysWithSthBefore) {
 647   const char* signature = "(axasadasaq)";
 648   message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 649   CommonAPI::DBus::DBusOutputStream outStream(message);
 650
 651   com::bmw::test::ArrayStruct arrayStruct;
 652   for (int i = 0; i < numOfElements; i++) {
 653       arrayStruct.val1.push_back(i*50);
 654       arrayStruct.val2.push_back("Hai");
 655       arrayStruct.val3.push_back(3.414);
 656       arrayStruct.val4.push_back("Ciao");
 657       arrayStruct.val5.push_back(i*5);
 658   }
 659   uint16_t frontValue = 0;
 660
 661   // 2(uint16) + 6(padding)                                             --> 8
 662   // 4(LengthField) + 4(padding) + 10 * 8(int64)                        --> 88  --> 96
 663   // 4(LengthField) + 10 * (4(LengthField) + 4("Hai\0"))                --> 84  --> 180
 664   // 4(LengthField) + 10 * 8(double)                                    --> 84  --> 264
 665   // 4(LengthField) + 10 * (4(LengthField) + 5("Ciao\0") + 3(padding))  --> 124 --> 388
 666   // 4(LengthField) + 10 * 2(uint16)                                    --> 24  --> 412
 667   size_t structLength = 412;
 668   outStream.reserveMemory(structLength);
 669   outStream << frontValue << arrayStruct;
 670   outStream.flush();
 671
 672   EXPECT_EQ(structLength, message.getBodyLength());
 673
 674   CommonAPI::DBus::DBusInputStream inStream(message);
 675   com::bmw::test::ArrayStruct verifyStruct;
 676
 677   uint16_t frontVerification;
 678   inStream >> frontVerification >> verifyStruct;
 679
 680   EXPECT_EQ(frontValue, frontVerification);
 681
 682   int64_t res1;
 683   std::string res2;
 684   double res3;
 685   std::string res4;
 686   uint16_t res5;
 687
 688   for (int i = 0; i < numOfElements; i++) {
 689     res1 = verifyStruct.val1[i];
 690     res2 = verifyStruct.val2[i];
 691     res3 = verifyStruct.val3[i];
 692     res4 = verifyStruct.val4[i];
 693     res5 = verifyStruct.val5[i];
 694
 695     EXPECT_EQ(i*50, res1);
 696     EXPECT_EQ(std::string("Hai"), res2);
 697     EXPECT_EQ(3.414, res3);
 698     EXPECT_EQ(std::string("Ciao"), res4);
 699     EXPECT_EQ(i*5, res5);
 700   }
 701 }
 702
 703 int main(int argc, char** argv) {
 704     ::testing::InitGoogleTest(&argc, argv);
 705     return RUN_ALL_TESTS();
 706 }