CommonAPI-DBus/src/test/DBusInputStreamTest.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 #include <CommonAPI/SerializableStruct.h>
   5 #include <CommonAPI/DBus/DBusInputStream.h>
   6 #include <CommonAPI/DBus/DBusOutputStream.h>
   7
   8 #include <unordered_map>
   9 #include <bits/functional_hash.h>
  10
  11 #include <gtest/gtest.h>
  12
  13 #include <dbus/dbus.h>
  14
  15 #include <chrono>
  16 #include <cstdint>
  17 #include <vector>
  18 #include <unordered_map>
  19 #include <bits/functional_hash.h>
  20
  21
  22 class InputStreamTest: public ::testing::Test {
  23   protected:
  24     DBusMessage* libdbusMessage;
  25     DBusMessageIter libdbusMessageWriteIter;
  26     size_t numOfElements;
  27
  28     void SetUp() {
  29         numOfElements = 2;
  30         libdbusMessage = dbus_message_new_method_call("no.bus.here", "/no/object/here", NULL, "noMethodHere");
  31         ASSERT_TRUE(libdbusMessage != NULL);
  32         dbus_message_iter_init_append(libdbusMessage, &libdbusMessageWriteIter);
  33     }
  34
  35     void TearDown() {
  36         dbus_message_unref(libdbusMessage);
  37     }
  38 };
  39
  40 TEST_F(InputStreamTest, CanBeConstructed) {
  41     CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage);
  42     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
  43 }
  44
  45 TEST_F(InputStreamTest, ReadsEmptyMessages) {
  46     CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage);
  47     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
  48
  49     EXPECT_EQ(0, scopedMessage.getBodyLength());
  50 }
  51
  52 TEST_F(InputStreamTest, ReadsBytes) {
  53     uint8_t val = 0xff;
  54     for (int i = 0; i < numOfElements; i += 1) {
  55         dbus_message_iter_append_basic(&libdbusMessageWriteIter, DBUS_TYPE_BYTE, &val);
  56     }
  57
  58     CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage);
  59     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
  60
  61     EXPECT_EQ(numOfElements, scopedMessage.getBodyLength());
  62     for (int i = 0; i < numOfElements; i += 1) {
  63         uint8_t readVal;
  64         inStream >> readVal;
  65         EXPECT_EQ(val, readVal);
  66     }
  67 }
  68
  69 TEST_F(InputStreamTest, ReadsBools) {
  70     dbus_bool_t f = FALSE;
  71     dbus_bool_t t = TRUE;
  72     for (int i = 0; i < numOfElements; i += 2) {
  73         dbus_message_iter_append_basic(&libdbusMessageWriteIter, DBUS_TYPE_BOOLEAN, &t);
  74         dbus_message_iter_append_basic(&libdbusMessageWriteIter, DBUS_TYPE_BOOLEAN, &f);
  75     }
  76
  77     CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage);
  78     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
  79
  80     EXPECT_EQ(numOfElements*4, scopedMessage.getBodyLength());
  81     for (int i = 0; i < numOfElements; i += 2) {
  82         bool readVal;
  83         inStream >> readVal;
  84         EXPECT_EQ(t, readVal);
  85         inStream >> readVal;
  86         EXPECT_EQ(f, readVal);
  87     }
  88 }
  89
  90 TEST_F(InputStreamTest, ReadsUint16) {
  91
  92     uint16_t val = 0xffff;
  93     for (int i = 0; i < numOfElements; i += 1) {
  94         dbus_message_iter_append_basic(&libdbusMessageWriteIter, DBUS_TYPE_UINT16, &val);
  95     }
  96
  97     CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage);
  98     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
  99
 100     EXPECT_EQ(numOfElements*2, scopedMessage.getBodyLength());
 101     for (int i = 0; i < numOfElements; i += 1) {
 102         uint16_t readVal;
 103         inStream >> readVal;
 104         EXPECT_EQ(val, readVal);
 105     }
 106 }
 107
 108 TEST_F(InputStreamTest, ReadsInt16) {
 109
 110     int16_t val = 0x7fff;
 111     for (int i = 0; i < numOfElements; i += 1) {
 112         dbus_message_iter_append_basic(&libdbusMessageWriteIter, DBUS_TYPE_INT16, &val);
 113     }
 114
 115     CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage);
 116     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
 117
 118     EXPECT_EQ(numOfElements*2, scopedMessage.getBodyLength());
 119     for (int i = 0; i < numOfElements; i += 1) {
 120         int16_t readVal;
 121         inStream >> readVal;
 122         EXPECT_EQ(val, readVal);
 123     }
 124 }
 125
 126 TEST_F(InputStreamTest, ReadsUint32) {
 127
 128     uint32_t val = 0xffffffff;
 129     for (int i = 0; i < numOfElements; i += 1) {
 130         dbus_message_iter_append_basic(&libdbusMessageWriteIter, DBUS_TYPE_UINT32, &val);
 131     }
 132
 133     CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage);
 134     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
 135
 136     EXPECT_EQ(numOfElements*4, scopedMessage.getBodyLength());
 137     for (int i = 0; i < numOfElements; i += 1) {
 138         uint32_t readVal;
 139         inStream >> readVal;
 140         EXPECT_EQ(val, readVal);
 141     }
 142 }
 143
 144 TEST_F(InputStreamTest, ReadsInt32) {
 145
 146     int32_t val = 0x7fffffff;
 147     for (int i = 0; i < numOfElements; i += 1) {
 148         dbus_message_iter_append_basic(&libdbusMessageWriteIter, DBUS_TYPE_INT32, &val);
 149     }
 150
 151     CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage);
 152     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
 153
 154     EXPECT_EQ(numOfElements*4, scopedMessage.getBodyLength());
 155     for (int i = 0; i < numOfElements; i += 1) {
 156         int32_t readVal;
 157         inStream >> readVal;
 158         EXPECT_EQ(val, readVal);
 159     }
 160 }
 161
 162 TEST_F(InputStreamTest, ReadsUint64) {
 163
 164     uint64_t val = 0xffffffffffffffff;
 165     for (int i = 0; i < numOfElements; i += 1) {
 166         dbus_message_iter_append_basic(&libdbusMessageWriteIter, DBUS_TYPE_UINT64, &val);
 167     }
 168
 169     CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage);
 170     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
 171
 172     EXPECT_EQ(numOfElements*8, scopedMessage.getBodyLength());
 173     for (int i = 0; i < numOfElements; i += 1) {
 174         uint64_t readVal;
 175         inStream >> readVal;
 176         EXPECT_EQ(val, readVal);
 177     }
 178 }
 179
 180 TEST_F(InputStreamTest, ReadsInt64) {
 181
 182     int64_t val = 0x7fffffffffffffff;
 183     for (int i = 0; i < numOfElements; i += 1) {
 184         dbus_message_iter_append_basic(&libdbusMessageWriteIter, DBUS_TYPE_INT64, &val);
 185     }
 186
 187     CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage);
 188     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
 189
 190     EXPECT_EQ(numOfElements*8, scopedMessage.getBodyLength());
 191     for (int i = 0; i < numOfElements; i += 1) {
 192         int64_t readVal;
 193         inStream >> readVal;
 194         EXPECT_EQ(val, readVal);
 195     }
 196 }
 197
 198 TEST_F(InputStreamTest, ReadsDoubles) {
 199
 200     double val = 13.37;
 201     for (int i = 0; i < numOfElements; i += 1) {
 202         dbus_message_iter_append_basic(&libdbusMessageWriteIter, DBUS_TYPE_DOUBLE, &val);
 203     }
 204
 205     CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage);
 206     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
 207
 208     EXPECT_EQ(numOfElements*8, scopedMessage.getBodyLength());
 209     for (int i = 0; i < numOfElements; i += 1) {
 210         double readVal;
 211         inStream >> readVal;
 212         EXPECT_EQ(val, readVal);
 213     }
 214 }
 215
 216 TEST_F(InputStreamTest, ReadsStrings) {
 217
 218     std::string val = "hai";
 219     for (int i = 0; i < numOfElements; i += 1) {
 220         dbus_message_iter_append_basic(&libdbusMessageWriteIter, DBUS_TYPE_STRING, &val);
 221     }
 222
 223     CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage);
 224     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
 225
 226     EXPECT_EQ(numOfElements*4 + numOfElements*4, scopedMessage.getBodyLength());
 227     for (int i = 0; i < numOfElements; i += 1) {
 228         std::string readVal;
 229         inStream >> readVal;
 230         EXPECT_EQ(val, readVal);
 231     }
 232 }
 233
 234 namespace bmw {
 235 namespace test {
 236
 237 struct TestSerializableStruct: CommonAPI::SerializableStruct {
 238     uint32_t a;
 239     int16_t b;
 240     bool c;
 241     std::string d;
 242     double e;
 243
 244         virtual void readFromInputStream(CommonAPI::InputStream& inputStream) {
 245                 inputStream >> a >> b >> c >> d >> e;
 246         }
 247
 248         virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
 249                 outputStream << a << b << c << d << e;
 250         }
 251 };
 252
 253 } //namespace test
 254 } //namespace bmw
 255
 256 TEST_F(InputStreamTest, ReadsStructs) {
 257
 258     bmw::test::TestSerializableStruct testStruct;
 259     testStruct.a = 15;
 260     testStruct.b = -32;
 261     testStruct.c = FALSE;
 262     testStruct.d = "Hello all";
 263     testStruct.e = 3.414;
 264
 265     DBusMessageIter subIter;
 266     dbus_message_iter_open_container(&libdbusMessageWriteIter, DBUS_TYPE_STRUCT, NULL, &subIter);
 267     dbus_message_iter_append_basic(&subIter, DBUS_TYPE_UINT32, &testStruct.a);
 268     dbus_message_iter_append_basic(&subIter, DBUS_TYPE_INT16, &testStruct.b);
 269     dbus_bool_t dbusBool = static_cast<dbus_bool_t>(testStruct.c);
 270     dbus_message_iter_append_basic(&subIter, DBUS_TYPE_BOOLEAN, &dbusBool);
 271     dbus_message_iter_append_basic(&subIter, DBUS_TYPE_STRING, &testStruct.d);
 272     dbus_message_iter_append_basic(&subIter, DBUS_TYPE_DOUBLE, &testStruct.e);
 273     dbus_message_iter_close_container(&libdbusMessageWriteIter, &subIter);
 274
 275     CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage);
 276     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
 277
 278     //40(byte length of struct) = 4(uint32_t) + 2(int16_t) + 2(padding) + 4(bool) + 4(strlength)
 279     //                          + 9(string) + 1(terminating '\0' of string) + 6(padding) + 8 (double)
 280     EXPECT_EQ(40, scopedMessage.getBodyLength());
 281
 282     bmw::test::TestSerializableStruct verifyStruct;
 283     inStream >> verifyStruct;
 284     EXPECT_EQ(testStruct.a, verifyStruct.a);
 285     EXPECT_EQ(testStruct.b, verifyStruct.b);
 286     EXPECT_EQ(testStruct.c, verifyStruct.c);
 287     EXPECT_EQ(testStruct.d, verifyStruct.d);
 288     EXPECT_EQ(testStruct.e, verifyStruct.e);
 289 }
 290
 291 TEST_F(InputStreamTest, ReadsArrays) {
 292
 293     std::vector<int32_t> testVector;
 294     int32_t val1 = 0xffffffff;
 295     int32_t val2 = 0x7fffffff;
 296     for (int i = 0; i < numOfElements; i += 2) {
 297         testVector.push_back(val1);
 298         testVector.push_back(val2);
 299     }
 300
 301     DBusMessageIter subIter;
 302     dbus_message_iter_open_container(&libdbusMessageWriteIter, DBUS_TYPE_ARRAY, "i", &subIter);
 303     for (int i = 0; i < numOfElements; i++) {
 304         dbus_message_iter_append_basic(&subIter, DBUS_TYPE_INT32, &testVector[i]);
 305     }
 306     dbus_message_iter_close_container(&libdbusMessageWriteIter, &subIter);
 307
 308     CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage);
 309     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
 310
 311     EXPECT_EQ(scopedMessage.getBodyLength(), numOfElements*4 + 4);
 312     std::vector<int32_t> verifyVector;
 313     inStream >> verifyVector;
 314     int32_t res1;
 315     int32_t res2;
 316     for (int i = 0; i < numOfElements; i += 2) {
 317         res1 = verifyVector[i];
 318         EXPECT_EQ(val1, res1);
 319         res2 = verifyVector[i + 1];
 320         EXPECT_EQ(val2, res2);
 321     }
 322 }
 323
 324 TEST_F(InputStreamTest, ReadsArraysInArrays) {
 325     size_t numOfElements = 2;
 326     DBusMessage* dbusMessage = dbus_message_new_method_call("no.bus.here", "/no/object/here", NULL, "noMethodHere");
 327     ASSERT_TRUE(dbusMessage != NULL);
 328
 329     DBusMessageIter writeIter;
 330     dbus_message_iter_init_append(dbusMessage, &writeIter);
 331
 332     std::vector<std::vector<int32_t>> testVector;
 333     int32_t val1 = 0xffffffff;
 334     int32_t val2 = 0x7fffffff;
 335     for (int i = 0; i < numOfElements; i++) {
 336         std::vector<int32_t> inner;
 337         for (int j = 0; j < numOfElements; j += 2) {
 338             inner.push_back(val1);
 339             inner.push_back(val2);
 340         }
 341         testVector.push_back(inner);
 342     }
 343
 344     DBusMessageIter subIter;
 345     dbus_message_iter_open_container(&writeIter, DBUS_TYPE_ARRAY, "ai", &subIter);
 346     for (int i = 0; i < numOfElements; i++) {
 347         DBusMessageIter subsubIter;
 348         dbus_message_iter_open_container(&subIter, DBUS_TYPE_ARRAY, "i", &subsubIter);
 349         for (int j = 0; j < numOfElements; j++) {
 350             dbus_message_iter_append_basic(&subsubIter, DBUS_TYPE_INT32, &(testVector[i][j]));
 351         }
 352         dbus_message_iter_close_container(&subIter, &subsubIter);
 353     }
 354     dbus_message_iter_close_container(&writeIter, &subIter);
 355
 356     CommonAPI::DBus::DBusMessage scopedMessage(dbusMessage);
 357     CommonAPI::DBus::DBusInputStream inStream(scopedMessage);
 358
 359     // 5*5*int32_t + 5*lengthField_inner(int32_t) + lengthField_outer(int32_t)
 360     EXPECT_EQ(numOfElements*numOfElements*4 + numOfElements*4 + 4, scopedMessage.getBodyLength());
 361     std::vector<std::vector<int32_t>> verifyVector;
 362     inStream >> verifyVector;
 363
 364     int32_t res1;
 365     int32_t res2;
 366     for (int i = 0; i < numOfElements; i++) {
 367         std::vector<int32_t> innerVerify = verifyVector[i];
 368         for (int j = 0; j < numOfElements; j += 2) {
 369             res1 = innerVerify[j];
 370             EXPECT_EQ(val1, res1);
 371             res2 = innerVerify[j + 1];
 372             EXPECT_EQ(val2, res2);
 373         }
 374     }
 375 }
 376
 377 int main(int argc, char** argv) {
 378         ::testing::InitGoogleTest(&argc, argv);
 379         return RUN_ALL_TESTS();
 380 }