src/test/DBusVariantOutputStreamTest.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
   8 #include <gtest/gtest.h>
   9 #include <CommonAPI/DBus/DBusOutputStream.h>
  10 #include <CommonAPI/DBus/DBusInputStream.h>
  11 #include <CommonAPI/SerializableVariant.h>
  12
  13 using namespace CommonAPI;
  14
  15 class VariantOutputStreamTest: public ::testing::Test {
  16   protected:
  17     size_t numOfElements;
  18     CommonAPI::DBus::DBusMessage message;
  19     const char* busName;
  20     const char* objectPath;
  21     const char* interfaceName;
  22     const char* methodName;
  23     const char* signature;
  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       signature = "yyyyyyyyyy";
  32     }
  33
  34     void TearDown() {
  35     }
  36
  37 };
  38
  39 typedef Variant<int,bool> InnerVar;
  40
  41 struct MyStruct: CommonAPI::SerializableStruct {
  42     ~MyStruct();
  43
  44     uint32_t a;
  45     InnerVar b;
  46     bool c;
  47     std::string d;
  48     double e;
  49
  50     virtual void readFromInputStream(CommonAPI::InputStream& inputMessageStream);
  51     virtual void writeToOutputStream(CommonAPI::OutputStream& outputMessageStream) const;
  52     static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
  53         typeOutputStream.writeUInt32Type();
  54         typeOutputStream.writeVariantType();
  55         typeOutputStream.writeBoolType();
  56         typeOutputStream.writeStringType();
  57         typeOutputStream.writeDoubleType();
  58     }
  59 };
  60
  61 MyStruct::~MyStruct() {
  62 }
  63
  64 void MyStruct::readFromInputStream(CommonAPI::InputStream& inputMessageStream) {
  65   inputMessageStream >> a >> b >> c >> d >> e;
  66 }
  67
  68 void MyStruct::writeToOutputStream(CommonAPI::OutputStream& outputMessageStream) const {
  69   outputMessageStream << a << b << c << d << e;
  70 }
  71
  72 bool operator==(const MyStruct& lhs, const MyStruct& rhs) {
  73     if (&lhs == &rhs)
  74         return true;
  75
  76     return
  77         lhs.a == rhs.a &&
  78         lhs.b == rhs.b &&
  79         lhs.c == rhs.c &&
  80         lhs.d == rhs.d &&
  81         lhs.e == rhs.e
  82     ;
  83 }
  84
  85 TEST_F(VariantOutputStreamTest, CanBeCalled) {
  86     message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
  87     DBus::DBusOutputStream outputStream(message);
  88 }
  89
  90 TEST_F(VariantOutputStreamTest, CanWriteVariant) {
  91     message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
  92     DBus::DBusOutputStream outputStream(message);
  93
  94     int fromInt = 14132;
  95     Variant<int, bool> inVariant(fromInt);
  96     Variant<int, bool> outVariant;
  97
  98     outputStream << inVariant;
  99     outputStream.flush();
 100
 101     DBus::DBusInputStream inputStream(message);
 102
 103     inputStream >> outVariant;
 104
 105     EXPECT_TRUE(outVariant.isType<int>());
 106     EXPECT_EQ(inVariant.get<int>(), outVariant.get<int>());
 107     EXPECT_TRUE(inVariant == outVariant);
 108 }
 109
 110 TEST_F(VariantOutputStreamTest, CanWriteVariantInVariant) {
 111     message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 112     DBus::DBusOutputStream outputStream(message);
 113
 114     int fromInt = 14132;
 115     Variant<int, bool> nestedVariant(fromInt);
 116
 117     Variant<InnerVar, std::string, float> inVariant(nestedVariant);
 118
 119     Variant<InnerVar, std::string, float> outVariant;
 120
 121     outputStream << inVariant;
 122     outputStream.flush();
 123
 124     DBus::DBusInputStream inputStream(message);
 125
 126     inputStream >> outVariant;
 127
 128     EXPECT_TRUE(outVariant.isType<InnerVar>());
 129     EXPECT_EQ(inVariant.get<InnerVar>(), outVariant.get<InnerVar>());
 130     EXPECT_TRUE(inVariant == outVariant);
 131 }
 132
 133 TEST_F(VariantOutputStreamTest, CanWriteVariantInStruct) {
 134     message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 135     DBus::DBusOutputStream outputStream(message);
 136
 137     int fromInt = 14132;
 138     Variant<int, bool> nestedVariant(fromInt);
 139
 140     MyStruct inStruct;
 141     inStruct.b = nestedVariant;
 142
 143     MyStruct outStruct;
 144
 145     outputStream << inStruct;
 146     outputStream.flush();
 147
 148     DBus::DBusInputStream inputStream(message);
 149
 150     inputStream >> outStruct;
 151
 152     EXPECT_TRUE(outStruct.b.isType<int>());
 153     EXPECT_EQ(outStruct.b.get<int>(), inStruct.b.get<int>());
 154     EXPECT_TRUE(inStruct.b == outStruct.b);
 155 }
 156
 157 TEST_F(VariantOutputStreamTest, CanWriteVariantInArray) {
 158     message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 159     DBus::DBusOutputStream outputStream(message);
 160
 161     int fromInt = 14132;
 162     std::vector<InnerVar> inVector;
 163     std::vector<InnerVar> outVector;
 164
 165     for (int i = 0; i < numOfElements; i++) {
 166         inVector.push_back(InnerVar(fromInt));
 167     }
 168
 169     outputStream << inVector;
 170     outputStream.flush();
 171
 172     DBus::DBusInputStream inputStream(message);
 173
 174     inputStream >> outVector;
 175
 176     EXPECT_TRUE(outVector[0].isType<int>());
 177     EXPECT_EQ(inVector[0].get<int>(), outVector[0].get<int>());
 178     EXPECT_EQ(numOfElements, outVector.size());
 179     EXPECT_TRUE(inVector[0] == outVector[0]);
 180 }
 181
 182 TEST_F(VariantOutputStreamTest, CanWriteArrayInVariant) {
 183     message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 184     DBus::DBusOutputStream outputStream(message);
 185
 186     typedef std::vector<int> IntVector;
 187     typedef Variant<IntVector, std::string> VectorVariant;
 188
 189     std::vector<int> inVector;
 190     int fromInt = 14132;
 191     for (int i = 0; i < numOfElements; i++) {
 192         inVector.push_back(fromInt);
 193     }
 194
 195
 196     VectorVariant inVariant(inVector);
 197     VectorVariant outVariant;
 198
 199     outputStream << inVariant;
 200     outputStream.flush();
 201
 202     DBus::DBusInputStream inputStream(message);
 203
 204     inputStream >> outVariant;
 205
 206     EXPECT_TRUE(outVariant.isType<IntVector>());
 207     EXPECT_EQ(inVariant.get<IntVector>(), outVariant.get<IntVector>());
 208     EXPECT_TRUE(inVariant == outVariant);
 209 }
 210
 211 TEST_F(VariantOutputStreamTest, CanWriteStructInVariant) {
 212     message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 213     DBus::DBusOutputStream outputStream(message);
 214
 215     typedef Variant<MyStruct, std::string> StructVariant;
 216
 217     MyStruct str;
 218     int fromInt = 14132;
 219     str.a = fromInt;
 220
 221     StructVariant inVariant(str);
 222     StructVariant outVariant;
 223
 224     outputStream << inVariant;
 225     outputStream.flush();
 226
 227     DBus::DBusInputStream inputStream(message);
 228
 229     inputStream >> outVariant;
 230
 231     EXPECT_TRUE(outVariant.isType<MyStruct>());
 232     EXPECT_EQ(inVariant.get<MyStruct>(), outVariant.get<MyStruct>());
 233     EXPECT_TRUE(inVariant == outVariant);
 234 }
 235
 236 TEST_F(VariantOutputStreamTest, CanWriteVariantInStructInVariant) {
 237     message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 238     DBus::DBusOutputStream outputStream(message);
 239
 240     typedef Variant<MyStruct, std::string> StructVariant;
 241
 242     MyStruct str;
 243     int fromInt = 14132;
 244     str.b = InnerVar(fromInt);
 245
 246     StructVariant inVariant(str);
 247     StructVariant outVariant;
 248
 249     outputStream << inVariant;
 250     outputStream.flush();
 251
 252     DBus::DBusInputStream inputStream(message);
 253
 254     inputStream >> outVariant;
 255
 256     EXPECT_TRUE(outVariant.isType<MyStruct>());
 257     EXPECT_EQ(inVariant.get<MyStruct>(), outVariant.get<MyStruct>());
 258     EXPECT_TRUE(inVariant.get<MyStruct>().b == outVariant.get<MyStruct>().b);
 259     EXPECT_TRUE(inVariant.get<MyStruct>().b.get<int>() == outVariant.get<MyStruct>().b.get<int>());
 260     EXPECT_TRUE(inVariant == outVariant);
 261 }
 262
 263 TEST_F(VariantOutputStreamTest, CanWriteVariantInArrayInVariant) {
 264     message = CommonAPI::DBus::DBusMessage::createMethodCall(busName, objectPath, interfaceName, methodName, signature);
 265     DBus::DBusOutputStream outputStream(message);
 266
 267     typedef std::vector<InnerVar> VarVector;
 268     typedef Variant<VarVector, std::string> ArrayVariant;
 269
 270     VarVector inVector;
 271     int fromInt = 14132;
 272     for (int i = 0; i < numOfElements; i++) {
 273         inVector.push_back(InnerVar(fromInt));
 274     }
 275
 276     ArrayVariant inVariant(inVector);
 277     ArrayVariant outVariant;
 278
 279     outputStream << inVariant;
 280     outputStream.flush();
 281
 282     DBus::DBusInputStream inputStream(message);
 283
 284     inputStream >> outVariant;
 285
 286     EXPECT_TRUE(outVariant.isType<VarVector>());
 287     EXPECT_EQ(inVariant.get<VarVector>(), outVariant.get<VarVector>());
 288     EXPECT_TRUE(inVariant.get<VarVector>()[0] == outVariant.get<VarVector>()[0]);
 289     EXPECT_TRUE(inVariant.get<VarVector>()[0].get<int>() == outVariant.get<VarVector>()[0].get<int>());
 290     EXPECT_TRUE(inVariant == outVariant);
 291 }
 292
 293 int main(int argc, char** argv) {
 294     ::testing::InitGoogleTest(&argc, argv);
 295     return RUN_ALL_TESTS();
 296 }