From 51daac71ae012c925bf67dcda3192e04f76f76da Mon Sep 17 00:00:00 2001 From: Philip Rauwolf Date: Fri, 22 Mar 2013 09:56:23 +0100 Subject: Updated test files --- src/test/commonapi/tests/DerivedTypeCollection.cpp | 10 +- src/test/commonapi/tests/DerivedTypeCollection.h | 50 ++++---- .../commonapi/tests/PredefinedTypeCollection.h | 61 ++-------- .../commonapi/tests/TestInterfaceDBusProxy.cpp | 19 ++- src/test/commonapi/tests/TestInterfaceDBusProxy.h | 12 +- .../tests/TestInterfaceDBusStubAdapter.cpp | 27 +++-- .../commonapi/tests/TestInterfaceDBusStubAdapter.h | 2 +- src/test/commonapi/tests/TestInterfaceProxy.h | 132 +++++++++++++++++++++ src/test/commonapi/tests/TestInterfaceProxyBase.h | 7 +- src/test/commonapi/tests/TestInterfaceStub.h | 50 +++++++- .../commonapi/tests/TestInterfaceStubDefault.cpp | 59 +++++---- .../commonapi/tests/TestInterfaceStubDefault.h | 15 ++- src/test/test-derived-types.fidl | 116 +++++++++--------- src/test/test-interface-proxy.fidl | 119 ++++++++++--------- src/test/test-predefined-types.fidl | 44 +++---- 15 files changed, 456 insertions(+), 267 deletions(-) diff --git a/src/test/commonapi/tests/DerivedTypeCollection.cpp b/src/test/commonapi/tests/DerivedTypeCollection.cpp index 1ad1cce..14b083e 100644 --- a/src/test/commonapi/tests/DerivedTypeCollection.cpp +++ b/src/test/commonapi/tests/DerivedTypeCollection.cpp @@ -7,10 +7,9 @@ namespace commonapi { namespace tests { namespace DerivedTypeCollection { -TestStructExtended::TestStructExtended(const PredefinedTypeCollection::TestString& testStringValue, const uint16_t& uintValueValue, const TestEnumExtended2& testEnumExtended2Value, const PredefinedTypeCollection::WeirdStrangeAlienEnum& alienEnumValue): +TestStructExtended::TestStructExtended(const PredefinedTypeCollection::TestString& testStringValue, const uint16_t& uintValueValue, const TestEnumExtended2& testEnumExtended2Value): TestStruct(testStringValue, uintValueValue), - testEnumExtended2(testEnumExtended2Value), - alienEnum(alienEnumValue) + testEnumExtended2(testEnumExtended2Value) { } @@ -20,21 +19,18 @@ bool operator==(const TestStructExtended& lhs, const TestStructExtended& rhs) { return static_cast(lhs) == static_cast(rhs) && - lhs.testEnumExtended2 == rhs.testEnumExtended2 && - lhs.alienEnum == rhs.alienEnum + lhs.testEnumExtended2 == rhs.testEnumExtended2 ; } void TestStructExtended::readFromInputStream(CommonAPI::InputStream& inputStream) { TestStruct::readFromInputStream(inputStream); inputStream >> testEnumExtended2; - inputStream >> alienEnum; } void TestStructExtended::writeToOutputStream(CommonAPI::OutputStream& outputStream) const { TestStruct::writeToOutputStream(outputStream); outputStream << testEnumExtended2; - outputStream << alienEnum; } TestStruct::TestStruct(const PredefinedTypeCollection::TestString& testStringValue, const uint16_t& uintValueValue): testString(testStringValue), diff --git a/src/test/commonapi/tests/DerivedTypeCollection.h b/src/test/commonapi/tests/DerivedTypeCollection.h index b1cd43f..26409d6 100644 --- a/src/test/commonapi/tests/DerivedTypeCollection.h +++ b/src/test/commonapi/tests/DerivedTypeCollection.h @@ -8,7 +8,7 @@ #include #include #include -#include "PredefinedTypeCollection.h" +#include #include #include #include @@ -18,6 +18,26 @@ namespace commonapi { namespace tests { namespace DerivedTypeCollection { + struct TestStruct: CommonAPI::SerializableStruct { + PredefinedTypeCollection::TestString testString; + uint16_t uintValue; + + TestStruct() = default; + TestStruct(const PredefinedTypeCollection::TestString& testString, const uint16_t& uintValue); + + virtual void readFromInputStream(CommonAPI::InputStream& inputStream); + virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; + + static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { + typeOutputStream.writeStringType(); + typeOutputStream.writeUInt16Type(); + } + }; + + typedef std::vector TestArrayTestStruct; + + typedef std::unordered_map TestMap; + enum class TestEnum: int32_t { E_UNKNOWN = 0, E_OK = 1, @@ -27,6 +47,7 @@ namespace DerivedTypeCollection { // XXX Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 struct TestEnumComparator; + enum class TestEnumExtended: int32_t { E_UNKNOWN = TestEnum::E_UNKNOWN, E_OK = TestEnum::E_OK, @@ -38,23 +59,7 @@ namespace DerivedTypeCollection { // XXX Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 struct TestEnumExtendedComparator; - typedef std::unordered_map TestEnumMap; - struct TestStruct: CommonAPI::SerializableStruct { - PredefinedTypeCollection::TestString testString; - uint16_t uintValue; - - TestStruct() = default; - TestStruct(const PredefinedTypeCollection::TestString& testString, const uint16_t& uintValue); - virtual void readFromInputStream(CommonAPI::InputStream& inputStream); - virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; - - static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { - typeOutputStream.writeStringType(); - typeOutputStream.writeUInt16Type(); - } - }; - typedef std::vector TestArrayTestStruct; enum class TestEnumExtended2: int32_t { E_UNKNOWN = TestEnum::E_UNKNOWN, E_OK = TestEnum::E_OK, @@ -68,12 +73,12 @@ namespace DerivedTypeCollection { // XXX Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 struct TestEnumExtended2Comparator; + struct TestStructExtended: TestStruct { TestEnumExtended2 testEnumExtended2; - PredefinedTypeCollection::WeirdStrangeAlienEnum alienEnum; TestStructExtended() = default; - TestStructExtended(const PredefinedTypeCollection::TestString& testString, const uint16_t& uintValue, const TestEnumExtended2& testEnumExtended2, const PredefinedTypeCollection::WeirdStrangeAlienEnum& alienEnum); + TestStructExtended(const PredefinedTypeCollection::TestString& testString, const uint16_t& uintValue, const TestEnumExtended2& testEnumExtended2); virtual void readFromInputStream(CommonAPI::InputStream& inputStream); virtual void writeToOutputStream(CommonAPI::OutputStream& outputStream) const; @@ -81,10 +86,11 @@ namespace DerivedTypeCollection { static inline void writeToTypeOutputStream(CommonAPI::TypeOutputStream& typeOutputStream) { TestStruct::writeToTypeOutputStream(typeOutputStream); typeOutputStream.writeInt32Type(); - typeOutputStream.writeInt32Type(); } }; - typedef std::unordered_map TestMap; + + typedef std::unordered_map TestEnumMap; + enum class TestEnumMissingValue: int32_t { E1 = 10, E2, @@ -93,7 +99,9 @@ namespace DerivedTypeCollection { // XXX Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 struct TestEnumMissingValueComparator; + typedef std::vector TestArrayUInt64; + bool operator==(const TestStructExtended& lhs, const TestStructExtended& rhs); inline bool operator!=(const TestStructExtended& lhs, const TestStructExtended& rhs) { diff --git a/src/test/commonapi/tests/PredefinedTypeCollection.h b/src/test/commonapi/tests/PredefinedTypeCollection.h index ee9c1ec..f1d3cc2 100644 --- a/src/test/commonapi/tests/PredefinedTypeCollection.h +++ b/src/test/commonapi/tests/PredefinedTypeCollection.h @@ -5,8 +5,6 @@ #define COMMONAPI_TESTS_PREDEFINED_TYPE_COLLECTION_H_ #include -#include -#include #include #include #include @@ -16,40 +14,31 @@ namespace tests { namespace PredefinedTypeCollection { typedef uint8_t TestUInt8; + typedef uint16_t TestUInt16; + typedef uint32_t TestUInt32; + typedef uint64_t TestUInt64; + typedef int8_t TestInt8; + typedef int16_t TestInt16; + typedef int32_t TestInt32; + typedef int64_t TestInt64; + typedef bool TestBoolean; + typedef CommonAPI::ByteBuffer TestByteBuffer; + typedef double TestDouble; + typedef float TestFloat; + typedef std::string TestString; - enum class WeirdStrangeAlienEnum: int32_t { - WEIRD, - STRANGE, - ALIEN - }; - // XXX Definition of a comparator still is necessary for GCC 4.4.1, topic is fixed since 4.5.1 - struct WeirdStrangeAlienEnumComparator; - -inline CommonAPI::InputStream& operator>>(CommonAPI::InputStream& inputStream, WeirdStrangeAlienEnum& enumValue) { - return inputStream.readEnumValue(enumValue); -} - -inline CommonAPI::OutputStream& operator<<(CommonAPI::OutputStream& outputStream, const WeirdStrangeAlienEnum& enumValue) { - return outputStream.writeEnumValue(static_cast(enumValue)); -} - -struct WeirdStrangeAlienEnumComparator { - inline bool operator()(const WeirdStrangeAlienEnum& lhs, const WeirdStrangeAlienEnum& rhs) const { - return static_cast(lhs) < static_cast(rhs); - } -}; @@ -65,37 +54,11 @@ static inline const char* getTypeCollectionName() { namespace CommonAPI { - template<> - struct BasicTypeWriter { - inline static void writeType (CommonAPI::TypeOutputStream& typeStream) { - typeStream.writeInt32EnumType(); - } - }; - - template<> - struct InputStreamVectorHelper { - static void beginReadVector(InputStream& inputStream, const std::vector& vectorValue) { - inputStream.beginReadInt32EnumVector(); - } - }; - - template <> - struct OutputStreamVectorHelper { - static void beginWriteVector(OutputStream& outputStream, const std::vector& vectorValue) { - outputStream.beginWriteInt32EnumVector(vectorValue.size()); - } - }; } namespace std { - template<> - struct hash { - inline size_t operator()(const commonapi::tests::PredefinedTypeCollection::WeirdStrangeAlienEnum& weirdStrangeAlienEnum) const { - return static_cast(weirdStrangeAlienEnum); - } - }; } #endif // COMMONAPI_TESTS_PREDEFINED_TYPE_COLLECTION_H_ diff --git a/src/test/commonapi/tests/TestInterfaceDBusProxy.cpp b/src/test/commonapi/tests/TestInterfaceDBusProxy.cpp index 34981e0..f5460d1 100644 --- a/src/test/commonapi/tests/TestInterfaceDBusProxy.cpp +++ b/src/test/commonapi/tests/TestInterfaceDBusProxy.cpp @@ -28,7 +28,7 @@ TestInterfaceDBusProxy::TestInterfaceDBusProxy( const std::shared_ptr& dbusProxyconnection): CommonAPI::DBus::DBusProxy(commonApiAddress, interfaceName, busName, objectPath, dbusProxyconnection) , testPredefinedTypeAttribute_(*this, "onTestPredefinedTypeAttributeAttributeChanged", "setTestPredefinedTypeAttributeAttribute", "u", "getTestPredefinedTypeAttributeAttribute"), - testDerivedStructAttribute_(*this, "onTestDerivedStructAttributeAttributeChanged", "setTestDerivedStructAttributeAttribute", "(sqii)", "getTestDerivedStructAttributeAttribute"), + testDerivedStructAttribute_(*this, "onTestDerivedStructAttributeAttributeChanged", "setTestDerivedStructAttributeAttribute", "(sqi)", "getTestDerivedStructAttributeAttribute"), testDerivedArrayAttribute_(*this, "onTestDerivedArrayAttributeAttributeChanged", "setTestDerivedArrayAttributeAttribute", "at", "getTestDerivedArrayAttributeAttribute") , testPredefinedTypeBroadcast_(*this, "TestPredefinedTypeBroadcast", "us") { @@ -48,6 +48,23 @@ TestInterfaceDBusProxy::TestPredefinedTypeBroadcastEvent& TestInterfaceDBusProxy return testPredefinedTypeBroadcast_; } +void TestInterfaceDBusProxy::testEmptyMethod(CommonAPI::CallStatus& callStatus) { + CommonAPI::DBus::DBusProxyHelper, + CommonAPI::DBus::DBusSerializableArguments<> >::callMethodWithReply( + *this, + "testEmptyMethod", + "", + callStatus + ); +} +std::future TestInterfaceDBusProxy::testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback) { + return CommonAPI::DBus::DBusProxyHelper, + CommonAPI::DBus::DBusSerializableArguments<> >::callMethodAsync( + *this, + "testEmptyMethod", + "", + std::move(callback)); +} void TestInterfaceDBusProxy::testVoidPredefinedTypeMethod(const uint32_t& uint32Value, const std::string& stringValue, CommonAPI::CallStatus& callStatus) { CommonAPI::DBus::DBusProxyHelper, CommonAPI::DBus::DBusSerializableArguments<> >::callMethodWithReply( diff --git a/src/test/commonapi/tests/TestInterfaceDBusProxy.h b/src/test/commonapi/tests/TestInterfaceDBusProxy.h index cf3fd76..1ec27be 100644 --- a/src/test/commonapi/tests/TestInterfaceDBusProxy.h +++ b/src/test/commonapi/tests/TestInterfaceDBusProxy.h @@ -4,7 +4,7 @@ #ifndef COMMONAPI_TESTS_TEST_INTERFACE_DBUS_PROXY_H_ #define COMMONAPI_TESTS_TEST_INTERFACE_DBUS_PROXY_H_ -#include "TestInterfaceProxyBase.h" +#include #include #include #include @@ -24,7 +24,7 @@ class TestInterfaceDBusProxy: virtual public TestInterfaceProxyBase, virtual pub const std::string& objectPath, const std::shared_ptr& dbusProxyconnection); - virtual ~TestInterfaceDBusProxy() { } + virtual ~TestInterfaceDBusProxy() {} virtual TestPredefinedTypeAttributeAttribute& getTestPredefinedTypeAttributeAttribute(); virtual TestDerivedStructAttributeAttribute& getTestDerivedStructAttributeAttribute(); @@ -32,19 +32,17 @@ class TestInterfaceDBusProxy: virtual public TestInterfaceProxyBase, virtual pub virtual TestPredefinedTypeBroadcastEvent& getTestPredefinedTypeBroadcastEvent(); - + virtual void testEmptyMethod(CommonAPI::CallStatus& callStatus); + virtual std::future testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback); virtual void testVoidPredefinedTypeMethod(const uint32_t& uint32Value, const std::string& stringValue, CommonAPI::CallStatus& callStatus); virtual std::future testVoidPredefinedTypeMethodAsync(const uint32_t& uint32Value, const std::string& stringValue, TestVoidPredefinedTypeMethodAsyncCallback callback); - virtual void testPredefinedTypeMethod(const uint32_t& uint32InValue, const std::string& stringInValue, CommonAPI::CallStatus& callStatus, uint32_t& uint32OutValue, std::string& stringOutValue); virtual std::future testPredefinedTypeMethodAsync(const uint32_t& uint32InValue, const std::string& stringInValue, TestPredefinedTypeMethodAsyncCallback callback); - virtual void testVoidDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, CommonAPI::CallStatus& callStatus); virtual std::future testVoidDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, TestVoidDerivedTypeMethodAsyncCallback callback); - virtual void testDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, CommonAPI::CallStatus& callStatus, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue); virtual std::future testDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, TestDerivedTypeMethodAsyncCallback callback); - + virtual void getOwnVersion(uint16_t& ownVersionMajor, uint16_t& ownVersionMinor) const; private: diff --git a/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.cpp b/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.cpp index 869560e..9145d2c 100644 --- a/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.cpp +++ b/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.cpp @@ -2,7 +2,7 @@ * 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 "TestInterfaceDBusStubAdapter.h" -#include "TestInterface.h" +#include namespace commonapi { namespace tests { @@ -45,14 +45,14 @@ const char* TestInterfaceDBusStubAdapter::getMethodsDBusIntrospectionXmlData() c "\n" "\n" "\n" - "" + "" "\n" "\n" - "\n" - "\n" + "\n" + "\n" "\n" "\n" - "\n" + "\n" "\n" "\n" "" @@ -68,6 +68,8 @@ const char* TestInterfaceDBusStubAdapter::getMethodsDBusIntrospectionXmlData() c "\n" "\n" "\n" + "\n" + "\n" "\n" "\n" "\n" @@ -109,7 +111,7 @@ static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher< static CommonAPI::DBus::DBusGetAttributeStubDispatcher< TestInterfaceStub, DerivedTypeCollection::TestStructExtended - > getTestDerivedStructAttributeAttributeStubDispatcher(&TestInterfaceStub::getTestDerivedStructAttributeAttribute, "(sqii)"); + > getTestDerivedStructAttributeAttributeStubDispatcher(&TestInterfaceStub::getTestDerivedStructAttributeAttribute, "(sqi)"); static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher< TestInterfaceStub, DerivedTypeCollection::TestStructExtended @@ -118,7 +120,7 @@ static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher< &TestInterfaceStubRemoteEvent::onRemoteSetTestDerivedStructAttributeAttribute, &TestInterfaceStubRemoteEvent::onRemoteTestDerivedStructAttributeAttributeChanged, &TestInterfaceStubAdapter::fireTestDerivedStructAttributeAttributeChanged, - "(sqii)"); + "(sqi)"); static CommonAPI::DBus::DBusGetAttributeStubDispatcher< TestInterfaceStub, @@ -135,6 +137,12 @@ static CommonAPI::DBus::DBusSetObservableAttributeStubDispatcher< "at"); +static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< + TestInterfaceStub, + std::tuple<>, + std::tuple<> + > testEmptyMethodStubDispatcher(&TestInterfaceStub::testEmptyMethod, ""); + static CommonAPI::DBus::DBusMethodWithReplyStubDispatcher< TestInterfaceStub, std::tuple, @@ -165,10 +173,11 @@ const TestInterfaceDBusStubAdapterHelper::StubDispatcherTable TestInterfaceDBusS { { "getTestPredefinedTypeAttributeAttribute", "" }, &commonapi::tests::getTestPredefinedTypeAttributeAttributeStubDispatcher } , { { "setTestPredefinedTypeAttributeAttribute", "u" }, &commonapi::tests::setTestPredefinedTypeAttributeAttributeStubDispatcher }, { { "getTestDerivedStructAttributeAttribute", "" }, &commonapi::tests::getTestDerivedStructAttributeAttributeStubDispatcher } - , { { "setTestDerivedStructAttributeAttribute", "(sqii)" }, &commonapi::tests::setTestDerivedStructAttributeAttributeStubDispatcher }, + , { { "setTestDerivedStructAttributeAttribute", "(sqi)" }, &commonapi::tests::setTestDerivedStructAttributeAttributeStubDispatcher }, { { "getTestDerivedArrayAttributeAttribute", "" }, &commonapi::tests::getTestDerivedArrayAttributeAttributeStubDispatcher } , { { "setTestDerivedArrayAttributeAttribute", "at" }, &commonapi::tests::setTestDerivedArrayAttributeAttributeStubDispatcher } , + { { "testEmptyMethod", "" }, &commonapi::tests::testEmptyMethodStubDispatcher }, { { "testVoidPredefinedTypeMethod", "us" }, &commonapi::tests::testVoidPredefinedTypeMethodStubDispatcher }, { { "testPredefinedTypeMethod", "us" }, &commonapi::tests::testPredefinedTypeMethodStubDispatcher }, { { "testVoidDerivedTypeMethod", "ia{ua(sq)}" }, &commonapi::tests::testVoidDerivedTypeMethodStubDispatcher }, @@ -189,7 +198,7 @@ void TestInterfaceDBusStubAdapter::fireTestDerivedStructAttributeAttributeChange ::sendSignal( *this, "onTestDerivedStructAttributeAttributeChanged", - "(sqii)", + "(sqi)", value ); } diff --git a/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.h b/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.h index 7a809ad..651a22b 100644 --- a/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.h +++ b/src/test/commonapi/tests/TestInterfaceDBusStubAdapter.h @@ -4,7 +4,7 @@ #ifndef COMMONAPI_TESTS_TEST_INTERFACE_DBUS_STUB_ADAPTER_H_ #define COMMONAPI_TESTS_TEST_INTERFACE_DBUS_STUB_ADAPTER_H_ -#include "TestInterfaceStub.h" +#include #include #include diff --git a/src/test/commonapi/tests/TestInterfaceProxy.h b/src/test/commonapi/tests/TestInterfaceProxy.h index 0e0c54c..7ab5cdc 100644 --- a/src/test/commonapi/tests/TestInterfaceProxy.h +++ b/src/test/commonapi/tests/TestInterfaceProxy.h @@ -17,31 +17,153 @@ class TestInterfaceProxy: virtual public TestInterface, virtual public TestInter TestInterfaceProxy(std::shared_ptr delegate); ~TestInterfaceProxy(); + /// Returns the wrapper class that provides access to the attribute TestPredefinedTypeAttribute. virtual TestPredefinedTypeAttributeAttribute& getTestPredefinedTypeAttributeAttribute(); + /// Returns the wrapper class that provides access to the attribute TestDerivedStructAttribute. virtual TestDerivedStructAttributeAttribute& getTestDerivedStructAttributeAttribute(); + /// Returns the wrapper class that provides access to the attribute TestDerivedArrayAttribute. virtual TestDerivedArrayAttributeAttribute& getTestDerivedArrayAttributeAttribute(); + /// Returns the wrapper class that provides access to the broadcast TestPredefinedTypeBroadcast. virtual TestPredefinedTypeBroadcastEvent& getTestPredefinedTypeBroadcastEvent(); + /** + * Calls testEmptyMethod with synchronous semantics. + * + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used. + */ + virtual void testEmptyMethod(CommonAPI::CallStatus& callStatus); + /** + * Calls testEmptyMethod with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ + virtual std::future testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback); + + /** + * Calls testVoidPredefinedTypeMethod with synchronous semantics. + * + * All const parameters are input parameters to this method. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used. + */ virtual void testVoidPredefinedTypeMethod(const uint32_t& uint32Value, const std::string& stringValue, CommonAPI::CallStatus& callStatus); + /** + * Calls testVoidPredefinedTypeMethod with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ virtual std::future testVoidPredefinedTypeMethodAsync(const uint32_t& uint32Value, const std::string& stringValue, TestVoidPredefinedTypeMethodAsyncCallback callback); + /** + * Calls testPredefinedTypeMethod with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used. + */ virtual void testPredefinedTypeMethod(const uint32_t& uint32InValue, const std::string& stringInValue, CommonAPI::CallStatus& callStatus, uint32_t& uint32OutValue, std::string& stringOutValue); + /** + * Calls testPredefinedTypeMethod with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ virtual std::future testPredefinedTypeMethodAsync(const uint32_t& uint32InValue, const std::string& stringInValue, TestPredefinedTypeMethodAsyncCallback callback); + /** + * Calls testVoidDerivedTypeMethod with synchronous semantics. + * + * All const parameters are input parameters to this method. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used. + */ virtual void testVoidDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, CommonAPI::CallStatus& callStatus); + /** + * Calls testVoidDerivedTypeMethod with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ virtual std::future testVoidDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2Value, const DerivedTypeCollection::TestMap& testMapValue, TestVoidDerivedTypeMethodAsyncCallback callback); + /** + * Calls testDerivedTypeMethod with synchronous semantics. + * + * All const parameters are input parameters to this method. + * All non-const parameters will be filled with the returned values. + * The CallStatus will be filled when the method returns and indicate either + * "SUCCESS" or which type of error has occurred. In case of an error, ONLY the CallStatus + * will be set. + * Synchronous calls are not supported (will block indefinitely) when mainloop integration is used. + */ virtual void testDerivedTypeMethod(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, CommonAPI::CallStatus& callStatus, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue); + /** + * Calls testDerivedTypeMethod with asynchronous semantics. + * + * The provided callback will be called when the reply to this call arrives or + * an error occurs during the call. The CallStatus will indicate either "SUCCESS" + * or which type of error has occurred. In case of any error, ONLY the CallStatus + * will have a defined value. + * The std::future returned by this method will be fulfilled at arrival of the reply. + * It will provide the same value for CallStatus as will be handed to the callback. + */ virtual std::future testDerivedTypeMethodAsync(const DerivedTypeCollection::TestEnumExtended2& testEnumExtended2InValue, const DerivedTypeCollection::TestMap& testMapInValue, TestDerivedTypeMethodAsyncCallback callback); + /// Returns the CommonAPI address of the remote partner this proxy communicates with. virtual std::string getAddress() const; + + /// Returns the domain of the remote partner this proxy communicates with. virtual const std::string& getDomain() const; + + /// Returns the service ID of the remote partner this proxy communicates with. virtual const std::string& getServiceId() const; + + /// Returns the instance ID of the remote partner this proxy communicates with. virtual const std::string& getInstanceId() const; + + /// Returns true if the remote partner for this proxy is available. virtual bool isAvailable() const; + + /** + * Returns the wrapper class that is used to (de-)register for notifications about + * the availability of the remote partner of this proxy. + */ virtual CommonAPI::ProxyStatusEvent& getProxyStatusEvent(); + + /** + * Returns the wrapper class that is used to access version information of the remote + * partner of this proxy. + */ virtual CommonAPI::InterfaceVersionAttribute& getInterfaceVersionAttribute(); private: @@ -143,6 +265,16 @@ typename TestInterfaceProxy<_AttributeExtensions...>::TestPredefinedTypeBroadcas } +template +void TestInterfaceProxy<_AttributeExtensions...>::testEmptyMethod(CommonAPI::CallStatus& callStatus) { + delegate_->testEmptyMethod(callStatus); +} + +template +std::future TestInterfaceProxy<_AttributeExtensions...>::testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback) { + return delegate_->testEmptyMethodAsync(callback); +} + template void TestInterfaceProxy<_AttributeExtensions...>::testVoidPredefinedTypeMethod(const uint32_t& uint32Value, const std::string& stringValue, CommonAPI::CallStatus& callStatus) { delegate_->testVoidPredefinedTypeMethod(uint32Value, stringValue, callStatus); diff --git a/src/test/commonapi/tests/TestInterfaceProxyBase.h b/src/test/commonapi/tests/TestInterfaceProxyBase.h index 4210e25..6ae5263 100644 --- a/src/test/commonapi/tests/TestInterfaceProxyBase.h +++ b/src/test/commonapi/tests/TestInterfaceProxyBase.h @@ -7,8 +7,7 @@ #include "TestInterface.h" #include #include -#include "PredefinedTypeCollection.h" -#include "DerivedTypeCollection.h" +#include #include #include #include @@ -27,6 +26,7 @@ class TestInterfaceProxyBase: virtual public CommonAPI::Proxy { typedef CommonAPI::ObservableAttribute TestDerivedStructAttributeAttribute; typedef CommonAPI::ObservableAttribute TestDerivedArrayAttributeAttribute; typedef CommonAPI::Event TestPredefinedTypeBroadcastEvent; + typedef std::function TestEmptyMethodAsyncCallback; typedef std::function TestVoidPredefinedTypeMethodAsyncCallback; typedef std::function TestPredefinedTypeMethodAsyncCallback; typedef std::function TestVoidDerivedTypeMethodAsyncCallback; @@ -39,6 +39,9 @@ class TestInterfaceProxyBase: virtual public CommonAPI::Proxy { virtual TestPredefinedTypeBroadcastEvent& getTestPredefinedTypeBroadcastEvent() = 0; + virtual void testEmptyMethod(CommonAPI::CallStatus& callStatus) = 0; + virtual std::future testEmptyMethodAsync(TestEmptyMethodAsyncCallback callback) = 0; + virtual void testVoidPredefinedTypeMethod(const uint32_t& uint32Value, const std::string& stringValue, CommonAPI::CallStatus& callStatus) = 0; virtual std::future testVoidPredefinedTypeMethodAsync(const uint32_t& uint32Value, const std::string& stringValue, TestVoidPredefinedTypeMethodAsyncCallback callback) = 0; diff --git a/src/test/commonapi/tests/TestInterfaceStub.h b/src/test/commonapi/tests/TestInterfaceStub.h index ac34f79..6d078ed 100644 --- a/src/test/commonapi/tests/TestInterfaceStub.h +++ b/src/test/commonapi/tests/TestInterfaceStub.h @@ -6,8 +6,7 @@ #include #include -#include "PredefinedTypeCollection.h" -#include "DerivedTypeCollection.h" +#include #include #include #include @@ -17,45 +16,92 @@ namespace commonapi { namespace tests { +/** + * Receives messages from remote and handles all dispatching of deserialized calls + * to a stub for the service TestInterface. Also provides means to send broadcasts + * and attribute-changed-notifications of observable attributes as defined by this service. + * An application developer should not need to bother with this class. + */ class TestInterfaceStubAdapter: virtual public CommonAPI::StubAdapter, public TestInterface { public: + ///Notifies all remote listeners about a change of value of the attribute TestPredefinedTypeAttribute. virtual void fireTestPredefinedTypeAttributeAttributeChanged(const uint32_t& TestPredefinedTypeAttribute) = 0; + ///Notifies all remote listeners about a change of value of the attribute TestDerivedStructAttribute. virtual void fireTestDerivedStructAttributeAttributeChanged(const DerivedTypeCollection::TestStructExtended& TestDerivedStructAttribute) = 0; + ///Notifies all remote listeners about a change of value of the attribute TestDerivedArrayAttribute. virtual void fireTestDerivedArrayAttributeAttributeChanged(const DerivedTypeCollection::TestArrayUInt64& TestDerivedArrayAttribute) = 0; + /** + * Sends a broadcast event for TestPredefinedTypeBroadcast. Should not be called directly. + * Instead, the "fireEvent" methods of the stub should be used. + */ virtual void fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue) = 0; }; +/** + * Defines the necessary callbacks to handle remote set events related to the attributes + * defined in the IDL description for TestInterface. + * For each attribute two callbacks are defined: + * - a verification callback that allows to verify the requested value and to prevent setting + * e.g. an invalid value ("onRemoteSet"). + * - an action callback to do local work after the attribute value has been changed + * ("onRemoteChanged"). + * + * This class and the one below are the ones an application developer needs to have + * a look at if he wants to implement a service. + */ class TestInterfaceStubRemoteEvent { public: virtual ~TestInterfaceStubRemoteEvent() { } + /// Verification callback for remote set requests on the attribute TestPredefinedTypeAttribute. virtual bool onRemoteSetTestPredefinedTypeAttributeAttribute(uint32_t TestPredefinedTypeAttribute) = 0; + /// Action callback for remote set requests on the attribute TestPredefinedTypeAttribute. virtual void onRemoteTestPredefinedTypeAttributeAttributeChanged() = 0; + /// Verification callback for remote set requests on the attribute TestDerivedStructAttribute. virtual bool onRemoteSetTestDerivedStructAttributeAttribute(DerivedTypeCollection::TestStructExtended TestDerivedStructAttribute) = 0; + /// Action callback for remote set requests on the attribute TestDerivedStructAttribute. virtual void onRemoteTestDerivedStructAttributeAttributeChanged() = 0; + /// Verification callback for remote set requests on the attribute TestDerivedArrayAttribute. virtual bool onRemoteSetTestDerivedArrayAttributeAttribute(DerivedTypeCollection::TestArrayUInt64 TestDerivedArrayAttribute) = 0; + /// Action callback for remote set requests on the attribute TestDerivedArrayAttribute. virtual void onRemoteTestDerivedArrayAttributeAttributeChanged() = 0; }; +/** + * Defines the interface that must be implemented by any class that should provide + * the service TestInterface to remote clients. + * This class and the one above are the ones an application developer needs to have + * a look at if he wants to implement a service. + */ class TestInterfaceStub : public CommonAPI::Stub { public: virtual ~TestInterfaceStub() { } + /// Provides getter access to the attribute TestPredefinedTypeAttribute. virtual const uint32_t& getTestPredefinedTypeAttributeAttribute() = 0; + /// Provides getter access to the attribute TestDerivedStructAttribute. virtual const DerivedTypeCollection::TestStructExtended& getTestDerivedStructAttributeAttribute() = 0; + /// Provides getter access to the attribute TestDerivedArrayAttribute. virtual const DerivedTypeCollection::TestArrayUInt64& getTestDerivedArrayAttributeAttribute() = 0; + /// This is the method that will be called on remote calls on the method testEmptyMethod. + virtual void testEmptyMethod() = 0; + /// This is the method that will be called on remote calls on the method testVoidPredefinedTypeMethod. virtual void testVoidPredefinedTypeMethod(uint32_t uint32Value, std::string stringValue) = 0; + /// This is the method that will be called on remote calls on the method testPredefinedTypeMethod. virtual void testPredefinedTypeMethod(uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue) = 0; + /// This is the method that will be called on remote calls on the method testVoidDerivedTypeMethod. virtual void testVoidDerivedTypeMethod(DerivedTypeCollection::TestEnumExtended2 testEnumExtended2Value, DerivedTypeCollection::TestMap testMapValue) = 0; + /// This is the method that will be called on remote calls on the method testDerivedTypeMethod. virtual void testDerivedTypeMethod(DerivedTypeCollection::TestEnumExtended2 testEnumExtended2InValue, DerivedTypeCollection::TestMap testMapInValue, DerivedTypeCollection::TestEnumExtended2& testEnumExtended2OutValue, DerivedTypeCollection::TestMap& testMapOutValue) = 0; + /// Sends a broadcast event for TestPredefinedTypeBroadcast. virtual void fireTestPredefinedTypeBroadcastEvent(const uint32_t& uint32Value, const std::string& stringValue) = 0; }; diff --git a/src/test/commonapi/tests/TestInterfaceStubDefault.cpp b/src/test/commonapi/tests/TestInterfaceStubDefault.cpp index c5e7e35..d852c0c 100644 --- a/src/test/commonapi/tests/TestInterfaceStubDefault.cpp +++ b/src/test/commonapi/tests/TestInterfaceStubDefault.cpp @@ -1,7 +1,7 @@ /* 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 "TestInterfaceStubDefault.h" +#include namespace commonapi { namespace tests { @@ -15,10 +15,6 @@ TestInterfaceStubRemoteEvent* TestInterfaceStubDefault::initStubAdapter(const st return &remoteEventHandler_; } -void TestInterfaceStubDefault::deinitStubAdapter() { - stubAdapter_.reset(); -} - const uint32_t& TestInterfaceStubDefault::getTestPredefinedTypeAttributeAttribute() { return testPredefinedTypeAttributeAttributeValue_; } @@ -46,6 +42,14 @@ bool TestInterfaceStubDefault::validateTestPredefinedTypeAttributeAttributeReque return true; } +bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestPredefinedTypeAttributeAttribute(uint32_t value) { + return defaultStub_->trySetTestPredefinedTypeAttributeAttribute(std::move(value)); +} + +void TestInterfaceStubDefault::RemoteEventHandler::onRemoteTestPredefinedTypeAttributeAttributeChanged() { + defaultStub_->onRemoteTestPredefinedTypeAttributeAttributeChanged(); +} + const DerivedTypeCollection::TestStructExtended& TestInterfaceStubDefault::getTestDerivedStructAttributeAttribute() { return testDerivedStructAttributeAttributeValue_; } @@ -73,6 +77,14 @@ bool TestInterfaceStubDefault::validateTestDerivedStructAttributeAttributeReques return true; } +bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestDerivedStructAttributeAttribute(DerivedTypeCollection::TestStructExtended value) { + return defaultStub_->trySetTestDerivedStructAttributeAttribute(std::move(value)); +} + +void TestInterfaceStubDefault::RemoteEventHandler::onRemoteTestDerivedStructAttributeAttributeChanged() { + defaultStub_->onRemoteTestDerivedStructAttributeAttributeChanged(); +} + const DerivedTypeCollection::TestArrayUInt64& TestInterfaceStubDefault::getTestDerivedArrayAttributeAttribute() { return testDerivedArrayAttributeAttributeValue_; } @@ -100,6 +112,18 @@ bool TestInterfaceStubDefault::validateTestDerivedArrayAttributeAttributeRequest return true; } +bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestDerivedArrayAttributeAttribute(DerivedTypeCollection::TestArrayUInt64 value) { + return defaultStub_->trySetTestDerivedArrayAttributeAttribute(std::move(value)); +} + +void TestInterfaceStubDefault::RemoteEventHandler::onRemoteTestDerivedArrayAttributeAttributeChanged() { + defaultStub_->onRemoteTestDerivedArrayAttributeAttributeChanged(); +} + + +void TestInterfaceStubDefault::testEmptyMethod() { + // No operation in default +} void TestInterfaceStubDefault::testVoidPredefinedTypeMethod(uint32_t uint32Value, std::string stringValue) { // No operation in default @@ -126,30 +150,5 @@ TestInterfaceStubDefault::RemoteEventHandler::RemoteEventHandler(TestInterfaceSt defaultStub_(defaultStub) { } -bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestPredefinedTypeAttributeAttribute(uint32_t value) { - return defaultStub_->trySetTestPredefinedTypeAttributeAttribute(std::move(value)); -} - -void TestInterfaceStubDefault::RemoteEventHandler::onRemoteTestPredefinedTypeAttributeAttributeChanged() { - defaultStub_->onRemoteTestPredefinedTypeAttributeAttributeChanged(); -} - -bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestDerivedStructAttributeAttribute(DerivedTypeCollection::TestStructExtended value) { - return defaultStub_->trySetTestDerivedStructAttributeAttribute(std::move(value)); -} - -void TestInterfaceStubDefault::RemoteEventHandler::onRemoteTestDerivedStructAttributeAttributeChanged() { - defaultStub_->onRemoteTestDerivedStructAttributeAttributeChanged(); -} - -bool TestInterfaceStubDefault::RemoteEventHandler::onRemoteSetTestDerivedArrayAttributeAttribute(DerivedTypeCollection::TestArrayUInt64 value) { - return defaultStub_->trySetTestDerivedArrayAttributeAttribute(std::move(value)); -} - -void TestInterfaceStubDefault::RemoteEventHandler::onRemoteTestDerivedArrayAttributeAttributeChanged() { - defaultStub_->onRemoteTestDerivedArrayAttributeAttributeChanged(); -} - - } // namespace tests } // namespace commonapi diff --git a/src/test/commonapi/tests/TestInterfaceStubDefault.h b/src/test/commonapi/tests/TestInterfaceStubDefault.h index bc5cdff..3f0aeff 100644 --- a/src/test/commonapi/tests/TestInterfaceStubDefault.h +++ b/src/test/commonapi/tests/TestInterfaceStubDefault.h @@ -4,17 +4,26 @@ #ifndef COMMONAPI_TESTS_TEST_INTERFACE_STUB_DEFAULT_H_ #define COMMONAPI_TESTS_TEST_INTERFACE_STUB_DEFAULT_H_ -#include "TestInterfaceStub.h" +#include namespace commonapi { namespace tests { +/** + * Provides a default implementation for TestInterfaceStubRemoteEvent and + * TestInterfaceStub. Method callbacks have an empty implementation, + * remote set calls on attributes will always change the value of the attribute + * to the one received. + * + * Override this stub if you only want to provide a subset of the functionality + * that would be defined for this service, and/or if you do not need any non-default + * behaviour. + */ class TestInterfaceStubDefault : public TestInterfaceStub { public: TestInterfaceStubDefault(); TestInterfaceStubRemoteEvent* initStubAdapter(const std::shared_ptr& stubAdapter); - void deinitStubAdapter(); virtual const uint32_t& getTestPredefinedTypeAttributeAttribute(); virtual void setTestPredefinedTypeAttributeAttribute(uint32_t value); @@ -26,6 +35,8 @@ class TestInterfaceStubDefault : public TestInterfaceStub { virtual void setTestDerivedArrayAttributeAttribute(DerivedTypeCollection::TestArrayUInt64 value); + virtual void testEmptyMethod(); + virtual void testVoidPredefinedTypeMethod(uint32_t uint32Value, std::string stringValue); virtual void testPredefinedTypeMethod(uint32_t uint32InValue, std::string stringInValue, uint32_t& uint32OutValue, std::string& stringOutValue); diff --git a/src/test/test-derived-types.fidl b/src/test/test-derived-types.fidl index 7b8c477..48343f9 100644 --- a/src/test/test-derived-types.fidl +++ b/src/test/test-derived-types.fidl @@ -1,56 +1,60 @@ -/* 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/. */ -package commonapi.tests - -import commonapi.tests.* from "test-predefined-types.fidl" - -typeCollection DerivedTypeCollection { - <** @description : Common errors. **> - enumeration TestEnum { - <** @description : default **> - E_UNKNOWN = "0x00" - <** @description : no error - positive reply **> - E_OK = "0x01" - <** @description : value out of range **> - E_OUT_OF_RANGE = "0x02" - <** @description : not used **> - E_NOT_USED = "0x03" - } - - enumeration TestEnumMissingValue { - <** @description : default **> - E1 = "A" - E2 - E3 = "2" - } - - enumeration TestEnumExtended extends TestEnum { - <** @description : new error **> - E_NEW = "0x04" - } - - enumeration TestEnumExtended2 extends TestEnumExtended { - <** @description : new error **> - E_NEW2 = "0x05" - } - - struct TestStruct { - <** @description : the name of the property **> - PredefinedTypeCollection.TestString testString - - <** @description : the actual value **> - UInt16 uintValue - } - - struct TestStructExtended extends TestStruct { - TestEnumExtended2 testEnumExtended2 - } - - array TestArrayUInt64 of UInt64 - array TestArrayTestStruct of TestStruct - - map TestMap { UInt32 to TestArrayTestStruct } -} - - +/* 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/. */ +package commonapi.tests + +import commonapi.tests.* from "test-predefined-types.fidl" + +typeCollection DerivedTypeCollection { + + map TestMap { UInt32 to TestArrayTestStruct } + + struct TestStructExtended extends TestStruct { + TestEnumExtended2 testEnumExtended2 + } + + map TestEnumMap { TestEnum to String } + + <** @description : Common errors. **> + enumeration TestEnum { + <** @description : default **> + E_UNKNOWN = "0x00" + <** @description : no error - positive reply **> + E_OK = "0x01" + <** @description : value out of range **> + E_OUT_OF_RANGE = "0x02" + <** @description : not used **> + E_NOT_USED = "0x03" + } + + array TestArrayTestStruct of TestStruct + + enumeration TestEnumExtended2 extends TestEnumExtended { + <** @description : new error **> + E_NEW2 = "0x05" + } + + enumeration TestEnumMissingValue { + <** @description : default **> + E1 = "A" + E2 + E3 = "2" + } + + enumeration TestEnumExtended extends TestEnum { + <** @description : new error **> + E_NEW = "0x04" + } + + array TestArrayUInt64 of UInt64 + + struct TestStruct { + <** @description : the name of the property **> + PredefinedTypeCollection.TestString testString + + <** @description : the actual value **> + UInt16 uintValue + } +} + + diff --git a/src/test/test-interface-proxy.fidl b/src/test/test-interface-proxy.fidl index 88d4874..094897b 100644 --- a/src/test/test-interface-proxy.fidl +++ b/src/test/test-interface-proxy.fidl @@ -1,58 +1,61 @@ -/* 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/. */ -package commonapi.tests - -import commonapi.tests.* from "test-derived-types.fidl" - -interface TestInterface { - version { major 1 minor 0 } - - attribute UInt32 TestPredefinedTypeAttribute - attribute DerivedTypeCollection.TestStructExtended TestDerivedStructAttribute - attribute DerivedTypeCollection.TestArrayUInt64 TestDerivedArrayAttribute - - method testVoidPredefinedTypeMethod { - in { - UInt32 uint32Value - String stringValue - } - } - - method testPredefinedTypeMethod { - in { - UInt32 uint32InValue - String stringInValue - } - out { - UInt32 uint32OutValue - String stringOutValue - } - } - - method testVoidDerivedTypeMethod { - in { - DerivedTypeCollection.TestEnumExtended2 testEnumExtended2Value - DerivedTypeCollection.TestMap testMapValue - } - } - - method testDerivedTypeMethod { - in { - DerivedTypeCollection.TestEnumExtended2 testEnumExtended2InValue - DerivedTypeCollection.TestMap testMapInValue - } - out { - DerivedTypeCollection.TestEnumExtended2 testEnumExtended2OutValue - DerivedTypeCollection.TestMap testMapOutValue - } - } - - broadcast TestPredefinedTypeBroadcast { - out { - UInt32 uint32Value - String stringValue - } - } -} - +/* 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/. */ +package commonapi.tests + +import commonapi.tests.* from "test-derived-types.fidl" + +interface TestInterface { + version { major 1 minor 0 } + + attribute UInt32 TestPredefinedTypeAttribute + attribute DerivedTypeCollection.TestStructExtended TestDerivedStructAttribute + attribute DerivedTypeCollection.TestArrayUInt64 TestDerivedArrayAttribute + + method testEmptyMethod { + } + + method testVoidPredefinedTypeMethod { + in { + UInt32 uint32Value + String stringValue + } + } + + method testPredefinedTypeMethod { + in { + UInt32 uint32InValue + String stringInValue + } + out { + UInt32 uint32OutValue + String stringOutValue + } + } + + method testVoidDerivedTypeMethod { + in { + DerivedTypeCollection.TestEnumExtended2 testEnumExtended2Value + DerivedTypeCollection.TestMap testMapValue + } + } + + method testDerivedTypeMethod { + in { + DerivedTypeCollection.TestEnumExtended2 testEnumExtended2InValue + DerivedTypeCollection.TestMap testMapInValue + } + out { + DerivedTypeCollection.TestEnumExtended2 testEnumExtended2OutValue + DerivedTypeCollection.TestMap testMapOutValue + } + } + + broadcast TestPredefinedTypeBroadcast { + out { + UInt32 uint32Value + String stringValue + } + } +} + diff --git a/src/test/test-predefined-types.fidl b/src/test/test-predefined-types.fidl index 6226ed2..8a69103 100644 --- a/src/test/test-predefined-types.fidl +++ b/src/test/test-predefined-types.fidl @@ -1,22 +1,22 @@ -/* 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/. */ -package commonapi.tests - -typeCollection PredefinedTypeCollection { - typedef TestUInt8 is UInt8 - typedef TestUInt16 is UInt16 - typedef TestUInt32 is UInt32 - typedef TestUInt64 is UInt64 - typedef TestInt8 is Int8 - typedef TestInt16 is Int16 - typedef TestInt32 is Int32 - typedef TestInt64 is Int64 - typedef TestBoolean is Boolean - typedef TestByteBuffer is ByteBuffer - typedef TestDouble is Double - typedef TestFloat is Float - typedef TestString is String -} - - +/* 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/. */ +package commonapi.tests + +typeCollection PredefinedTypeCollection { + typedef TestUInt8 is UInt8 + typedef TestUInt16 is UInt16 + typedef TestUInt32 is UInt32 + typedef TestUInt64 is UInt64 + typedef TestInt8 is Int8 + typedef TestInt16 is Int16 + typedef TestInt32 is Int32 + typedef TestInt64 is Int64 + typedef TestBoolean is Boolean + typedef TestByteBuffer is ByteBuffer + typedef TestDouble is Double + typedef TestFloat is Float + typedef TestString is String +} + + -- cgit v1.2.1