src/test/DBusVariantTest.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/SerializableVariant.h>
  10
  11 using namespace CommonAPI;
  12
  13 class VariantTest: public ::testing::Test {
  14
  15   protected:
  16     typedef Variant<int, double, std::string> BasicVariantType;
  17
  18     void SetUp() {
  19         fromInt = 5;
  20         fromDouble = 12.344d;
  21         fromString = "123abcsadfaljkawlöfasklöerklöfjasklfjysklfjaskfjsklösdfdko4jdfasdjioögjopefgip3rtgjiprg!";
  22     }
  23
  24     void TearDown() {
  25     }
  26
  27     int fromInt;
  28     double fromDouble;
  29     std::string fromString;
  30 };
  31
  32 TEST_F(VariantTest, HandlesInts) {
  33     BasicVariantType myVariant(fromInt);
  34
  35     EXPECT_TRUE(myVariant.isType<int>());
  36     EXPECT_FALSE(myVariant.isType<double>());
  37     EXPECT_FALSE(myVariant.isType<std::string>());
  38
  39     const int myInt = myVariant.get<int>();
  40     EXPECT_EQ(myInt, fromInt);
  41
  42     EXPECT_ANY_THROW(myVariant.get<double>());
  43     EXPECT_ANY_THROW(myVariant.get<std::string>());
  44 }
  45
  46 TEST_F(VariantTest, HandlesDoubles) {
  47     BasicVariantType myVariant(fromDouble);
  48
  49     EXPECT_FALSE(myVariant.isType<int>());
  50     EXPECT_TRUE(myVariant.isType<double>());
  51     EXPECT_FALSE(myVariant.isType<std::string>());
  52
  53     EXPECT_ANY_THROW(myVariant.get<int>());
  54
  55     const double myDouble = myVariant.get<double>();
  56     EXPECT_EQ(myDouble, fromDouble);
  57
  58     EXPECT_ANY_THROW(myVariant.get<std::string>());
  59 }
  60
  61 TEST_F(VariantTest, HandlesStrings) {
  62     BasicVariantType myVariant(fromString);
  63
  64     EXPECT_FALSE(myVariant.isType<int>());
  65     EXPECT_FALSE(myVariant.isType<double>());
  66     EXPECT_TRUE(myVariant.isType<std::string>());
  67
  68     EXPECT_ANY_THROW(myVariant.get<int>());
  69     EXPECT_ANY_THROW(myVariant.get<double>());
  70
  71     const std::string myString = myVariant.get<std::string>();
  72     EXPECT_EQ(myString, fromString);
  73 }
  74
  75 TEST_F(VariantTest, HandlesStringVectors) {
  76     typedef Variant<int, double, std::vector<std::string>> VectorVariantType;
  77
  78     std::vector<std::string> testVector;
  79     for(int i = 0; i < 10; i++) {
  80         testVector.push_back(fromString);
  81     }
  82
  83     VectorVariantType vectorVariant(testVector);
  84     const std::vector<std::string> resultVector = vectorVariant.get<std::vector<std::string>>();
  85     EXPECT_EQ(resultVector, testVector);
  86 }
  87
  88 TEST_F(VariantTest, HandlesAssignment) {
  89     Variant<int, double, std::string> myVariant = fromInt;
  90
  91     myVariant = fromString;
  92
  93     EXPECT_FALSE(myVariant.isType<int>());
  94     EXPECT_FALSE(myVariant.isType<double>());
  95     EXPECT_TRUE(myVariant.isType<std::string>());
  96
  97     EXPECT_ANY_THROW(myVariant.get<int>());
  98
  99     const std::string myString = myVariant.get<std::string>();
 100     EXPECT_EQ(myString, fromString);
 101 }
 102
 103 TEST_F(VariantTest, HandlesVariantConstructionByAssignment) {
 104     Variant<int, double, std::string> myVariant = fromInt;
 105
 106     EXPECT_TRUE(myVariant.isType<int>());
 107     EXPECT_FALSE(myVariant.isType<double>());
 108     EXPECT_FALSE(myVariant.isType<std::string>());
 109
 110     const int myInt = myVariant.get<int>();
 111     EXPECT_EQ(myInt, fromInt);
 112 }
 113
 114 TEST_F(VariantTest, HandlesVariantCopy) {
 115     BasicVariantType myVariant(fromInt);
 116     Variant<int, double, std::string> myVariantAssigned = myVariant;
 117
 118     EXPECT_TRUE(myVariantAssigned.isType<int>());
 119     EXPECT_FALSE(myVariantAssigned.isType<double>());
 120     EXPECT_FALSE(myVariantAssigned.isType<std::string>());
 121
 122     const int myInt2 = myVariantAssigned.get<int>();
 123     EXPECT_EQ(myInt2, fromInt);
 124
 125     Variant<int, double, std::string> myVariantCopied(myVariant);
 126     EXPECT_EQ(myVariant, myVariantCopied);
 127
 128     EXPECT_TRUE(myVariantCopied.isType<int>());
 129     EXPECT_FALSE(myVariantCopied.isType<double>());
 130     EXPECT_FALSE(myVariantCopied.isType<std::string>());
 131
 132     const int& myIntCopy = myVariantCopied.get<int>();
 133     EXPECT_EQ(myIntCopy, fromInt);
 134 }
 135
 136 TEST_F(VariantTest, HandlesVariantsWithinVariants) {
 137     typedef Variant<int, double, BasicVariantType > VariantInVariantType;
 138     BasicVariantType fromInnerVariant(fromInt);
 139     VariantInVariantType myOuterVariant(fromInnerVariant);
 140
 141     EXPECT_FALSE(myOuterVariant.isType<int>());
 142     EXPECT_FALSE(myOuterVariant.isType<double>());
 143     EXPECT_TRUE(myOuterVariant.isType<BasicVariantType>());
 144
 145     EXPECT_ANY_THROW(myOuterVariant.get<int>());
 146     EXPECT_ANY_THROW(myOuterVariant.get<double>());
 147
 148     const BasicVariantType myInnerVariant = myOuterVariant.get<BasicVariantType>();
 149     EXPECT_EQ(fromInnerVariant, myInnerVariant);
 150 }
 151
 152
 153 TEST_F(VariantTest, VariantStringArray) {
 154
 155     std::vector<std::string> testVector;
 156     testVector.push_back("Test 1");
 157     testVector.push_back("Test 2");
 158     testVector.push_back("Test 3");
 159     testVector.push_back("Test 4");
 160
 161     CommonAPI::Variant<int, double, std::vector<std::string>>* vectorVariant = new CommonAPI::Variant<int, double, std::vector<std::string>>(testVector);
 162
 163     std::vector<std::string> readVector = vectorVariant->get<std::vector<std::string> >();
 164     EXPECT_EQ(readVector, testVector);
 165
 166     delete vectorVariant;
 167 }
 168
 169 int main(int argc, char** argv) {
 170     ::testing::InitGoogleTest(&argc, argv);
 171     return RUN_ALL_TESTS();
 172 }