From: Philip Rauwolf Date: Tue, 12 Mar 2013 15:05:29 +0000 (+0100) Subject: Updated DBusConnectionTest to current version of CommonAPI, integrated X-Git-Tag: 2.0.1~4 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=2d076820d3422901aa57e2b6b548d88a28ea06ad;p=profile%2Fivi%2Fcommon-api-dbus-runtime.git Updated DBusConnectionTest to current version of CommonAPI, integrated it into current test suite --- diff --git a/.gitignore b/.gitignore index 29281ae..36c6418 100644 --- a/.gitignore +++ b/.gitignore @@ -37,3 +37,4 @@ /DBusAddressTranslatorTest /.pydevproject /DBusServiceRegistryTest +/DBusConnectionTest diff --git a/Makefile.am b/Makefile.am index df0572d..9d35dd9 100644 --- a/Makefile.am +++ b/Makefile.am @@ -100,6 +100,7 @@ TestInterfaceSources = \ src/test/fakeLegacyService/fake/legacy/service/LegacyInterfaceDBusProxy.cpp check_PROGRAMS = \ + DBusConnectionTest \ DBusServiceRegistryTest \ DBusProxyTest \ DBusAddressTranslatorTest \ @@ -133,6 +134,11 @@ DBusAddressTranslatorTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS} DBusAddressTranslatorTest_CXXFLAGS = ${GTEST_CXXFLAGS} DBusAddressTranslatorTest_LDADD = ${LDADD_FOR_GTEST} +DBusConnectionTest_SOURCES = src/test/DBusConnectionTest.cpp +DBusConnectionTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS} +DBusConnectionTest_CXXFLAGS = ${GTEST_CXXFLAGS} +DBusConnectionTest_LDADD = ${LDADD_FOR_GTEST} + DBusTypeStreamTest_SOURCES = src/test/DBusTypeStreamTest.cpp DBusTypeStreamTest_CPPFLAGS = ${AM_CPPFLAGS} ${GTEST_CPPFLAGS} DBusTypeStreamTest_CXXFLAGS = ${GTEST_CXXFLAGS} diff --git a/src/test/DBusConnectionTest.cpp b/src/test/DBusConnectionTest.cpp index 0b85009..f06f11d 100644 --- a/src/test/DBusConnectionTest.cpp +++ b/src/test/DBusConnectionTest.cpp @@ -4,195 +4,277 @@ * 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 -#include +#include +#include #include +#include #include -#define ASSERT_DBUSMESSAGE_EQ(_dbusMessage1, _dbusMessage2) \ - ASSERT_FALSE(_dbusMessage1.getSignatureString() == NULL); \ - ASSERT_FALSE(_dbusMessage2.getSignatureString() == NULL); \ - ASSERT_STREQ(_dbusMessage1.getSignatureString(), _dbusMessage2.getSignatureString()); \ - ASSERT_EQ(_dbusMessage1.getBodyLength(), _dbusMessage2.getBodyLength()); \ - ASSERT_FALSE(_dbusMessage1.getBodyData() == NULL); \ - ASSERT_FALSE(_dbusMessage2.getBodyData() == NULL); \ - ASSERT_EQ(memcmp(_dbusMessage1.getBodyData(), _dbusMessage2.getBodyData(), _dbusMessage1.getBodyLength()), 0) - - -namespace { - class DBusConnectionTest: public ::testing::Test { - public: - void onConnectionStatusEvent(const common::api::AvailabilityStatus& newConnectionStatus) { - connectionStatusEventCount_++; - connectionStatus_ = newConnectionStatus; - } - - bool onInterfaceHandlerDBusMessageReply(const common::api::dbus::DBusMessage& dbusMessage, - const std::shared_ptr& dbusConnection) { - interfaceHandlerDBusMessageCount_++; - interfaceHandlerDBusMessage_ = dbusMessage; - interfaceHandlerDBusMessageReply_ = dbusMessage.createMethodReturn("si"); - - common::api::dbus::DBusOutputMessageStream dbusOutputMessageStream(interfaceHandlerDBusMessageReply_); - dbusOutputMessageStream << "This is a default message reply!" << interfaceHandlerDBusMessageCount_; - dbusOutputMessageStream.flush(); - - dbusConnection->sendDBusMessage(interfaceHandlerDBusMessageReply_); - - return true; - } - - void onDBusMessageHandler(const common::api::dbus::DBusMessage& dbusMessage) { - dbusMessageHandlerCount_++; - dbusMessageHandlerDBusMessage_ = dbusMessage; - } - protected: virtual void SetUp() { - dbusConnection_ = common::api::dbus::DBusConnection::getSessionBus(); - connectionStatusEventCount_ = 0; - interfaceHandlerDBusMessageCount_ = 0; - dbusMessageHandlerCount_ = 0; } virtual void TearDown() { - if (dbusConnection_ && dbusConnection_->isConnected()) - dbusConnection_->disconnect(); - - // reset DBusMessage - interfaceHandlerDBusMessage_ = common::api::dbus::DBusMessage(); - interfaceHandlerDBusMessageReply_ = common::api::dbus::DBusMessage(); - - dbusMessageHandlerDBusMessage_ = common::api::dbus::DBusMessage(); } - - - std::shared_ptr dbusConnection_; - - uint32_t connectionStatusEventCount_; - common::api::AvailabilityStatus connectionStatus_; - - uint32_t interfaceHandlerDBusMessageCount_; - common::api::dbus::DBusMessage interfaceHandlerDBusMessage_; - common::api::dbus::DBusMessage interfaceHandlerDBusMessageReply_; - - uint32_t dbusMessageHandlerCount_; - common::api::dbus::DBusMessage dbusMessageHandlerDBusMessage_; }; -TEST_F(DBusConnectionTest, IsInitiallyDisconnected) { - ASSERT_FALSE(dbusConnection_->isConnected()); +//TEST_F(DBusConnectionTest, IsInitiallyDisconnected) { +// ASSERT_FALSE(dbusConnection_->isConnected()); +//} +// +//TEST_F(DBusConnectionTest, ConnectAndDisconnectWork) { +// ASSERT_TRUE(dbusConnection_->connect()); +// ASSERT_TRUE(dbusConnection_->isConnected()); +// +// dbusConnection_->disconnect(); +// ASSERT_FALSE(dbusConnection_->isConnected()); +//} +// +//TEST_F(DBusConnectionTest, ConnectionStatusEventWorks) { +// ASSERT_EQ(connectionStatusEventCount_, 0); +// +// auto connectionStatusSubscription = dbusConnection_->getConnectionStatusEvent().subscribe(std::bind( +// &DBusConnectionTest::onConnectionStatusEvent, +// this, +// std::placeholders::_1)); +// +// ASSERT_FALSE(dbusConnection_->isConnected()); +// ASSERT_EQ(connectionStatusEventCount_, 0); +// +// uint32_t expectedEventCount = 0; +// while (expectedEventCount < 10) { +// ASSERT_TRUE(dbusConnection_->connect()); +// ASSERT_TRUE(dbusConnection_->isConnected()); +// ASSERT_EQ(connectionStatusEventCount_, ++expectedEventCount); +// ASSERT_EQ(connectionStatus_, common::api::AvailabilityStatus::AVAILABLE); +// +// dbusConnection_->disconnect(); +// ASSERT_FALSE(dbusConnection_->isConnected()); +// ASSERT_EQ(connectionStatusEventCount_, ++expectedEventCount); +// ASSERT_EQ(connectionStatus_, common::api::AvailabilityStatus::NOT_AVAILABLE); +// } +// +// dbusConnection_->getConnectionStatusEvent().unsubscribe(connectionStatusSubscription); +// ASSERT_EQ(connectionStatusEventCount_, expectedEventCount); +// +// ASSERT_TRUE(dbusConnection_->connect()); +// ASSERT_TRUE(dbusConnection_->isConnected()); +// ASSERT_EQ(connectionStatusEventCount_, expectedEventCount); +// +// dbusConnection_->disconnect(); +// ASSERT_FALSE(dbusConnection_->isConnected()); +// ASSERT_EQ(connectionStatusEventCount_, expectedEventCount); +//} +// +//TEST_F(DBusConnectionTest, SendingAsyncDBusMessagesWorks) { +// const char* busName = "common.api.dbus.test.TestInterfaceHandler"; +// const char* objectPath = "/common/api/dbus/test/TestObject"; +// const char* interfaceName = "common.api.dbus.test.TestInterface"; +// const char* methodName = "TestMethod"; +// +// auto interfaceHandlerDBusConnection = common::api::dbus::DBusConnection::getSessionBus(); +// +// ASSERT_TRUE(interfaceHandlerDBusConnection->connect()); +// ASSERT_TRUE(interfaceHandlerDBusConnection->requestServiceNameAndBlock(busName)); +// +// auto interfaceHandlerToken = interfaceHandlerDBusConnection->registerInterfaceHandler( +// objectPath, +// interfaceName, +// std::bind(&DBusConnectionTest::onInterfaceHandlerDBusMessageReply, +// this, +// std::placeholders::_1, +// interfaceHandlerDBusConnection)); +// +// +// ASSERT_TRUE(dbusConnection_->connect()); +// +// for (uint32_t expectedDBusMessageCount = 1; expectedDBusMessageCount <= 10; expectedDBusMessageCount++) { +// auto dbusMessageCall = common::api::dbus::DBusMessage::createMethodCall( +// busName, +// objectPath, +// interfaceName, +// methodName, +// "si"); +// ASSERT_TRUE(dbusMessageCall); +// +// common::api::dbus::DBusOutputMessageStream dbusOutputMessageStream(dbusMessageCall); +// dbusOutputMessageStream << "This is a test async call" +// << expectedDBusMessageCount; +// dbusOutputMessageStream.flush(); +// +// dbusConnection_->sendDBusMessageWithReplyAsync( +// dbusMessageCall, +// std::bind(&DBusConnectionTest::onDBusMessageHandler, this, std::placeholders::_1)); +// +// for (int i = 0; i < 10 && interfaceHandlerDBusMessageCount_ < expectedDBusMessageCount; i++) +// interfaceHandlerDBusConnection->readWriteDispatch(100); +// +// ASSERT_EQ(interfaceHandlerDBusMessageCount_, expectedDBusMessageCount); +// ASSERT_DBUSMESSAGE_EQ(dbusMessageCall, interfaceHandlerDBusMessage_); +// +// for (int i = 0; i < 10 && dbusMessageHandlerCount_ < expectedDBusMessageCount; i++) +// dbusConnection_->readWriteDispatch(100); +// +// ASSERT_EQ(dbusMessageHandlerCount_, expectedDBusMessageCount); +// ASSERT_DBUSMESSAGE_EQ(dbusMessageHandlerDBusMessage_, interfaceHandlerDBusMessageReply_); +// } +// +// dbusConnection_->disconnect(); +// +// +// interfaceHandlerDBusConnection->unregisterInterfaceHandler(interfaceHandlerToken); +// +// ASSERT_TRUE(interfaceHandlerDBusConnection->releaseServiceName(busName)); +// interfaceHandlerDBusConnection->disconnect(); +//} + + +void dispatch(::DBusConnection* libdbusConnection) { + dbus_bool_t success = TRUE; + while(success) { + success = dbus_connection_read_write_dispatch(libdbusConnection, 1); + } } -TEST_F(DBusConnectionTest, ConnectAndDisconnectWork) { - ASSERT_TRUE(dbusConnection_->connect()); - ASSERT_TRUE(dbusConnection_->isConnected()); +std::promise promise; +std::future future = promise.get_future(); - dbusConnection_->disconnect(); - ASSERT_FALSE(dbusConnection_->isConnected()); +void notifyThunk(DBusPendingCall*, void* data) { + ::DBusConnection* libdbusConnection = reinterpret_cast(data); + dbus_connection_close(libdbusConnection); + dbus_connection_unref(libdbusConnection); + promise.set_value(true); } -TEST_F(DBusConnectionTest, ConnectionStatusEventWorks) { - ASSERT_EQ(connectionStatusEventCount_, 0); +TEST_F(DBusConnectionTest, LibdbusConnectionsMayCommitSuicide) { + const ::DBusBusType libdbusType = ::DBusBusType::DBUS_BUS_SESSION; + ::DBusError libdbusError; + dbus_error_init(&libdbusError); + ::DBusConnection* libdbusConnection = dbus_bus_get_private(libdbusType, &libdbusError); - auto connectionStatusSubscription = dbusConnection_->getConnectionStatusEvent().subscribe(std::bind( - &DBusConnectionTest::onConnectionStatusEvent, - this, - std::placeholders::_1)); + assert(libdbusConnection); + dbus_connection_set_exit_on_disconnect(libdbusConnection, false); - ASSERT_FALSE(dbusConnection_->isConnected()); - ASSERT_EQ(connectionStatusEventCount_, 0); + auto dispatchThread = std::thread(&dispatch, libdbusConnection); - uint32_t expectedEventCount = 0; - while (expectedEventCount < 10) { - ASSERT_TRUE(dbusConnection_->connect()); - ASSERT_TRUE(dbusConnection_->isConnected()); - ASSERT_EQ(connectionStatusEventCount_, ++expectedEventCount); - ASSERT_EQ(connectionStatus_, common::api::AvailabilityStatus::AVAILABLE); + ::DBusMessage* libdbusMessageCall = dbus_message_new_method_call( + "org.freedesktop.DBus", + "/org/freedesktop/DBus", + "org.freedesktop.DBus", + "ListNames"); - dbusConnection_->disconnect(); - ASSERT_FALSE(dbusConnection_->isConnected()); - ASSERT_EQ(connectionStatusEventCount_, ++expectedEventCount); - ASSERT_EQ(connectionStatus_, common::api::AvailabilityStatus::NOT_AVAILABLE); - } + dbus_message_set_signature(libdbusMessageCall, ""); - dbusConnection_->getConnectionStatusEvent().unsubscribe(connectionStatusSubscription); - ASSERT_EQ(connectionStatusEventCount_, expectedEventCount); + bool hasHappened = false; - ASSERT_TRUE(dbusConnection_->connect()); - ASSERT_TRUE(dbusConnection_->isConnected()); - ASSERT_EQ(connectionStatusEventCount_, expectedEventCount); + DBusPendingCall* libdbusPendingCall; + dbus_bool_t libdbusSuccess; - dbusConnection_->disconnect(); - ASSERT_FALSE(dbusConnection_->isConnected()); - ASSERT_EQ(connectionStatusEventCount_, expectedEventCount); -} + dbus_connection_send_with_reply( + libdbusConnection, + libdbusMessageCall, + &libdbusPendingCall, + 500); -TEST_F(DBusConnectionTest, SendingAsyncDBusMessagesWorks) { - const char* busName = "common.api.dbus.test.TestInterfaceHandler"; - const char* objectPath = "/common/api/dbus/test/TestObject"; - const char* interfaceName = "common.api.dbus.test.TestInterface"; - const char* methodName = "TestMethod"; + dbus_pending_call_set_notify( + libdbusPendingCall, + notifyThunk, + libdbusConnection, + NULL); - auto interfaceHandlerDBusConnection = common::api::dbus::DBusConnection::getSessionBus(); + ASSERT_EQ(true, future.get()); + dispatchThread.join(); +} - ASSERT_TRUE(interfaceHandlerDBusConnection->connect()); - ASSERT_TRUE(interfaceHandlerDBusConnection->requestServiceNameAndBlock(busName)); - auto interfaceHandlerToken = interfaceHandlerDBusConnection->registerInterfaceHandler( - objectPath, - interfaceName, - std::bind(&DBusConnectionTest::onInterfaceHandlerDBusMessageReply, - this, - std::placeholders::_1, - interfaceHandlerDBusConnection)); +std::promise promise2; +std::future future2 = promise2.get_future(); +std::promise promise3; +std::future future3 = promise3.get_future(); +void noPartnerCallback(DBusPendingCall*, void* data) { + ::DBusConnection* libdbusConnection = reinterpret_cast(data); + dbus_connection_close(libdbusConnection); + dbus_connection_unref(libdbusConnection); + promise2.set_value(true); +} - ASSERT_TRUE(dbusConnection_->connect()); +void noPartnerCleanup(void* data) { + std::cout << "Cleanup" << std::endl; + promise3.set_value(true); +} - for (uint32_t expectedDBusMessageCount = 1; expectedDBusMessageCount <= 10; expectedDBusMessageCount++) { - auto dbusMessageCall = common::api::dbus::DBusMessage::createMethodCall( - busName, - objectPath, - interfaceName, - methodName, - "si"); - ASSERT_TRUE(dbusMessageCall); +TEST_F(DBusConnectionTest, TimeoutForNonexistingServices) { + const ::DBusBusType libdbusType = ::DBusBusType::DBUS_BUS_SESSION; + ::DBusError libdbusError; + dbus_error_init(&libdbusError); + ::DBusConnection* libdbusConnection = dbus_bus_get_private(libdbusType, &libdbusError); - common::api::dbus::DBusOutputMessageStream dbusOutputMessageStream(dbusMessageCall); - dbusOutputMessageStream << "This is a test async call" - << expectedDBusMessageCount; - dbusOutputMessageStream.flush(); + assert(libdbusConnection); + dbus_connection_set_exit_on_disconnect(libdbusConnection, false); - dbusConnection_->sendDBusMessageWithReplyAsync( - dbusMessageCall, - std::bind(&DBusConnectionTest::onDBusMessageHandler, this, std::placeholders::_1)); + auto dispatchThread = std::thread(&dispatch, libdbusConnection); - for (int i = 0; i < 10 && interfaceHandlerDBusMessageCount_ < expectedDBusMessageCount; i++) - interfaceHandlerDBusConnection->readWriteDispatch(100); + ::DBusMessage* libdbusMessageCall = dbus_message_new_method_call( + "some.connection.somewhere", + "/some/non/existing/object", + "some.interface.somewhere.but.same.place", + "NoReasonableMethod"); - ASSERT_EQ(interfaceHandlerDBusMessageCount_, expectedDBusMessageCount); - ASSERT_DBUSMESSAGE_EQ(dbusMessageCall, interfaceHandlerDBusMessage_); + dbus_message_set_signature(libdbusMessageCall, ""); - for (int i = 0; i < 10 && dbusMessageHandlerCount_ < expectedDBusMessageCount; i++) - dbusConnection_->readWriteDispatch(100); + bool hasHappened = false; - ASSERT_EQ(dbusMessageHandlerCount_, expectedDBusMessageCount); - ASSERT_DBUSMESSAGE_EQ(dbusMessageHandlerDBusMessage_, interfaceHandlerDBusMessageReply_); - } + DBusPendingCall* libdbusPendingCall; + dbus_bool_t libdbusSuccess; - dbusConnection_->disconnect(); + dbus_connection_send_with_reply( + libdbusConnection, + libdbusMessageCall, + &libdbusPendingCall, + 5000); + dbus_pending_call_set_notify( + libdbusPendingCall, + noPartnerCallback, + libdbusConnection, + noPartnerCleanup); - interfaceHandlerDBusConnection->unregisterInterfaceHandler(interfaceHandlerToken); + ASSERT_EQ(true, future2.get()); + dispatchThread.join(); +} - ASSERT_TRUE(interfaceHandlerDBusConnection->releaseServiceName(busName)); - interfaceHandlerDBusConnection->disconnect(); +//TEST_F(DBusConnectionTest, ConnectionsMayCommitAsynchronousSuicide) { +// CommonAPI::DBus::DBusConnection* dbusConnection_ = new CommonAPI::DBus::DBusConnection(CommonAPI::DBus::DBusConnection::BusType::SESSION); +// dbusConnection_->connect(); +// +// auto dbusMessageCall = CommonAPI::DBus::DBusMessage::createMethodCall( +// "org.freedesktop.DBus", +// "/org/freedesktop/DBus", +// "org.freedesktop.DBus", +// "ListNames", +// ""); +// +// bool hasHappened = false; +// +// auto future = dbusConnection_->sendDBusMessageWithReplyAsync(dbusMessageCall, CommonAPI::DBus::DBusProxyAsyncCallbackHandler>::create( +// [&] (const CommonAPI::CallStatus&, std::vector) { +// hasHappened = true; +// delete dbusConnection_; +// } +// )); +// +// ASSERT_EQ(CommonAPI::CallStatus::SUCCESS, future.get()); +//} + + +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } -} // namespace