Long live Qt 4.5!

3 files changed, 554 insertions, 0 deletions

diff --git a/tests/auto/qdbusconnection/.gitignore b/tests/auto/qdbusconnection/.gitignore
new file mode 100644
index 0000000..2995d60
--- /dev/null
+++ b/tests/auto/qdbusconnection/.gitignore
@@ -0,0 +1 @@
+tst_qdbusconnection
diff --git a/tests/auto/qdbusconnection/qdbusconnection.pro b/tests/auto/qdbusconnection/qdbusconnection.pro
new file mode 100644
index 0000000..d33ab0d
--- /dev/null
+++ b/tests/auto/qdbusconnection/qdbusconnection.pro
@@ -0,0 +1,11 @@
+load(qttest_p4)
+QT = core
+
+contains(QT_CONFIG,dbus): {
+	SOURCES += tst_qdbusconnection.cpp
+	QT += dbus
+} else {
+	SOURCES += ../qdbusmarshall/dummy.cpp
+}
+
+
diff --git a/tests/auto/qdbusconnection/tst_qdbusconnection.cpp b/tests/auto/qdbusconnection/tst_qdbusconnection.cpp
new file mode 100644
index 0000000..e04df2a
--- /dev/null
+++ b/tests/auto/qdbusconnection/tst_qdbusconnection.cpp
@@ -0,0 +1,542 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <qcoreapplication.h>
+#include <qdebug.h>
+
+#include <QtTest/QtTest>
+#include <QtDBus/QtDBus>
+
+class BaseObject: public QObject
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "local.BaseObject")
+public:
+    BaseObject(QObject *parent = 0) : QObject(parent) { }
+public slots:
+    void anotherMethod() { }
+};
+
+class MyObject: public BaseObject
+{
+    Q_OBJECT
+public slots:
+    void method(const QDBusMessage &msg);
+
+public:
+    static QString path;
+    int callCount;
+    MyObject(QObject *parent = 0) : BaseObject(parent), callCount(0) {}
+};
+
+void MyObject::method(const QDBusMessage &msg)
+{
+    path = msg.path();
+    ++callCount;
+    //qDebug() << msg;
+}
+
+class tst_QDBusConnection: public QObject
+{
+    Q_OBJECT
+
+    int signalsReceived;
+public slots:
+    void oneSlot() { ++signalsReceived; }
+
+private slots:
+    void noConnection();
+    void connectToBus();
+    void connect();
+    void send();
+    void sendAsync();
+    void sendSignal();
+
+    void registerObject_data();
+    void registerObject();
+    void registerObject2();
+
+    void registerQObjectChildren();
+
+    void callSelf();
+    void multipleInterfacesInQObject();
+
+    void slotsWithLessParameters();
+
+public:
+    QString serviceName() const { return "com.trolltech.Qt.Autotests.QDBusConnection"; }
+    bool callMethod(const QDBusConnection &conn, const QString &path);
+};
+
+class QDBusSpy: public QObject
+{
+    Q_OBJECT
+public slots:
+    void handlePing(const QString &str) { args.clear(); args << str; }
+    void asyncReply(const QDBusMessage &msg) { args = msg.arguments(); }
+
+public:
+    QList<QVariant> args;
+};
+
+void tst_QDBusConnection::noConnection()
+{
+    QDBusConnection con = QDBusConnection::connectToBus("unix:path=/dev/null", "testconnection");
+    QVERIFY(!con.isConnected());
+
+    // try sending a message. This should fail
+    QDBusMessage msg = QDBusMessage::createMethodCall("org.kde.selftest", "/org/kde/selftest",
+                                                      "org.kde.selftest", "Ping");
+    msg << QLatin1String("ping");
+
+    QVERIFY(!con.send(msg));
+
+    QDBusSpy spy;
+    QVERIFY(con.callWithCallback(msg, &spy, SLOT(asyncReply)) == 0);
+
+    QDBusMessage reply = con.call(msg);
+    QVERIFY(reply.type() == QDBusMessage::ErrorMessage);
+
+    QDBusReply<void> voidreply(reply);
+    QVERIFY(!voidreply.isValid());
+
+    QDBusConnection::disconnectFromBus("testconnection");
+}
+
+void tst_QDBusConnection::sendSignal()
+{
+    QDBusConnection con = QDBusConnection::sessionBus();
+
+    QVERIFY(con.isConnected());
+
+    QDBusMessage msg = QDBusMessage::createSignal("/org/kde/selftest", "org.kde.selftest",
+                                                  "Ping");
+    msg << QLatin1String("ping");
+
+    QVERIFY(con.send(msg));
+
+    QTest::qWait(1000);
+}
+
+void tst_QDBusConnection::send()
+{
+    QDBusConnection con = QDBusConnection::sessionBus();
+
+    QVERIFY(con.isConnected());
+
+    QDBusMessage msg = QDBusMessage::createMethodCall("org.freedesktop.DBus",
+        "/org/freedesktop/DBus", "org.freedesktop.DBus", "ListNames");
+
+    QDBusMessage reply = con.call(msg);
+
+    QCOMPARE(reply.arguments().count(), 1);
+    QCOMPARE(reply.arguments().at(0).typeName(), "QStringList");
+    QVERIFY(reply.arguments().at(0).toStringList().contains(con.baseService()));
+}
+
+void tst_QDBusConnection::sendAsync()
+{
+    QDBusConnection con = QDBusConnection::sessionBus();
+    QVERIFY(con.isConnected());
+
+    QDBusSpy spy;
+
+    QDBusMessage msg = QDBusMessage::createMethodCall("org.freedesktop.DBus",
+            "/org/freedesktop/DBus", "org.freedesktop.DBus", "ListNames");
+    QVERIFY(con.callWithCallback(msg, &spy, SLOT(asyncReply(QDBusMessage))));
+
+    QTest::qWait(1000);
+
+    QCOMPARE(spy.args.value(0).typeName(), "QStringList");
+    QVERIFY(spy.args.at(0).toStringList().contains(con.baseService()));
+}
+
+void tst_QDBusConnection::connect()
+{
+    QDBusSpy spy;
+
+    QDBusConnection con = QDBusConnection::sessionBus();
+
+    con.connect(con.baseService(), "/org/kde/selftest", "org.kde.selftest", "ping", &spy,
+                 SLOT(handlePing(QString)));
+
+    QDBusMessage msg = QDBusMessage::createSignal("/org/kde/selftest", "org.kde.selftest",
+                                                  "ping");
+    msg << QLatin1String("ping");
+
+    QVERIFY(con.send(msg));
+
+    QTest::qWait(1000);
+
+    QCOMPARE(spy.args.count(), 1);
+    QCOMPARE(spy.args.at(0).toString(), QString("ping"));
+}
+
+void tst_QDBusConnection::connectToBus()
+{
+    {
+        QDBusConnection con = QDBusConnection::connectToBus(
+                QDBusConnection::SessionBus, "bubu");
+
+        QVERIFY(con.isConnected());
+        QVERIFY(!con.lastError().isValid());
+
+        QDBusConnection con2("foo");
+        QVERIFY(!con2.isConnected());
+        QVERIFY(!con2.lastError().isValid());
+
+        con2 = con;
+        QVERIFY(con.isConnected());
+        QVERIFY(con2.isConnected());
+        QVERIFY(!con.lastError().isValid());
+        QVERIFY(!con2.lastError().isValid());
+    }
+
+    {
+        QDBusConnection con("bubu");
+        QVERIFY(con.isConnected());
+        QVERIFY(!con.lastError().isValid());
+    }
+
+    QDBusConnection::disconnectFromBus("bubu");
+
+    {
+        QDBusConnection con("bubu");
+        QVERIFY(!con.isConnected());
+        QVERIFY(!con.lastError().isValid());
+    }
+
+    QByteArray address = qgetenv("DBUS_SESSION_BUS_ADDRESS");
+    if (!address.isEmpty()) {
+        QDBusConnection con = QDBusConnection::connectToBus(address, "newconn");
+        QVERIFY(con.isConnected());
+        QVERIFY(!con.lastError().isValid());
+
+        QDBusConnection::disconnectFromBus("newconn");
+    }
+}
+
+void tst_QDBusConnection::registerObject_data()
+{
+    QTest::addColumn<QString>("path");
+
+    QTest::newRow("/") << "/";
+    QTest::newRow("/p1") << "/p1";
+    QTest::newRow("/p2") << "/p2";
+    QTest::newRow("/p1/q") << "/p1/q";
+    QTest::newRow("/p1/q/r") << "/p1/q/r";
+}
+
+void tst_QDBusConnection::registerObject()
+{
+    QFETCH(QString, path);
+
+    QDBusConnection con = QDBusConnection::sessionBus();
+    QVERIFY(con.isConnected());
+
+    //QVERIFY(!callMethod(con, path));
+    {
+        // register one object at root:
+        MyObject obj;
+        QVERIFY(con.registerObject(path, &obj, QDBusConnection::ExportAllSlots));
+        QCOMPARE(con.objectRegisteredAt(path), &obj);
+        QVERIFY(callMethod(con, path));
+        QCOMPARE(obj.path, path);
+    }
+    // make sure it's gone
+    QVERIFY(!callMethod(con, path));
+}
+
+void tst_QDBusConnection::registerObject2()
+{
+    QDBusConnection con = QDBusConnection::sessionBus();
+    QVERIFY(con.isConnected());
+
+    // make sure nothing is using our paths:
+     QVERIFY(!callMethod(con, "/"));
+     QVERIFY(!callMethod(con, "/p1"));
+     QVERIFY(!callMethod(con, "/p2"));
+     QVERIFY(!callMethod(con, "/p1/q"));
+     QVERIFY(!callMethod(con, "/p1/q/r"));
+
+    {
+        // register one object at root:
+        MyObject obj;
+        QVERIFY(con.registerObject("/", &obj, QDBusConnection::ExportAllSlots));
+        QVERIFY(callMethod(con, "/"));
+        qDebug() << obj.path;
+        QCOMPARE(obj.path, QString("/"));
+    }
+    // make sure it's gone
+    QVERIFY(!callMethod(con, "/"));
+
+    {
+        // register one at an element:
+        MyObject obj;
+        QVERIFY(con.registerObject("/p1", &obj, QDBusConnection::ExportAllSlots));
+        QVERIFY(!callMethod(con, "/"));
+        QVERIFY(callMethod(con, "/p1"));
+        qDebug() << obj.path;
+        QCOMPARE(obj.path, QString("/p1"));
+
+        // re-register it somewhere else
+        QVERIFY(con.registerObject("/p2", &obj, QDBusConnection::ExportAllSlots));
+        QVERIFY(callMethod(con, "/p1"));
+        QCOMPARE(obj.path, QString("/p1"));
+        QVERIFY(callMethod(con, "/p2"));
+        QCOMPARE(obj.path, QString("/p2"));
+    }
+    // make sure it's gone
+    QVERIFY(!callMethod(con, "/p1"));
+    QVERIFY(!callMethod(con, "/p2"));
+
+    {
+        // register at a deep path
+        MyObject obj;
+        QVERIFY(con.registerObject("/p1/q/r", &obj, QDBusConnection::ExportAllSlots));
+        QVERIFY(!callMethod(con, "/"));
+        QVERIFY(!callMethod(con, "/p1"));
+        QVERIFY(!callMethod(con, "/p1/q"));
+        QVERIFY(callMethod(con, "/p1/q/r"));
+        QCOMPARE(obj.path, QString("/p1/q/r"));
+    }
+    // make sure it's gone
+    QVERIFY(!callMethod(con, "/p1/q/r"));
+
+    {
+        MyObject obj;
+        QVERIFY(con.registerObject("/p1/q2", &obj, QDBusConnection::ExportAllSlots));
+        QVERIFY(callMethod(con, "/p1/q2"));
+        QCOMPARE(obj.path, QString("/p1/q2"));
+
+        // try unregistering
+        con.unregisterObject("/p1/q2");
+        QVERIFY(!callMethod(con, "/p1/q2"));
+
+        // register it again
+        QVERIFY(con.registerObject("/p1/q2", &obj, QDBusConnection::ExportAllSlots));
+        QVERIFY(callMethod(con, "/p1/q2"));
+        QCOMPARE(obj.path, QString("/p1/q2"));
+
+        // now try removing things around it:
+        con.unregisterObject("/p2");
+        QVERIFY(callMethod(con, "/p1/q2")); // unrelated object shouldn't affect
+
+        con.unregisterObject("/p1");
+        QVERIFY(callMethod(con, "/p1/q2")); // unregistering just the parent shouldn't affect it
+
+        con.unregisterObject("/p1/q2/r");
+        QVERIFY(callMethod(con, "/p1/q2")); // unregistering non-existing child shouldn't affect it either
+
+        con.unregisterObject("/p1/q");
+        QVERIFY(callMethod(con, "/p1/q2")); // unregistering sibling (before) shouldn't affect
+
+        con.unregisterObject("/p1/r");
+        QVERIFY(callMethod(con, "/p1/q2")); // unregistering sibling (after) shouldn't affect
+
+        // now remove it:
+        con.unregisterObject("/p1", QDBusConnection::UnregisterTree);
+        QVERIFY(!callMethod(con, "/p1/q2")); // we removed the full tree
+    }
+}
+
+void tst_QDBusConnection::registerQObjectChildren()
+{
+    // make sure no one is there
+    QDBusConnection con = QDBusConnection::sessionBus();
+    QVERIFY(!callMethod(con, "/p1"));
+
+    {
+        MyObject obj, *a, *b, *c, *cc;
+
+        a = new MyObject(&obj);
+        a->setObjectName("a");
+
+        b = new MyObject(&obj);
+        b->setObjectName("b");
+
+        c = new MyObject(&obj);
+        c->setObjectName("c");
+
+        cc = new MyObject(c);
+        cc->setObjectName("cc");
+
+        con.registerObject("/p1", &obj, QDBusConnection::ExportAllSlots |
+                           QDBusConnection::ExportChildObjects);
+
+        // make calls
+        QVERIFY(callMethod(con, "/p1"));
+        QCOMPARE(obj.callCount, 1);
+        QVERIFY(callMethod(con, "/p1/a"));
+        QCOMPARE(a->callCount, 1);
+        QVERIFY(callMethod(con, "/p1/b"));
+        QCOMPARE(b->callCount, 1);
+        QVERIFY(callMethod(con, "/p1/c"));
+        QCOMPARE(c->callCount, 1);
+        QVERIFY(callMethod(con, "/p1/c/cc"));
+        QCOMPARE(cc->callCount, 1);
+
+        QVERIFY(!callMethod(con, "/p1/d"));
+        QVERIFY(!callMethod(con, "/p1/c/abc"));
+
+        // pull an object, see if it goes away:
+        delete b;
+        QVERIFY(!callMethod(con, "/p1/b"));
+
+        delete c;
+        QVERIFY(!callMethod(con, "/p1/c"));
+        QVERIFY(!callMethod(con, "/p1/c/cc"));
+    }
+
+    QVERIFY(!callMethod(con, "/p1"));
+    QVERIFY(!callMethod(con, "/p1/a"));
+    QVERIFY(!callMethod(con, "/p1/b"));
+    QVERIFY(!callMethod(con, "/p1/c"));
+    QVERIFY(!callMethod(con, "/p1/c/cc"));
+}
+
+bool tst_QDBusConnection::callMethod(const QDBusConnection &conn, const QString &path)
+{
+    QDBusMessage msg = QDBusMessage::createMethodCall(conn.baseService(), path, "", "method");
+    QDBusMessage reply = conn.call(msg, QDBus::Block/*WithGui*/);
+
+    if (reply.type() != QDBusMessage::ReplyMessage)
+        return false;
+    if (MyObject::path == path) {
+        QTest::compare_helper(true, "COMPARE()", __FILE__, __LINE__);
+    } else {
+        QTest::compare_helper(false, "Compared values are not the same",
+                              QTest::toString(MyObject::path), QTest::toString(path),
+                              "MyObject::path", "path", __FILE__, __LINE__);
+        return false;
+    }
+
+    return true;
+}
+
+class TestObject : public QObject
+{
+Q_OBJECT
+public:
+    TestObject(QObject *parent = 0) : QObject(parent) {}
+    ~TestObject() {}
+
+    QString func;
+
+public slots:
+    void test0() { func = "test0"; }
+    void test1(int i) { func = "test1 " + QString::number(i); }
+    int test2() { func = "test2"; return 43; }
+    int test3(int i) { func = "test2"; return i + 1; }
+};
+
+void tst_QDBusConnection::callSelf()
+{
+    TestObject testObject;
+    QDBusConnection connection = QDBusConnection::sessionBus();
+    QVERIFY(connection.registerObject("/test", &testObject,
+            QDBusConnection::ExportAllContents));
+    QCOMPARE(connection.objectRegisteredAt("/test"), &testObject);
+    QVERIFY(connection.registerService(serviceName()));
+    QDBusInterface interface(serviceName(), "/test");
+    QVERIFY(interface.isValid());
+
+    interface.call(QDBus::Block, "test0");
+    QCOMPARE(testObject.func, QString("test0"));
+    interface.call(QDBus::Block, "test1", 42);
+    QCOMPARE(testObject.func, QString("test1 42"));
+    QDBusMessage reply = interface.call(QDBus::Block, "test2");
+    QCOMPARE(testObject.func, QString("test2"));
+    QCOMPARE(reply.arguments().value(0).toInt(), 43);
+
+    QDBusMessage msg = QDBusMessage::createMethodCall(serviceName(), "/test",
+                                                      QString(), "test3");
+    msg << 44;
+    reply = connection.call(msg);
+    QCOMPARE(reply.arguments().value(0).toInt(), 45);
+}
+
+void tst_QDBusConnection::multipleInterfacesInQObject()
+{
+    QDBusConnection con = QDBusConnection::sessionBus();
+    QVERIFY(!callMethod(con, "/p1"));
+
+    MyObject obj;
+    con.registerObject("/p1", &obj, QDBusConnection::ExportAllSlots);
+
+    // check if we can call the BaseObject's interface
+    QDBusMessage msg = QDBusMessage::createMethodCall(con.baseService(), "/p1",
+                                                      "local.BaseObject", "anotherMethod");
+    QDBusMessage reply = con.call(msg, QDBus::Block);
+    QCOMPARE(reply.type(), QDBusMessage::ReplyMessage);
+    QVERIFY(reply.arguments().count() == 0);
+}
+
+void tst_QDBusConnection::slotsWithLessParameters()
+{
+    QDBusConnection con = QDBusConnection::sessionBus();
+
+    QDBusMessage signal = QDBusMessage::createSignal("/", "com.trolltech.TestCase",
+                                                     "oneSignal");
+    signal << "one parameter";
+
+    signalsReceived = 0;
+    QVERIFY(con.connect(con.baseService(), signal.path(), signal.interface(),
+                        signal.member(), this, SLOT(oneSlot())));
+    QVERIFY(con.send(signal));
+    QTest::qWait(100);
+    QCOMPARE(signalsReceived, 1);
+
+    // disconnect and try with a signature
+    signalsReceived = 0;
+    QVERIFY(con.disconnect(con.baseService(), signal.path(), signal.interface(),
+                           signal.member(), this, SLOT(oneSlot())));
+    QVERIFY(con.connect(con.baseService(), signal.path(), signal.interface(),
+                        signal.member(), "s", this, SLOT(oneSlot())));
+    QVERIFY(con.send(signal));
+    QTest::qWait(100);
+    QCOMPARE(signalsReceived, 1);
+}
+
+QString MyObject::path;
+QTEST_MAIN(tst_QDBusConnection)
+
+#include "tst_qdbusconnection.moc"
+