src/test/DBusTypeStreamTest.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 <gtest/gtest.h>
   6
   7 #include <unordered_map>
   8 #include <vector>
   9
  10 #include <CommonAPI/SerializableStruct.h>
  11 #include <CommonAPI/SerializableVariant.h>
  12 #include <CommonAPI/types.h>
  13 #include <CommonAPI/ByteBuffer.h>
  14
  15 #include <CommonAPI/DBus/DBusOutputStream.h>
  16
  17 #include "commonapi/tests/DerivedTypeCollection.h"
  18
  19 #include <type_traits>
  20
  21
  22 struct TestStructWithVariant: public CommonAPI::SerializableStruct {
  23     TestStructWithVariant(): uint16Val_(42), stringVal_("Hai!"), variantVal_(13.37) {
  24
  25     }
  26
  27     virtual ~TestStructWithVariant() {}
  28
  29     virtual void readFromInputStream(CommonAPI::InputStream& inputStream) {
  30     }
  31
  32     virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const {
  33     }
  34
  35     static void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) {
  36         CommonAPI::TypeWriter<uint16_t>::writeType(typeOutputStream);
  37         CommonAPI::TypeWriter<std::string>::writeType(typeOutputStream);
  38         CommonAPI::TypeWriter<CommonAPI::Variant<uint32_t, double, std::vector<std::string>>>::writeType(typeOutputStream);
  39     }
  40
  41   private:
  42     uint16_t uint16Val_;
  43     std::string stringVal_;
  44     CommonAPI::Variant<uint32_t, double, std::vector<std::string>> variantVal_;
  45 };
  46
  47
  48 typedef std::vector<commonapi::tests::DerivedTypeCollection::TestEnum> TestEnumList;
  49
  50
  51 class TypeOutputStreamTest: public ::testing::Test {
  52   protected:
  53
  54     void SetUp() {
  55     }
  56
  57     void TearDown() {
  58     }
  59
  60     CommonAPI::DBus::DBusTypeOutputStream typeStream_;
  61 };
  62
  63
  64
  65 TEST_F(TypeOutputStreamTest, CreatesBasicTypeSignatures) {
  66     CommonAPI::TypeWriter<bool>::writeType(typeStream_);
  67     std::string signature = typeStream_.retrieveSignature();
  68     ASSERT_TRUE(signature.compare("b") == 0);
  69 }
  70
  71 TEST_F(TypeOutputStreamTest, CreatesInt8Signature) {
  72     CommonAPI::TypeWriter<int8_t>::writeType(typeStream_);
  73     std::string signature = typeStream_.retrieveSignature();
  74     ASSERT_TRUE(signature.compare("y") == 0);
  75 }
  76 TEST_F(TypeOutputStreamTest, CreatesInt16Signature) {
  77     CommonAPI::TypeWriter<int16_t>::writeType(typeStream_);
  78     std::string signature = typeStream_.retrieveSignature();
  79     ASSERT_TRUE(signature.compare("n") == 0);
  80 }
  81 TEST_F(TypeOutputStreamTest, CreatesInt32Signature) {
  82     CommonAPI::TypeWriter<int32_t>::writeType(typeStream_);
  83     std::string signature = typeStream_.retrieveSignature();
  84     ASSERT_TRUE(signature.compare("i") == 0);
  85 }
  86 TEST_F(TypeOutputStreamTest, CreatesInt64Signature) {
  87     CommonAPI::TypeWriter<int64_t>::writeType(typeStream_);
  88     std::string signature = typeStream_.retrieveSignature();
  89     ASSERT_TRUE(signature.compare("x") == 0);
  90 }
  91
  92 TEST_F(TypeOutputStreamTest, CreatesUInt8Signature) {
  93     CommonAPI::TypeWriter<uint8_t>::writeType(typeStream_);
  94     std::string signature = typeStream_.retrieveSignature();
  95     ASSERT_TRUE(signature.compare("y") == 0);
  96 }
  97 TEST_F(TypeOutputStreamTest, CreatesUInt16Signature) {
  98     CommonAPI::TypeWriter<uint16_t>::writeType(typeStream_);
  99     std::string signature = typeStream_.retrieveSignature();
 100     ASSERT_TRUE(signature.compare("q") == 0);
 101 }
 102 TEST_F(TypeOutputStreamTest, CreatesUInt32Signature) {
 103     CommonAPI::TypeWriter<uint32_t>::writeType(typeStream_);
 104     std::string signature = typeStream_.retrieveSignature();
 105     ASSERT_TRUE(signature.compare("u") == 0);
 106 }
 107 TEST_F(TypeOutputStreamTest, CreatesUInt64Signature) {
 108     CommonAPI::TypeWriter<uint64_t>::writeType(typeStream_);
 109     std::string signature = typeStream_.retrieveSignature();
 110     ASSERT_TRUE(signature.compare("t") == 0);
 111 }
 112
 113 TEST_F(TypeOutputStreamTest, CreatesFloatSignature) {
 114     CommonAPI::TypeWriter<float>::writeType(typeStream_);
 115     std::string signature = typeStream_.retrieveSignature();
 116     ASSERT_TRUE(signature.compare("d") == 0);
 117 }
 118 TEST_F(TypeOutputStreamTest, CreatesDoubleSignature) {
 119     CommonAPI::TypeWriter<double>::writeType(typeStream_);
 120     std::string signature = typeStream_.retrieveSignature();
 121     ASSERT_TRUE(signature.compare("d") == 0);
 122 }
 123
 124 TEST_F(TypeOutputStreamTest, CreatesStringSignature) {
 125     CommonAPI::TypeWriter<std::string>::writeType(typeStream_);
 126     std::string signature = typeStream_.retrieveSignature();
 127     ASSERT_TRUE(signature.compare("s") == 0);
 128 }
 129
 130 TEST_F(TypeOutputStreamTest, CreatesByteBufferSignature) {
 131     CommonAPI::TypeWriter<CommonAPI::ByteBuffer>::writeType(typeStream_);
 132     std::string signature = typeStream_.retrieveSignature();
 133     ASSERT_TRUE(signature.compare("ay") == 0);
 134 }
 135
 136 TEST_F(TypeOutputStreamTest, CreatesVersionSignature) {
 137     CommonAPI::TypeWriter<CommonAPI::Version>::writeType(typeStream_);
 138     std::string signature = typeStream_.retrieveSignature();
 139     ASSERT_TRUE(signature.compare("(uu)") == 0);
 140 }
 141
 142 TEST_F(TypeOutputStreamTest, CreatesInt32EnumSignature) {
 143     CommonAPI::TypeWriter<commonapi::tests::DerivedTypeCollection::TestEnum>::writeType(typeStream_);
 144     std::string signature = typeStream_.retrieveSignature();
 145     ASSERT_TRUE(signature.compare("i") == 0);
 146 }
 147
 148 TEST_F(TypeOutputStreamTest, CreatesVariantWithBasicTypesSignature) {
 149     CommonAPI::TypeWriter<CommonAPI::Variant<int, double, std::string>>::writeType(typeStream_);
 150     std::string signature = typeStream_.retrieveSignature();
 151     ASSERT_TRUE(signature.compare("(yv)") == 0);
 152 }
 153
 154 TEST_F(TypeOutputStreamTest, CreatesVariantWithVariantSignature) {
 155     CommonAPI::TypeWriter<CommonAPI::Variant<int, CommonAPI::Variant<int, double, std::string>, CommonAPI::Variant<int, CommonAPI::Variant<int, double, std::string>, std::string>, std::string>>::writeType(typeStream_);
 156     std::string signature = typeStream_.retrieveSignature();
 157     ASSERT_TRUE(signature.compare("(yv)") == 0);
 158 }
 159
 160 TEST_F(TypeOutputStreamTest, CreatesVectorOfStringsSignature) {
 161     CommonAPI::TypeWriter<std::vector<std::string> >::writeType(typeStream_);
 162     std::string signature = typeStream_.retrieveSignature();
 163     ASSERT_TRUE(signature.compare("as") == 0);
 164 }
 165
 166 TEST_F(TypeOutputStreamTest, CreatesVectorOfInt32EnumsSignature) {
 167     CommonAPI::TypeWriter<TestEnumList>::writeType(typeStream_);
 168     std::string signature = typeStream_.retrieveSignature();
 169     ASSERT_TRUE(signature.compare("ai") == 0);
 170 }
 171
 172 TEST_F(TypeOutputStreamTest, CreatesVectorOfVersionsSignature) {
 173     CommonAPI::TypeWriter<std::vector<CommonAPI::Version> >::writeType(typeStream_);
 174     std::string signature = typeStream_.retrieveSignature();
 175     ASSERT_TRUE(signature.compare("a(uu)") == 0);
 176 }
 177
 178 TEST_F(TypeOutputStreamTest, CreatesVectorOfVariantsSignature) {
 179     CommonAPI::TypeWriter<std::vector<CommonAPI::Variant<int, double, std::string>> >::writeType(typeStream_);
 180     std::string signature = typeStream_.retrieveSignature();
 181     ASSERT_TRUE(signature.compare("a(yv)") == 0);
 182 }
 183
 184 TEST_F(TypeOutputStreamTest, CreatesVectorOfVectorOfStringsSignature) {
 185     CommonAPI::TypeWriter<std::vector<std::vector<std::string>> >::writeType(typeStream_);
 186     std::string signature = typeStream_.retrieveSignature();
 187     ASSERT_TRUE(signature.compare("aas") == 0);
 188 }
 189
 190 TEST_F(TypeOutputStreamTest, CreatesVectorOfVectorOfVariantsSignature) {
 191     CommonAPI::TypeWriter<std::vector<std::vector<CommonAPI::Variant<int, double, std::string>>> >::writeType(typeStream_);
 192     std::string signature = typeStream_.retrieveSignature();
 193     ASSERT_TRUE(signature.compare("aa(yv)") == 0);
 194 }
 195
 196 TEST_F(TypeOutputStreamTest, CreatesMapOfUInt16ToStringSignature) {
 197     CommonAPI::TypeWriter<std::unordered_map<uint16_t, std::string>>::writeType(typeStream_);
 198     std::string signature = typeStream_.retrieveSignature();
 199     ASSERT_TRUE(signature.compare("a{qs}") == 0);
 200 }
 201
 202 TEST_F(TypeOutputStreamTest, CreatesVectorOfMapsOfUInt16ToStringSignature) {
 203     CommonAPI::TypeWriter<std::vector<std::unordered_map<uint16_t, std::string>> >::writeType(typeStream_);
 204     std::string signature = typeStream_.retrieveSignature();
 205     ASSERT_TRUE(signature.compare("aa{qs}") == 0);
 206 }
 207
 208
 209 TEST_F(TypeOutputStreamTest, ParsesSignatureOfTestStructCorrectly) {
 210     CommonAPI::TypeWriter<TestStructWithVariant>::writeType(typeStream_);
 211     std::string signature = typeStream_.retrieveSignature();
 212     ASSERT_TRUE(signature.compare("(qs(yv))") == 0);
 213 }
 214
 215
 216 TEST_F(TypeOutputStreamTest, ParsesSignatureOfUInt32TypeVariantsCorrectly) {
 217     uint32_t fromUInt = 42;
 218     CommonAPI::Variant<uint32_t, double, uint16_t> myVariant(fromUInt);
 219
 220     myVariant.writeToTypeOutputStream(typeStream_);
 221
 222     std::string signature = typeStream_.retrieveSignature();
 223     ASSERT_TRUE(signature.compare("u") == 0);
 224 }
 225
 226
 227 TEST_F(TypeOutputStreamTest, ParsesSignatureOfStringTypeVariantsCorrectly) {
 228     std::string fromString = "Hai!";
 229     CommonAPI::Variant<uint32_t, double, std::string> myVariant(fromString);
 230
 231     myVariant.writeToTypeOutputStream(typeStream_);
 232
 233     std::string signature = typeStream_.retrieveSignature();
 234     ASSERT_TRUE(signature.compare("s") == 0);
 235 }
 236
 237
 238 TEST_F(TypeOutputStreamTest, ParsesSignatureOfVectorTypeVariantsCorrectly) {
 239     std::vector<std::string> fromStringVector;
 240     CommonAPI::Variant<uint32_t, double, std::vector<std::string>> myVariant(fromStringVector);
 241
 242     myVariant.writeToTypeOutputStream(typeStream_);
 243
 244     std::string signature = typeStream_.retrieveSignature();
 245     ASSERT_TRUE(signature.compare("as") == 0);
 246 }
 247
 248
 249 TEST_F(TypeOutputStreamTest, ParsesSignatureOfTestStructTypeVariantsCorrectly) {
 250     TestStructWithVariant fromTestStruct;
 251     CommonAPI::Variant<uint32_t, double, TestStructWithVariant> myVariant(fromTestStruct);
 252
 253     myVariant.writeToTypeOutputStream(typeStream_);
 254
 255     std::string signature = typeStream_.retrieveSignature();
 256     ASSERT_TRUE(signature.compare("(qs(yv))") == 0);
 257 }
 258
 259 TEST_F(TypeOutputStreamTest, ParsesSignatureOfGenericUInt32TypeVariantsCorrectly) {
 260     uint32_t fromUInt = 42;
 261     CommonAPI::Variant<uint32_t, double, uint16_t> myVariant(fromUInt);
 262     CommonAPI::SerializableVariant* genericVariant = &myVariant;
 263
 264     genericVariant->writeToTypeOutputStream(typeStream_);
 265
 266     std::string signature = typeStream_.retrieveSignature();
 267     ASSERT_TRUE(signature.compare("u") == 0);
 268 }
 269
 270 TEST_F(TypeOutputStreamTest, ParsesSignatureOfGenericInt32EnumTypeVariantsCorrectly) {
 271     commonapi::tests::DerivedTypeCollection::TestEnum fromInt32Enum = commonapi::tests::DerivedTypeCollection::TestEnum::E_OK;
 272     CommonAPI::Variant<uint32_t, double, commonapi::tests::DerivedTypeCollection::TestEnum> myVariant(fromInt32Enum);
 273     CommonAPI::SerializableVariant* genericVariant = &myVariant;
 274
 275     genericVariant->writeToTypeOutputStream(typeStream_);
 276
 277     std::string signature = typeStream_.retrieveSignature();
 278     ASSERT_TRUE(signature.compare("i") == 0);
 279 }
 280
 281 TEST_F(TypeOutputStreamTest, ParsesSignatureOfGenericStringTypeVariantsCorrectly) {
 282     std::string fromString = "Hai!";
 283     CommonAPI::Variant<uint32_t, double, std::string> myVariant(fromString);
 284     CommonAPI::SerializableVariant* genericVariant = &myVariant;
 285
 286     genericVariant->writeToTypeOutputStream(typeStream_);
 287
 288     std::string signature = typeStream_.retrieveSignature();
 289     ASSERT_TRUE(signature.compare("s") == 0);
 290 }
 291
 292
 293 TEST_F(TypeOutputStreamTest, ParsesSignatureOfGenericVectorTypeVariantsCorrectly) {
 294     std::vector<std::string> fromStringVector;
 295     CommonAPI::Variant<uint32_t, double, std::vector<std::string>> myVariant(fromStringVector);
 296     CommonAPI::SerializableVariant* genericVariant = &myVariant;
 297
 298     genericVariant->writeToTypeOutputStream(typeStream_);
 299
 300     std::string signature = typeStream_.retrieveSignature();
 301     ASSERT_TRUE(signature.compare("as") == 0);
 302 }
 303
 304
 305 TEST_F(TypeOutputStreamTest, ParsesSignatureOfGenericVectorOfInt32EnumTypeVariantsCorrectly) {
 306     TestEnumList fromEnumVector;
 307     CommonAPI::Variant<uint32_t, double, TestEnumList> myVariant(fromEnumVector);
 308     CommonAPI::SerializableVariant* genericVariant = &myVariant;
 309
 310     genericVariant->writeToTypeOutputStream(typeStream_);
 311
 312     std::string signature = typeStream_.retrieveSignature();
 313     ASSERT_TRUE(signature.compare("ai") == 0);
 314 }
 315
 316
 317 TEST_F(TypeOutputStreamTest, ParsesSignatureOfGenericTestStructTypeVariantsCorrectly) {
 318     TestStructWithVariant fromTestStruct;
 319     CommonAPI::Variant<uint32_t, double, TestStructWithVariant> myVariant(fromTestStruct);
 320     CommonAPI::SerializableVariant* genericVariant = &myVariant;
 321
 322     genericVariant->writeToTypeOutputStream(typeStream_);
 323
 324     std::string signature = typeStream_.retrieveSignature();
 325     ASSERT_TRUE(signature.compare("(qs(yv))") == 0);
 326 }
 327
 328
 329 int main(int argc, char** argv) {
 330     ::testing::InitGoogleTest(&argc, argv);
 331     return RUN_ALL_TESTS();
 332 }