src/test/DBusOutputStreamTest.cpp

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