c2049f67e4
Each application will have one thread dedicated for this, for all QDBusConnections. I wouldn't mind sharing such a thread with other uses in Qt, provided none of them ever block (the QProcessManager thread comes to mind, but it's going away soon). The cost associated with this change in this commit is so far rather minimal. All incoming D-Bus calls need to be handled after an event is posted anyway, to avoid deadlocking on reentering libdbus-1 functions that acquire locks still held. The cost is the one more thread running and the cost of synchronizing them when an event is posted. The benefits far outweigh that cost: no longer will we have problems of QtDBus failing to run if the main system or session connections are used before QCoreApplication is run. Moreover, events can be received and handled in aux threads even if the main thread is blocked on some operation. Note: this commit may not be testable (tst_qdbusconnection may fail) Task-number: QTBUG-43585 Change-Id: Ic5d393bfd36e48a193fcffff13b737556ccd11a8 Reviewed-by: Albert Astals Cid <aacid@kde.org> Reviewed-by: Alex Blasche <alexander.blasche@theqtcompany.com>
481 lines
14 KiB
C++
481 lines
14 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2015 The Qt Company Ltd.
|
|
** Copyright (C) 2015 Intel Corporation.
|
|
** Contact: http://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the test suite of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL21$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see http://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at http://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 2.1 or version 3 as published by the Free
|
|
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
|
|
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
|
|
** following information to ensure the GNU Lesser General Public License
|
|
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
|
|
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
|
**
|
|
** As a special exception, The Qt Company gives you certain additional
|
|
** rights. These rights are described in The Qt Company LGPL Exception
|
|
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
#include <QtCore/QObject>
|
|
#include <QtCore/QVariant>
|
|
#include <QtCore/QList>
|
|
#include <QtCore/QThread>
|
|
#include <QtCore/QVector>
|
|
#include <QtTest/QtTest>
|
|
#include <QtDBus>
|
|
|
|
#define TEST_INTERFACE_NAME "org.qtproject.QtDBus.MyObject"
|
|
|
|
class MyObject : public QDBusAbstractAdaptor
|
|
{
|
|
Q_OBJECT
|
|
Q_CLASSINFO("D-Bus Interface", "org.qtproject.QtDBus.MyObject")
|
|
|
|
public:
|
|
MyObject(QObject* parent =0)
|
|
: QDBusAbstractAdaptor(parent)
|
|
{}
|
|
|
|
public slots:
|
|
QStringList returnFoo() const
|
|
{ return QStringList() << QString::fromLatin1("foo"); }
|
|
|
|
void returnError(const QDBusMessage &msg) const
|
|
{
|
|
msg.setDelayedReply(true);
|
|
QDBusConnection::sessionBus().send(msg.createErrorReply("dbuspendingcall_error", ""));
|
|
}
|
|
};
|
|
|
|
class tst_QDBusPendingCall: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public:
|
|
tst_QDBusPendingCall();
|
|
|
|
public Q_SLOTS:
|
|
void callback(const QStringList &list);
|
|
void errorCallback(const QDBusError &error);
|
|
void finished(QDBusPendingCallWatcher *call);
|
|
void makeCall();
|
|
|
|
private Q_SLOTS:
|
|
void initTestCase();
|
|
void waitForFinished();
|
|
void waitForFinished_error();
|
|
void watcher();
|
|
void watcher_error();
|
|
void watcher_waitForFinished();
|
|
void watcher_waitForFinished_threaded();
|
|
void watcher_waitForFinished_alreadyFinished();
|
|
void watcher_waitForFinished_alreadyFinished_eventLoop();
|
|
void watcher_waitForFinished_error();
|
|
void callInsideWaitForFinished();
|
|
|
|
void callWithCallback_localLoop();
|
|
void callWithCallback_localLoop_errorReply();
|
|
|
|
private:
|
|
QDBusPendingCall sendMessage();
|
|
QDBusPendingCall sendError();
|
|
|
|
QDBusConnection conn;
|
|
|
|
enum { CallbackCalled, ErrorCallbackCalled, FinishCalled, MakeCallCalled };
|
|
int slotCalled;
|
|
int callCount;
|
|
QStringList callbackArgument;
|
|
QDBusError errorArgument;
|
|
QDBusPendingCallWatcher *watchArgument;
|
|
MyObject *obj;
|
|
};
|
|
|
|
tst_QDBusPendingCall::tst_QDBusPendingCall()
|
|
: conn(QDBusConnection::sessionBus())
|
|
, obj(new MyObject(this))
|
|
{
|
|
}
|
|
|
|
void tst_QDBusPendingCall::finished(QDBusPendingCallWatcher *call)
|
|
{
|
|
slotCalled = FinishCalled;
|
|
++callCount;
|
|
watchArgument = call;
|
|
if (QThread::currentThread() == thread())
|
|
QTestEventLoop::instance().exitLoop();
|
|
}
|
|
|
|
void tst_QDBusPendingCall::callback(const QStringList &list)
|
|
{
|
|
slotCalled = CallbackCalled;
|
|
++callCount;
|
|
callbackArgument = list;
|
|
QTestEventLoop::instance().exitLoop();
|
|
}
|
|
|
|
void tst_QDBusPendingCall::errorCallback(const QDBusError &error)
|
|
{
|
|
slotCalled = ErrorCallbackCalled;
|
|
++callCount;
|
|
errorArgument = error;
|
|
QTestEventLoop::instance().exitLoop();
|
|
}
|
|
|
|
void tst_QDBusPendingCall::makeCall()
|
|
{
|
|
// make an external call to D-Bus to make sure we haven't left any locks
|
|
slotCalled = MakeCallCalled;
|
|
++callCount;
|
|
|
|
sendMessage().waitForFinished();
|
|
}
|
|
|
|
void tst_QDBusPendingCall::initTestCase()
|
|
{
|
|
QVERIFY(conn.isConnected());
|
|
QVERIFY(conn.registerObject("/", this));
|
|
}
|
|
|
|
QDBusPendingCall tst_QDBusPendingCall::sendMessage()
|
|
{
|
|
QDBusMessage msg = QDBusMessage::createMethodCall("org.freedesktop.DBus",
|
|
"/",
|
|
"org.freedesktop.DBus",
|
|
"ListNames");
|
|
return conn.asyncCall(msg);
|
|
}
|
|
|
|
QDBusPendingCall tst_QDBusPendingCall::sendError()
|
|
{
|
|
QDBusMessage msg = QDBusMessage::createMethodCall("org.freedesktop.DBus",
|
|
"/",
|
|
"org.freedesktop.DBus",
|
|
"ThisNameWontExist");
|
|
return conn.asyncCall(msg);
|
|
}
|
|
|
|
void tst_QDBusPendingCall::waitForFinished()
|
|
{
|
|
QDBusPendingCall ac = sendMessage();
|
|
ac.waitForFinished();
|
|
QVERIFY(ac.isFinished());
|
|
QVERIFY(!ac.isError());
|
|
|
|
const QDBusMessage reply = ac.reply();
|
|
QVERIFY(reply.type() == QDBusMessage::ReplyMessage);
|
|
QCOMPARE(reply.signature(), QString("as"));
|
|
|
|
const QVariantList args = ac.reply().arguments();
|
|
QCOMPARE(args.count(), 1);
|
|
|
|
const QVariant &arg = args.at(0);
|
|
QCOMPARE(arg.type(), QVariant::StringList);
|
|
QVERIFY(arg.toStringList().contains(conn.baseService()));
|
|
}
|
|
|
|
void tst_QDBusPendingCall::waitForFinished_error()
|
|
{
|
|
QDBusPendingCall ac = sendError();
|
|
ac.waitForFinished();
|
|
QVERIFY(ac.isFinished());
|
|
QVERIFY(ac.isError());
|
|
|
|
QDBusError error = ac.error();
|
|
QVERIFY(error.isValid());
|
|
QCOMPARE(error.name(), QString("org.freedesktop.DBus.Error.UnknownMethod"));
|
|
QCOMPARE(error.type(), QDBusError::UnknownMethod);
|
|
}
|
|
|
|
void tst_QDBusPendingCall::callWithCallback_localLoop()
|
|
{
|
|
// Verify that a callback actually gets called when the call is dispatched locally.
|
|
QDBusInterface iface(QDBusConnection::sessionBus().baseService(), QLatin1String("/"),
|
|
TEST_INTERFACE_NAME);
|
|
QVERIFY(iface.isValid());
|
|
|
|
QVERIFY(iface.callWithCallback("returnFoo", QVariantList(), this, SLOT(callback(QStringList))));
|
|
|
|
// May be called synchronously or asynchronously...
|
|
if (callbackArgument != (QStringList() << QString::fromLatin1("foo"))) {
|
|
QTestEventLoop::instance().enterLoop(2);
|
|
QVERIFY(!QTestEventLoop::instance().timeout());
|
|
}
|
|
|
|
QCOMPARE(callbackArgument, QStringList() << QString::fromLatin1("foo"));
|
|
}
|
|
|
|
void tst_QDBusPendingCall::callWithCallback_localLoop_errorReply()
|
|
{
|
|
// Verify that an error callback actually gets called when the call is
|
|
// dispatched locally and the called method returns an error
|
|
|
|
QDBusInterface iface(QDBusConnection::sessionBus().baseService(), QLatin1String("/"),
|
|
TEST_INTERFACE_NAME);
|
|
QVERIFY(iface.isValid());
|
|
|
|
callbackArgument.clear();
|
|
|
|
QVERIFY(iface.callWithCallback("returnError", QVariantList(), this,
|
|
SLOT(callback(QStringList)), SLOT(errorCallback(QDBusError))));
|
|
|
|
// May be called synchronously or asynchronously...
|
|
if (errorArgument.name() != "dbuspendingcall_error") {
|
|
QTestEventLoop::instance().enterLoop(2);
|
|
QVERIFY(!QTestEventLoop::instance().timeout());
|
|
}
|
|
|
|
QCOMPARE(errorArgument.name(), QString::fromLatin1("dbuspendingcall_error"));
|
|
QVERIFY(callbackArgument.isEmpty());
|
|
}
|
|
|
|
void tst_QDBusPendingCall::watcher()
|
|
{
|
|
QDBusPendingCall ac = sendMessage();
|
|
callCount = 0;
|
|
watchArgument = 0;
|
|
|
|
QDBusPendingCallWatcher watch(ac);
|
|
connect(&watch, SIGNAL(finished(QDBusPendingCallWatcher*)),
|
|
SLOT(finished(QDBusPendingCallWatcher*)));
|
|
|
|
QTestEventLoop::instance().enterLoop(2);
|
|
QVERIFY(!QTestEventLoop::instance().timeout());
|
|
|
|
QVERIFY(ac.isFinished());
|
|
QVERIFY(!ac.isError());
|
|
|
|
QCOMPARE(callCount, 1);
|
|
QCOMPARE(slotCalled, (int)FinishCalled);
|
|
QCOMPARE(watchArgument, &watch);
|
|
QVERIFY(!watch.isError());
|
|
|
|
const QVariantList args2 = ac.reply().arguments();
|
|
QVERIFY(!args2.isEmpty());
|
|
QVERIFY(args2.at(0).toStringList().contains(conn.baseService()));
|
|
}
|
|
|
|
void tst_QDBusPendingCall::watcher_error()
|
|
{
|
|
QDBusPendingCall ac = sendError();
|
|
callCount = 0;
|
|
watchArgument = 0;
|
|
|
|
QDBusPendingCallWatcher watch(ac);
|
|
connect(&watch, SIGNAL(finished(QDBusPendingCallWatcher*)),
|
|
SLOT(finished(QDBusPendingCallWatcher*)));
|
|
|
|
QTestEventLoop::instance().enterLoop(2);
|
|
QVERIFY(!QTestEventLoop::instance().timeout());
|
|
|
|
QVERIFY(ac.isFinished());
|
|
QVERIFY(ac.isError());
|
|
|
|
QCOMPARE(callCount, 1);
|
|
QCOMPARE(slotCalled, (int)FinishCalled);
|
|
QCOMPARE(watchArgument, &watch);
|
|
|
|
QVERIFY(watch.isError());
|
|
QVERIFY(watch.error().isValid());
|
|
}
|
|
|
|
void tst_QDBusPendingCall::watcher_waitForFinished()
|
|
{
|
|
QDBusPendingCall ac = sendMessage();
|
|
callCount = 0;
|
|
watchArgument = 0;
|
|
|
|
QDBusPendingCallWatcher watch(ac);
|
|
connect(&watch, SIGNAL(finished(QDBusPendingCallWatcher*)),
|
|
SLOT(finished(QDBusPendingCallWatcher*)));
|
|
|
|
watch.waitForFinished();
|
|
|
|
QVERIFY(ac.isFinished());
|
|
QVERIFY(!ac.isError());
|
|
|
|
QCOMPARE(callCount, 1);
|
|
QCOMPARE(slotCalled, (int)FinishCalled);
|
|
QCOMPARE(watchArgument, &watch);
|
|
QVERIFY(!watch.isError());
|
|
|
|
const QVariantList args2 = ac.reply().arguments();
|
|
QVERIFY(!args2.isEmpty());
|
|
QVERIFY(args2.at(0).toStringList().contains(conn.baseService()));
|
|
}
|
|
|
|
void tst_QDBusPendingCall::watcher_waitForFinished_threaded()
|
|
{
|
|
callCount = 0;
|
|
watchArgument = 0;
|
|
slotCalled = 0;
|
|
|
|
class WorkerThread: public QThread {
|
|
public:
|
|
tst_QDBusPendingCall *tst;
|
|
WorkerThread(tst_QDBusPendingCall *tst) : tst(tst) {}
|
|
void run()
|
|
{
|
|
QDBusPendingCall ac = tst->sendMessage();
|
|
// QVERIFY(!ac.isFinished());
|
|
// QVERIFY(!ac.isError());
|
|
// QVERIFY(ac.reply().type() == QDBusMessage::InvalidMessage);
|
|
|
|
QDBusPendingCallWatcher watch(ac);
|
|
tst->connect(&watch, SIGNAL(finished(QDBusPendingCallWatcher*)),
|
|
SLOT(finished(QDBusPendingCallWatcher*)), Qt::DirectConnection);
|
|
|
|
QTest::qSleep(100); // don't process events in this thread
|
|
|
|
// QVERIFY(!ac.isFinished());
|
|
// QVERIFY(!ac.isError());
|
|
// QVERIFY(ac.reply().type() == QDBusMessage::InvalidMessage);
|
|
QCOMPARE(tst->callCount, 0);
|
|
QCOMPARE(tst->slotCalled, 0);
|
|
|
|
watch.waitForFinished();
|
|
QVERIFY(ac.isFinished());
|
|
QVERIFY(!ac.isError());
|
|
|
|
QCOMPARE(tst->callCount, 1);
|
|
QCOMPARE(tst->slotCalled, (int)FinishCalled);
|
|
QCOMPARE(tst->watchArgument, &watch);
|
|
QVERIFY(!watch.isError());
|
|
|
|
const QVariantList args2 = ac.reply().arguments();
|
|
QVERIFY(!args2.isEmpty());
|
|
QVERIFY(args2.at(0).toStringList().contains(tst->conn.baseService()));
|
|
}
|
|
} thread(this);
|
|
QTestEventLoop::instance().connect(&thread, SIGNAL(finished()), SLOT(exitLoop()));
|
|
thread.start();
|
|
QTestEventLoop::instance().enterLoop(10);
|
|
QVERIFY(thread.wait(3000));
|
|
QVERIFY(!QTestEventLoop::instance().timeout());
|
|
}
|
|
|
|
void tst_QDBusPendingCall::watcher_waitForFinished_alreadyFinished()
|
|
{
|
|
QDBusPendingCall ac = sendMessage();
|
|
ac.waitForFinished();
|
|
QVERIFY(ac.isFinished());
|
|
QVERIFY(!ac.isError());
|
|
|
|
callCount = 0;
|
|
watchArgument = 0;
|
|
|
|
// create a watcher on an already-finished reply
|
|
QDBusPendingCallWatcher watch(ac);
|
|
connect(&watch, SIGNAL(finished(QDBusPendingCallWatcher*)),
|
|
SLOT(finished(QDBusPendingCallWatcher*)));
|
|
|
|
watch.waitForFinished();
|
|
|
|
QVERIFY(ac.isFinished());
|
|
QVERIFY(!ac.isError());
|
|
|
|
QCOMPARE(callCount, 1);
|
|
QCOMPARE(slotCalled, (int)FinishCalled);
|
|
QCOMPARE(watchArgument, &watch);
|
|
QVERIFY(!watch.isError());
|
|
|
|
const QVariantList args2 = ac.reply().arguments();
|
|
QVERIFY(!args2.isEmpty());
|
|
QVERIFY(args2.at(0).toStringList().contains(conn.baseService()));
|
|
}
|
|
|
|
void tst_QDBusPendingCall::watcher_waitForFinished_alreadyFinished_eventLoop()
|
|
{
|
|
QDBusPendingCall ac = sendMessage();
|
|
ac.waitForFinished();
|
|
QVERIFY(ac.isFinished());
|
|
QVERIFY(!ac.isError());
|
|
|
|
callCount = 0;
|
|
watchArgument = 0;
|
|
|
|
// create a watcher on an already-finished reply
|
|
QDBusPendingCallWatcher watch(ac);
|
|
connect(&watch, SIGNAL(finished(QDBusPendingCallWatcher*)),
|
|
SLOT(finished(QDBusPendingCallWatcher*)));
|
|
connect(&watch, SIGNAL(finished(QDBusPendingCallWatcher*)),
|
|
&QTestEventLoop::instance(), SLOT(exitLoop()));
|
|
|
|
QTestEventLoop::instance().enterLoop(1);
|
|
QVERIFY(!QTestEventLoop::instance().timeout());
|
|
|
|
QVERIFY(ac.isFinished());
|
|
QVERIFY(!ac.isError());
|
|
|
|
QCOMPARE(callCount, 1);
|
|
QCOMPARE(slotCalled, (int)FinishCalled);
|
|
QCOMPARE(watchArgument, &watch);
|
|
QVERIFY(!watch.isError());
|
|
|
|
const QVariantList args2 = ac.reply().arguments();
|
|
QVERIFY(!args2.isEmpty());
|
|
QVERIFY(args2.at(0).toStringList().contains(conn.baseService()));
|
|
}
|
|
|
|
void tst_QDBusPendingCall::watcher_waitForFinished_error()
|
|
{
|
|
QDBusPendingCall ac = sendError();
|
|
callCount = 0;
|
|
watchArgument = 0;
|
|
|
|
QDBusPendingCallWatcher watch(ac);
|
|
connect(&watch, SIGNAL(finished(QDBusPendingCallWatcher*)),
|
|
SLOT(finished(QDBusPendingCallWatcher*)));
|
|
|
|
watch.waitForFinished();
|
|
|
|
QVERIFY(ac.isFinished());
|
|
QVERIFY(ac.isError());
|
|
|
|
QCOMPARE(callCount, 1);
|
|
QCOMPARE(slotCalled, (int)FinishCalled);
|
|
QCOMPARE(watchArgument, &watch);
|
|
|
|
QVERIFY(watch.isError());
|
|
QVERIFY(watch.error().isValid());
|
|
}
|
|
|
|
void tst_QDBusPendingCall::callInsideWaitForFinished()
|
|
{
|
|
QDBusPendingCall ac = sendMessage();
|
|
QDBusPendingCallWatcher watch(ac);
|
|
|
|
callCount = 0;
|
|
|
|
connect(&watch, SIGNAL(finished(QDBusPendingCallWatcher*)),
|
|
SLOT(makeCall()));
|
|
|
|
watch.waitForFinished();
|
|
|
|
QCOMPARE(callCount, 1);
|
|
QCOMPARE(slotCalled, (int)MakeCallCalled);
|
|
QVERIFY(!watch.isError());
|
|
|
|
const QVariantList args2 = ac.reply().arguments();
|
|
QVERIFY(!args2.isEmpty());
|
|
QVERIFY(args2.at(0).toStringList().contains(conn.baseService()));
|
|
}
|
|
|
|
QTEST_MAIN(tst_QDBusPendingCall)
|
|
#include "tst_qdbuspendingcall.moc"
|