From: Philip Rauwolf Date: Wed, 16 Jan 2013 17:23:50 +0000 (+0100) Subject: Tests for integration of variants to inputStream (basic types working X-Git-Tag: genivi_release_2~22 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=7d6547855fd5ccd962307d6dd0783c4d221942e7;p=profile%2Fivi%2Fcommon-api-dbus-runtime.git Tests for integration of variants to inputStream (basic types working by now), added DBusTestUtils.h (for libdbusmessage byte parsing) --- diff --git a/src/CommonAPI/DBus/DBusInputStream.h b/src/CommonAPI/DBus/DBusInputStream.h index cdb22ff..407ae56 100644 --- a/src/CommonAPI/DBus/DBusInputStream.h +++ b/src/CommonAPI/DBus/DBusInputStream.h @@ -194,9 +194,10 @@ class DBusInputStream: public InputStream { } inline void skipOverSignature() { - uint8_t length; - readValue(length); - assert(length < 256); + uint8_t signatureLength; + readValue(signatureLength); + assert(signatureLength < 256); + readRawData(signatureLength); } char* dataBegin_; diff --git a/src/test/DBusInputStreamTest.cpp b/src/test/DBusInputStreamTest.cpp index 7e997ff..83e547c 100644 --- a/src/test/DBusInputStreamTest.cpp +++ b/src/test/DBusInputStreamTest.cpp @@ -9,6 +9,8 @@ #include #include +#include "DBusTestUtils.h" + #include #include @@ -380,14 +382,16 @@ TEST_F(InputStreamTest, ReadsArraysInArrays) { } } -TEST_F(InputStreamTest, ReadsBasicVariants) { +TEST_F(InputStreamTest, ReadsInt32Variants) { + typedef CommonAPI::Variant TestedVariantType; + int32_t fromInt = 5; - int8_t varIndex = 3; + int8_t variantTypeIndex = 3; for (int i = 0; i < numOfElements; i += 1) { DBusMessageIter subIter; dbus_message_iter_open_container(&libdbusMessageWriteIter, DBUS_TYPE_STRUCT, NULL, &subIter); - dbus_message_iter_append_basic(&subIter, DBUS_TYPE_BYTE, &varIndex); + dbus_message_iter_append_basic(&subIter, DBUS_TYPE_BYTE, &variantTypeIndex); DBusMessageIter subSubIter; dbus_message_iter_open_container(&subIter, DBUS_TYPE_VARIANT, "i", &subSubIter); dbus_message_iter_append_basic(&subSubIter, DBUS_TYPE_INT32, &fromInt); @@ -398,15 +402,11 @@ TEST_F(InputStreamTest, ReadsBasicVariants) { CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage); CommonAPI::DBus::DBusInputStream inStream(scopedMessage); - CommonAPI::Variant referenceVariant(fromInt); - - bool success; - int32_t referenceResult = referenceVariant.get(success); - EXPECT_TRUE(success); + TestedVariantType referenceVariant(fromInt); EXPECT_EQ(numOfElements*4 + numOfElements*4, scopedMessage.getBodyLength()); for (int i = 0; i < numOfElements; i += 1) { - CommonAPI::Variant readVariant; + TestedVariantType readVariant; inStream >> readVariant; bool readSuccess; @@ -415,18 +415,20 @@ TEST_F(InputStreamTest, ReadsBasicVariants) { bool varEq = (referenceVariant == readVariant); EXPECT_TRUE(varEq); - EXPECT_EQ(referenceResult, actualResult); + EXPECT_EQ(fromInt, actualResult); } } TEST_F(InputStreamTest, ReadsStringVariants) { + typedef CommonAPI::Variant TestedVariantType; + std::string fromString = "Hello World with CommonAPI Variants!"; - int8_t varIndex = 1; + int8_t variantTypeIndex = 1; for (int i = 0; i < numOfElements; i += 1) { DBusMessageIter subIter; dbus_message_iter_open_container(&libdbusMessageWriteIter, DBUS_TYPE_STRUCT, NULL, &subIter); - dbus_message_iter_append_basic(&subIter, DBUS_TYPE_BYTE, &varIndex); + dbus_message_iter_append_basic(&subIter, DBUS_TYPE_BYTE, &variantTypeIndex); DBusMessageIter subSubIter; dbus_message_iter_open_container(&subIter, DBUS_TYPE_VARIANT, "s", &subSubIter); dbus_message_iter_append_basic(&subSubIter, DBUS_TYPE_STRING, &fromString); @@ -437,17 +439,13 @@ TEST_F(InputStreamTest, ReadsStringVariants) { CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage); CommonAPI::DBus::DBusInputStream inStream(scopedMessage); - CommonAPI::Variant referenceVariant(fromString); - - bool success; - std::string referenceResult = referenceVariant.get(success); - EXPECT_TRUE(success); + TestedVariantType referenceVariant(fromString); - //Variant: type-index(1) + padding(3) + stringLength(4) + string(37) = 45 + //Variant: type-index(1) + signature(2) + padding(1) + stringLength(4) + string(37) = 45 // +struct-padding inbetween (alignment 8) EXPECT_EQ(numOfElements * (1+3+4+fromString.length()+1) + (numOfElements - 1) * (8-((fromString.length()+1)%8)) , scopedMessage.getBodyLength()); for (int i = 0; i < numOfElements; i += 1) { - CommonAPI::Variant readVariant; + TestedVariantType readVariant; inStream >> readVariant; bool readSuccess; @@ -456,7 +454,61 @@ TEST_F(InputStreamTest, ReadsStringVariants) { bool variantsAreEqual = (referenceVariant == readVariant); EXPECT_TRUE(variantsAreEqual); - EXPECT_EQ(referenceResult, actualResult); + EXPECT_EQ(fromString, actualResult); + } +} + +TEST_F(InputStreamTest, ReadsVariantsWithAnArrayOfStrings) { + typedef CommonAPI::Variant> TestedVariantType; + + std::string testString1 = "Hello World with CommonAPI Variants!"; + std::string testString2 = "What a beautiful world if there are working Arrays within Variants!!"; + int8_t variantTypeIndex = 1; + + std::vector testInnerVector; + + for (int i = 0; i < numOfElements; i += 2) { + testInnerVector.push_back(testString1); + testInnerVector.push_back(testString2); + } + + for (int i = 0; i < numOfElements; i += 1) { + DBusMessageIter subIter; + dbus_message_iter_open_container(&libdbusMessageWriteIter, DBUS_TYPE_STRUCT, NULL, &subIter); + dbus_message_iter_append_basic(&subIter, DBUS_TYPE_BYTE, &variantTypeIndex); + DBusMessageIter subSubIter; + dbus_message_iter_open_container(&subIter, DBUS_TYPE_VARIANT, "as", &subSubIter); + + DBusMessageIter innerArrayIter; + dbus_message_iter_open_container(&subSubIter, DBUS_TYPE_ARRAY, "s", &innerArrayIter); + for (int i = 0; i < numOfElements; i++) { + dbus_message_iter_append_basic(&innerArrayIter, DBUS_TYPE_STRING, &testInnerVector[i]); + } + dbus_message_iter_close_container(&subSubIter, &innerArrayIter); + + dbus_message_iter_close_container(&subIter, &subSubIter); + dbus_message_iter_close_container(&libdbusMessageWriteIter, &subIter); + } + + CommonAPI::DBus::DBusMessage scopedMessage(libdbusMessage); + CommonAPI::DBus::DBusInputStream inStream(scopedMessage); + + TestedVariantType referenceVariant(testInnerVector); + + //Variant: structAlign + type-index(1) + variantSignature(4) + padding(3) + arrayLength(4) + stringLength(4) + + // string(37) + padding(3) + stringLength(4) + string(69) = 129 + EXPECT_EQ(129 + 7 + 129, scopedMessage.getBodyLength()); + for (int i = 0; i < numOfElements; i += 1) { + TestedVariantType readVariant; + inStream >> readVariant; + + bool readSuccess; + std::vector actualResult = readVariant.get>(readSuccess); + EXPECT_TRUE(readSuccess); + + bool variantsAreEqual = (referenceVariant == readVariant); + EXPECT_TRUE(variantsAreEqual); + EXPECT_EQ(testInnerVector, actualResult); } } diff --git a/src/test/DBusTestUtils.h b/src/test/DBusTestUtils.h new file mode 100644 index 0000000..f481988 --- /dev/null +++ b/src/test/DBusTestUtils.h @@ -0,0 +1,24 @@ +/* Copyright (C) 2013 BMW Group + * Author: Manfred Bathelt (manfred.bathelt@bmw.de) + * Author: Juergen Gehring (juergen.gehring@bmw.de) + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include + + +inline char eliminateZeroes(char val) { + return !val ? '0' : val; +} + +inline void printLibdbusMessage(DBusMessage* libdbusMessage, uint32_t fromByteIndex, uint32_t toByteIndex) { + char* data = dbus_message_get_body(libdbusMessage); + for(int i = fromByteIndex; i < toByteIndex; i++) { + std::cout << eliminateZeroes(data[i]); + if(i%8 == 7) { + std::cout << std::endl; + } + } + std::cout << std::endl; +} diff --git a/src/test/DBusVariantTest.cpp b/src/test/DBusVariantTest.cpp index 4ba6981..07e6f8a 100644 --- a/src/test/DBusVariantTest.cpp +++ b/src/test/DBusVariantTest.cpp @@ -92,6 +92,14 @@ TEST_F(VariantTest, VariantTestPack) { std::cout << "myStringCopy = " << myStringCopy << " (" << std::boolalpha << success << ")\n"; EXPECT_TRUE(success); + std::vector testVector; + testVector.push_back(fromString); + CommonAPI::Variant> vectorVariant(testVector); + std::vector resultVector = vectorVariant.get>(success); + std::cout << "myVectorVariant read successfully= " << std::boolalpha << success << "\n"; + EXPECT_TRUE(success); + EXPECT_EQ(resultVector, testVector); + delete myVariants; }