2006-03-06 Thiago Macieira <thiago.macieira@trolltech.com>

	* test/qt/*: Update the self-tests.

1 files changed, 792 insertions, 0 deletions

diff --git a/test/qt/tst_qdbusabstractadaptor.cpp b/test/qt/tst_qdbusabstractadaptor.cpp
new file mode 100644
index 00000000..5c1c609d
--- /dev/null
+++ b/test/qt/tst_qdbusabstractadaptor.cpp
@@ -0,0 +1,792 @@
+#include <qcoreapplication.h>
+#include <qdebug.h>
+
+#include <QtTest/QtTest>
+
+#define DBUS_API_SUBJECT_TO_CHANGE
+#include <dbus/qdbus.h>
+
+#include "common.h"
+
+Q_DECLARE_METATYPE(QVariant)
+
+const char *slotSpy;
+QString propSpy;
+
+namespace QTest {
+    char *toString(QDBusMessage::MessageType t)
+    {
+        switch (t)
+        {
+        case QDBusMessage::InvalidMessage:
+            return qstrdup("InvalidMessage");
+        case QDBusMessage::MethodCallMessage:
+            return qstrdup("MethodCallMessage");
+        case QDBusMessage::ReplyMessage:
+            return qstrdup("ReplyMessage");
+        case QDBusMessage::ErrorMessage:
+            return qstrdup("ErrorMessage");
+        case QDBusMessage::SignalMessage:
+            return qstrdup("SignalMessage");
+        default:
+            return 0;
+        }
+    }
+}
+
+class tst_QDBusAbstractAdaptor: public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void initTestCase();
+
+    void methodCalls_data();
+    void methodCalls();
+    void signalEmissions_data();
+    void signalEmissions();
+    void sameSignalDifferentPaths();
+    void overloadedSignalEmission_data();
+    void overloadedSignalEmission();
+    void readProperties();
+    void writeProperties();
+    void adaptorIntrospection_data();
+    void adaptorIntrospection();
+    void objectTreeIntrospection();
+};
+
+class QDBusSignalSpy: public QObject
+{
+    Q_OBJECT
+
+public slots:
+    void slot(const QDBusMessage &msg)
+    {
+        ++count;
+        interface = msg.interface();
+        name = msg.name();
+        signature = msg.signature();
+        value.clear();
+        if (msg.count())
+            value = msg.at(0);
+    }
+
+public:
+    QDBusSignalSpy() : count(0) { }
+
+    int count;
+    QString interface;
+    QString name;
+    QString signature;
+    QVariant value;
+};
+
+class Interface1: public QDBusAbstractAdaptor
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "local.Interface1");
+public:
+    Interface1(QObject *parent) : QDBusAbstractAdaptor(parent)
+    { }
+
+    static QDBusIntrospection::Methods methodData;
+    static QDBusIntrospection::Signals signalData;
+    static QDBusIntrospection::Properties propertyData;
+};
+
+class Interface2: public QDBusAbstractAdaptor
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "local.Interface2");
+    Q_PROPERTY(QString prop1 READ prop1);
+    Q_PROPERTY(QString prop2 READ prop2 WRITE setProp2);
+public:
+    Interface2(QObject *parent) : QDBusAbstractAdaptor(parent)
+    { setAutoRelaySignals(true); }
+
+    QString prop1() const
+    { return __PRETTY_FUNCTION__; }
+
+    QString prop2() const
+    { return __PRETTY_FUNCTION__; }
+
+    void setProp2(const QString &value)
+    { slotSpy = __PRETTY_FUNCTION__; propSpy = value; }
+
+    void emitSignal(const QString &, const QVariant &)
+    { emit signal(); }
+
+public slots:
+    void method() { slotSpy = __PRETTY_FUNCTION__; }
+
+signals:
+    void signal();
+
+public:
+    static QDBusIntrospection::Methods methodData;
+    static QDBusIntrospection::Signals signalData;
+    static QDBusIntrospection::Properties propertyData;    
+};
+
+class Interface3: public QDBusAbstractAdaptor
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "local.Interface3");
+    Q_PROPERTY(QString prop1 READ prop1);
+    Q_PROPERTY(QString prop2 READ prop2 WRITE setProp2);
+public:
+    Interface3(QObject *parent) : QDBusAbstractAdaptor(parent)
+    { setAutoRelaySignals(true); }
+
+    QString prop1() const
+    { return __PRETTY_FUNCTION__; }
+
+    QString prop2() const
+    { return __PRETTY_FUNCTION__; }
+
+    void setProp2(const QString &value)
+    { slotSpy = __PRETTY_FUNCTION__; propSpy = value; }
+
+    void emitSignal(const QString &name, const QVariant &value)
+    {
+        if (name == "signalVoid")
+            emit signalVoid();
+        else if (name == "signalInt")
+            emit signalInt(value.toInt());
+        else if (name == "signalString")
+            emit signalString(value.toString());
+    }
+
+public slots:
+    void methodVoid() { slotSpy = __PRETTY_FUNCTION__; }
+    void methodInt(int) { slotSpy = __PRETTY_FUNCTION__; }
+    void methodString(QString) { slotSpy = __PRETTY_FUNCTION__; }
+
+signals:
+    void signalVoid();
+    void signalInt(int);
+    void signalString(const QString &);
+
+public:
+    static QDBusIntrospection::Methods methodData;
+    static QDBusIntrospection::Signals signalData;
+    static QDBusIntrospection::Properties propertyData;    
+};
+
+class Interface4: public QDBusAbstractAdaptor
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", "local.Interface4");
+    Q_PROPERTY(QString prop1 READ prop1);
+    Q_PROPERTY(QString prop2 READ prop2 WRITE setProp2);
+public:
+    Interface4(QObject *parent) : QDBusAbstractAdaptor(parent)
+    { setAutoRelaySignals(true); }
+
+    QString prop1() const
+    { return __PRETTY_FUNCTION__; }
+
+    QString prop2() const
+    { return __PRETTY_FUNCTION__; }
+
+    void setProp2(const QString &value)
+    { slotSpy = __PRETTY_FUNCTION__; propSpy = value; }
+
+    void emitSignal(const QString &, const QVariant &value)
+    {
+        switch (value.type())
+        {
+        case QVariant::Invalid:
+            emit signal();
+            break;
+        case QVariant::Int:
+            emit signal(value.toInt());
+            break;
+        case QVariant::String:
+            emit signal(value.toString());
+            break;
+        default:
+            break;
+        }
+    }
+
+public slots:
+    void method() { slotSpy = __PRETTY_FUNCTION__; }
+    void method(int) { slotSpy = __PRETTY_FUNCTION__; }
+    void method(QString) { slotSpy = __PRETTY_FUNCTION__; }
+
+signals:
+    void signal();
+    void signal(int);
+    void signal(const QString &);
+
+public:
+    static QDBusIntrospection::Methods methodData;
+    static QDBusIntrospection::Signals signalData;
+    static QDBusIntrospection::Properties propertyData;    
+};
+
+
+QDBusIntrospection::Methods Interface1::methodData;
+QDBusIntrospection::Signals Interface1::signalData;
+QDBusIntrospection::Properties Interface1::propertyData;    
+QDBusIntrospection::Methods Interface2::methodData;
+QDBusIntrospection::Signals Interface2::signalData;
+QDBusIntrospection::Properties Interface2::propertyData;    
+QDBusIntrospection::Methods Interface3::methodData;
+QDBusIntrospection::Signals Interface3::signalData;
+QDBusIntrospection::Properties Interface3::propertyData;    
+QDBusIntrospection::Methods Interface4::methodData;
+QDBusIntrospection::Signals Interface4::signalData;
+QDBusIntrospection::Properties Interface4::propertyData;
+
+void tst_QDBusAbstractAdaptor::initTestCase()
+{
+    QDBusIntrospection::Method method;
+    method.name = "Method";
+    Interface2::methodData << method;
+    Interface4::methodData << method;
+    method.inputArgs << arg("i");
+    Interface4::methodData << method;
+    method.inputArgs.clear();
+    method.inputArgs << arg("s");
+    Interface4::methodData << method;
+
+    method.name = "MethodVoid";
+    method.inputArgs.clear();
+    Interface3::methodData << method;
+    method.name = "MethodInt";
+    method.inputArgs << arg("i");
+    Interface3::methodData << method;
+    method.name = "MethodString";
+    method.inputArgs.clear();
+    method.inputArgs << arg("s");
+    Interface3::methodData << method;
+
+    QDBusIntrospection::Signal signal;
+    signal.name = "Signal";
+    Interface2::signalData << signal;
+    Interface4::signalData << signal;
+    signal.outputArgs << arg("i");
+    Interface4::signalData << signal;
+    signal.outputArgs.clear();
+    signal.outputArgs << arg("s");
+    Interface4::signalData << signal;
+
+    signal.name = "SignalVoid";
+    signal.outputArgs.clear();
+    Interface3::signalData << signal;
+    signal.name = "SignalInt";
+    signal.outputArgs << arg("i");
+    Interface3::signalData << signal;
+    signal.name = "SignalString";
+    signal.outputArgs.clear();
+    signal.outputArgs << arg("s");
+    Interface3::signalData << signal;
+
+    QDBusIntrospection::Property prop;
+    prop.name = "Prop1";
+    prop.type = QDBusType('s');
+    prop.access = QDBusIntrospection::Property::Read;
+    Interface2::propertyData << prop;
+    Interface3::propertyData << prop;
+    Interface4::propertyData << prop;
+    prop.name = "Prop2";
+    prop.access = QDBusIntrospection::Property::ReadWrite;
+    Interface2::propertyData << prop;
+    Interface3::propertyData << prop;
+    Interface4::propertyData << prop;
+}
+
+void tst_QDBusAbstractAdaptor::methodCalls_data()
+{
+    QTest::addColumn<int>("nInterfaces");
+    QTest::newRow("0") << 0;
+    QTest::newRow("1") << 1;
+    QTest::newRow("2") << 2;
+    QTest::newRow("3") << 3;
+    QTest::newRow("4") << 4;
+}
+
+void tst_QDBusAbstractAdaptor::methodCalls()
+{
+    QDBusConnection &con = QDBus::sessionBus();
+    QVERIFY(con.isConnected());
+
+    QDBusObject dobj = con.findObject(con.baseService(), "/");
+    QVERIFY(dobj.isValid());
+
+    //QDBusInterface empty(dobj, QString());
+    QDBusInterface if1(dobj, "local.Interface1");
+    QDBusInterface if2(dobj, "local.Interface2");
+    QDBusInterface if3(dobj, "local.Interface3");
+    QDBusInterface if4(dobj, "local.Interface4");
+
+    // must fail: no object
+    //QCOMPARE(empty.call("method").type(), QDBusMessage::ErrorMessage);
+    QCOMPARE(if1.call("method").type(), QDBusMessage::ErrorMessage);
+
+    QObject obj;
+    con.registerObject("/", &obj);
+
+    QFETCH(int, nInterfaces);
+    switch (nInterfaces)
+    {
+    case 4:
+        new Interface4(&obj);
+    case 3:
+        new Interface3(&obj);
+    case 2:
+        new Interface2(&obj);
+    case 1:
+        new Interface1(&obj);
+    }
+
+    // must fail: no such method
+    QCOMPARE(if1.call("method").type(), QDBusMessage::ErrorMessage);
+    if (!nInterfaces--)
+        return;
+    if (!nInterfaces--)
+        return;
+
+    // simple call: one such method exists
+    QCOMPARE(if2.call("method").type(), QDBusMessage::ReplyMessage);
+    QCOMPARE(slotSpy, "void Interface2::method()");
+    if (!nInterfaces--)
+        return;
+
+    // multiple methods in multiple interfaces, no name overlap
+    QCOMPARE(if1.call("methodVoid").type(), QDBusMessage::ErrorMessage);
+    QCOMPARE(if1.call("methodInt").type(), QDBusMessage::ErrorMessage);
+    QCOMPARE(if1.call("methodString").type(), QDBusMessage::ErrorMessage);
+    QCOMPARE(if2.call("methodVoid").type(), QDBusMessage::ErrorMessage);
+    QCOMPARE(if2.call("methodInt").type(), QDBusMessage::ErrorMessage);
+    QCOMPARE(if2.call("methodString").type(), QDBusMessage::ErrorMessage);
+
+    QCOMPARE(if3.call("methodVoid").type(), QDBusMessage::ReplyMessage);
+    QCOMPARE(slotSpy, "void Interface3::methodVoid()");
+    QCOMPARE(if3.call("methodInt", 42).type(), QDBusMessage::ReplyMessage);
+    QCOMPARE(slotSpy, "void Interface3::methodInt(int)");
+    QCOMPARE(if3.call("methodString", QString("")).type(), QDBusMessage::ReplyMessage);
+    QCOMPARE(slotSpy, "void Interface3::methodString(QString)");
+
+    if (!nInterfaces--)
+        return;
+
+    // method overloading: different interfaces
+    QCOMPARE(if4.call("method").type(), QDBusMessage::ReplyMessage);
+    QCOMPARE(slotSpy, "void Interface4::method()");
+
+    // method overloading: different parameters
+    QCOMPARE(if4.call("method.i", 42).type(), QDBusMessage::ReplyMessage);
+    QCOMPARE(slotSpy, "void Interface4::method(int)");
+    QCOMPARE(if4.call("method.s", QString()).type(), QDBusMessage::ReplyMessage);
+    QCOMPARE(slotSpy, "void Interface4::method(QString)");
+    
+}
+
+static void emitSignal(QDBusConnection &con, const QString &iface, const QString &name,
+                       const QVariant &parameter)
+{
+    QObject obj;
+    Interface2 *if2 = new Interface2(&obj);
+    Interface3 *if3 = new Interface3(&obj);
+    Interface4 *if4 = new Interface4(&obj);
+    con.registerObject("/",&obj);
+
+    if (iface.endsWith('2'))
+        if2->emitSignal(name, parameter);
+    else if (iface.endsWith('3'))
+        if3->emitSignal(name, parameter);
+    else if (iface.endsWith('4'))
+        if4->emitSignal(name, parameter);
+    
+    QTest::qWait(200);
+}
+
+void tst_QDBusAbstractAdaptor::signalEmissions_data()
+{
+    QTest::addColumn<QString>("interface");
+    QTest::addColumn<QString>("name");
+    QTest::addColumn<QString>("signature");
+    QTest::addColumn<QVariant>("parameter");
+
+    QTest::newRow("Interface2.signal") << "local.Interface2" << "signal" << QString() << QVariant();
+    QTest::newRow("Interface3.signalVoid") << "local.Interface3" << "signalVoid" << QString() << QVariant();
+    QTest::newRow("Interface3.signalInt") << "local.Interface3" << "signalInt" << "i" << QVariant(1);
+    QTest::newRow("Interface3.signalString") << "local.Interface3" << "signalString" << "s" << QVariant("foo");
+}
+
+void tst_QDBusAbstractAdaptor::signalEmissions()
+{
+    QFETCH(QString, interface);
+    QFETCH(QString, name);
+    QFETCH(QVariant, parameter);
+
+    QDBusConnection &con = QDBus::sessionBus();
+    QVERIFY(con.isConnected());
+
+    QDBusObject dobj = con.findObject(con.baseService(), "/");
+    QVERIFY(dobj.isValid());
+
+    //QDBusInterface empty(dobj, QString());
+    QDBusInterface if2(dobj, "local.Interface2");
+    QDBusInterface if3(dobj, "local.Interface3");
+
+    // connect all signals and emit only one
+    {
+        QDBusSignalSpy spy;
+        if2.connect("signal", &spy, SLOT(slot(QDBusMessage)));
+        if3.connect("signalVoid", &spy, SLOT(slot(QDBusMessage)));
+        if3.connect("signalInt", &spy, SLOT(slot(QDBusMessage)));
+        if3.connect("signalString", &spy, SLOT(slot(QDBusMessage)));
+        
+        emitSignal(con, interface, name, parameter);
+        
+        QCOMPARE(spy.count, 1);
+        QCOMPARE(spy.interface, interface);
+        QCOMPARE(spy.name, name);
+        QTEST(spy.signature, "signature");
+        QCOMPARE(spy.value, parameter);
+    }
+
+    // connect one signal and emit them all
+    {
+        QDBusSignalSpy spy;
+        con.connect(con.baseService(), "/", interface, name, &spy, SLOT(slot(QDBusMessage)));
+        emitSignal(con, "local.Interface2", "signal", QVariant());
+        emitSignal(con, "local.Interface3", "signalVoid", QVariant());
+        emitSignal(con, "local.Interface3", "signalInt", QVariant(1));
+        emitSignal(con, "local.Interface3", "signalString", QVariant("foo"));
+        
+        QCOMPARE(spy.count, 1);
+        QCOMPARE(spy.interface, interface);
+        QCOMPARE(spy.name, name);
+        QTEST(spy.signature, "signature");
+        QCOMPARE(spy.value, parameter);
+    }
+}
+
+void tst_QDBusAbstractAdaptor::sameSignalDifferentPaths()
+{
+    QDBusConnection &con = QDBus::sessionBus();
+    QVERIFY(con.isConnected());
+
+    QObject obj;
+    Interface2 *if2 = new Interface2(&obj);
+
+    con.registerObject("/p1",&obj);
+    con.registerObject("/p2",&obj);
+
+    QDBusSignalSpy spy;
+    con.connect(con.baseService(), "/p1", "local.Interface2", "signal", &spy, SLOT(slot(QDBusMessage)));
+    if2->emitSignal(QString(), QVariant());
+    QTest::qWait(200);
+    
+    QCOMPARE(spy.count, 1);
+    QCOMPARE(spy.interface, QString("local.Interface2"));
+    QCOMPARE(spy.name, QString("signal"));
+    QVERIFY(spy.signature.isEmpty());
+
+    // now connect the other one
+    spy.count = 0;
+    con.connect(con.baseService(), "/p2", "local.Interface2", "signal", &spy, SLOT(slot(QDBusMessage)));
+    if2->emitSignal(QString(), QVariant());
+    QTest::qWait(200);
+    
+    QCOMPARE(spy.count, 2);
+}
+
+void tst_QDBusAbstractAdaptor::overloadedSignalEmission_data()
+{
+    QTest::addColumn<QString>("signature");
+    QTest::addColumn<QVariant>("parameter");
+    QTest::newRow("void") << QString("") << QVariant();
+    QTest::newRow("int") << "i" << QVariant(1);
+    QTest::newRow("string") << "s" << QVariant("foo");
+}
+
+void tst_QDBusAbstractAdaptor::overloadedSignalEmission()
+{
+    QDBusConnection &con = QDBus::sessionBus();
+    QVERIFY(con.isConnected());
+
+    QString interface = "local.Interface4";
+    QString name = "signal";
+    QFETCH(QVariant, parameter);
+    QDBusInterface if4 = con.findInterface(con.baseService(), "/", interface);
+    
+    // connect all signals and emit only one
+    {
+        QDBusSignalSpy spy;
+        if4.connect("signal.", &spy, SLOT(slot(QDBusMessage)));
+        if4.connect("signal.i", &spy, SLOT(slot(QDBusMessage)));
+        if4.connect("signal.s", &spy, SLOT(slot(QDBusMessage)));
+        
+        emitSignal(con, interface, name, parameter);
+        
+        QCOMPARE(spy.count, 1);
+        QCOMPARE(spy.interface, interface);
+        QCOMPARE(spy.name, name);
+        QTEST(spy.signature, "signature");
+        QCOMPARE(spy.value, parameter);
+    }
+
+    QFETCH(QString, signature);
+    // connect one signal and emit them all
+    {
+        QDBusSignalSpy spy;
+        con.connect(con.baseService(), "/", interface, name, signature, &spy, SLOT(slot(QDBusMessage)));
+        emitSignal(con, "local.Interface4", "signal", QVariant());
+        emitSignal(con, "local.Interface4", "signal", QVariant(1));
+        emitSignal(con, "local.Interface4", "signal", QVariant("foo"));
+        
+        QCOMPARE(spy.count, 1);
+        QCOMPARE(spy.interface, interface);
+        QCOMPARE(spy.name, name);
+        QTEST(spy.signature, "signature");
+        QCOMPARE(spy.value, parameter);
+    }
+}    
+
+void tst_QDBusAbstractAdaptor::readProperties()
+{
+    QDBusConnection &con = QDBus::sessionBus();
+    QVERIFY(con.isConnected());
+
+    QObject obj;
+    new Interface2(&obj);
+    new Interface3(&obj);
+    new Interface4(&obj);
+    con.registerObject("/", &obj);
+
+    for (int i = 2; i <= 4; ++i) {
+        QString name = QString("Interface%1").arg(i);
+        QDBusInterface iface = con.findInterface(con.baseService(), "/", "local." + name);
+
+        for (int j = 1; j <= 2; ++j) {
+            QString propname = QString("prop%1").arg(j);
+            QDBusVariant value = iface.property(propname);
+
+            QVERIFY(value.type == QDBusType('s'));
+            QVERIFY(value.value.type() == QVariant::String);
+            QCOMPARE(value.value.toString(), QString("QString %1::%2() const").arg(name, propname));
+        }
+    }
+}
+
+void tst_QDBusAbstractAdaptor::writeProperties()
+{
+    QDBusConnection &con = QDBus::sessionBus();
+    QVERIFY(con.isConnected());
+
+    QObject obj;
+    new Interface2(&obj);
+    new Interface3(&obj);
+    new Interface4(&obj);
+    con.registerObject("/", &obj);
+
+    for (int i = 2; i <= 4; ++i) {
+        QString name = QString("Interface%1").arg(i);
+        QDBusInterface iface = con.findInterface(con.baseService(), "/", "local." + name);
+
+        QDBusVariant value(name);
+
+        propSpy.clear();
+        iface.setProperty("prop1", value);
+        QVERIFY(propSpy.isEmpty()); // call mustn't have succeeded
+
+        iface.setProperty("prop2", value);
+        QCOMPARE(propSpy, name);
+        QCOMPARE(QString(slotSpy), QString("void %1::setProp2(const QString&)").arg(name));
+    }
+}
+
+void tst_QDBusAbstractAdaptor::adaptorIntrospection_data()
+{
+    methodCalls_data();
+}
+
+void tst_QDBusAbstractAdaptor::adaptorIntrospection()
+{
+    QDBusConnection &con = QDBus::sessionBus();
+    QVERIFY(con.isConnected());
+
+    QObject obj;
+    con.registerObject("/", &obj);
+
+    QFETCH(int, nInterfaces);
+    switch (nInterfaces)
+    {
+    case 4:
+        new Interface4(&obj);
+    case 3:
+        new Interface3(&obj);
+    case 2:
+        new Interface2(&obj);
+    case 1:
+        new Interface1(&obj);
+    }
+
+    QDBusObject dobj = con.findObject(con.baseService(), "/");
+    QVERIFY(dobj.isValid());
+
+    QString xml = dobj.introspect();
+    QVERIFY(!xml.isEmpty());
+
+    QStringList interfaces = dobj.interfaces();
+    QCOMPARE(interfaces.count(), nInterfaces + 2);
+    switch (nInterfaces)
+    {
+    case 4: {
+        QVERIFY(interfaces.contains("local.Interface4"));
+        QDBusInterface iface(dobj, "local.Interface4");
+        QCOMPARE(iface.methodData(), Interface4::methodData);
+        QCOMPARE(iface.signalData(), Interface4::signalData);
+        QCOMPARE(iface.propertyData(), Interface4::propertyData);
+    }
+    case 3: {
+        QVERIFY(interfaces.contains("local.Interface3"));
+        QDBusInterface iface(dobj, "local.Interface3");
+        QCOMPARE(iface.methodData(), Interface3::methodData);
+        QCOMPARE(iface.signalData(), Interface3::signalData);
+        QCOMPARE(iface.propertyData(), Interface3::propertyData);
+    }
+    case 2: {
+        QVERIFY(interfaces.contains("local.Interface2"));
+        QDBusInterface iface(dobj, "local.Interface2");
+        QCOMPARE(iface.methodData(), Interface2::methodData);
+        QCOMPARE(iface.signalData(), Interface2::signalData);
+        QCOMPARE(iface.propertyData(), Interface2::propertyData);
+    }
+    case 1: {
+        QVERIFY(interfaces.contains("local.Interface1"));
+        QDBusInterface iface(dobj, "local.Interface1");
+        QCOMPARE(iface.methodData(), Interface1::methodData);
+        QCOMPARE(iface.signalData(), Interface1::signalData);
+        QCOMPARE(iface.propertyData(), Interface1::propertyData);
+    }
+    }
+}
+
+void tst_QDBusAbstractAdaptor::objectTreeIntrospection()
+{
+    QDBusConnection &con = QDBus::sessionBus();
+    QVERIFY(con.isConnected());
+
+    {
+        QDBusObject dobj = con.findObject(con.baseService(), "/");
+        QString xml = dobj.introspect();
+
+        QDBusIntrospection::Object tree =
+            QDBusIntrospection::parseObject(xml);
+        QVERIFY(tree.childObjects.isEmpty());
+    }
+
+    QObject root;
+    con.registerObject("/", &root);
+    {
+        QDBusObject dobj = con.findObject(con.baseService(), "/");
+        QString xml = dobj.introspect();
+
+        QDBusIntrospection::Object tree =
+            QDBusIntrospection::parseObject(xml);
+        QVERIFY(tree.childObjects.isEmpty());
+    }
+
+    QObject p1;
+    con.registerObject("/p1", &p1);
+    {
+        QDBusObject dobj = con.findObject(con.baseService(), "/");
+        QString xml = dobj.introspect();
+
+        QDBusIntrospection::Object tree =
+            QDBusIntrospection::parseObject(xml);
+        QVERIFY(tree.childObjects.contains("p1"));
+    }
+
+    con.unregisterObject("/");
+    {
+        QDBusObject dobj = con.findObject(con.baseService(), "/");
+        QString xml = dobj.introspect();
+
+        QDBusIntrospection::Object tree =
+            QDBusIntrospection::parseObject(xml);
+        QVERIFY(tree.childObjects.contains("p1"));
+    }
+
+    con.registerObject("/p1/q/r", &root);    
+    {
+        QDBusObject dobj = con.findObject(con.baseService(), "/p1");
+        QString xml = dobj.introspect();
+
+        QDBusIntrospection::Object tree =
+            QDBusIntrospection::parseObject(xml);
+        QVERIFY(tree.childObjects.contains("q"));
+    }
+    {
+        QDBusObject dobj = con.findObject(con.baseService(), "/p1/q");
+        QString xml = dobj.introspect();
+
+        QDBusIntrospection::Object tree =
+            QDBusIntrospection::parseObject(xml);
+        QVERIFY(tree.childObjects.contains("r"));
+    }
+
+    con.unregisterObject("/p1", QDBusConnection::UnregisterTree);
+    {
+        QDBusObject dobj = con.findObject(con.baseService(), "/");
+        QString xml = dobj.introspect();
+
+        QDBusIntrospection::Object tree =
+            QDBusIntrospection::parseObject(xml);
+        QVERIFY(tree.childObjects.isEmpty());
+    }
+
+    QObject p2;
+    con.registerObject("/p2", &p2, QDBusConnection::ExportChildObjects);
+    {
+        QDBusObject dobj = con.findObject(con.baseService(), "/");
+        QString xml = dobj.introspect();
+
+        QDBusIntrospection::Object tree =
+            QDBusIntrospection::parseObject(xml);
+        QVERIFY(!tree.childObjects.contains("p1"));
+        QVERIFY(tree.childObjects.contains("p2"));
+    }
+    
+    QObject q;
+    q.setParent(&p2);
+    {
+        QDBusObject dobj = con.findObject(con.baseService(), "/p2");
+        QString xml = dobj.introspect();
+
+        QDBusIntrospection::Object tree =
+            QDBusIntrospection::parseObject(xml);
+        QVERIFY(!tree.childObjects.contains("q"));
+    }
+
+    q.setObjectName("q");
+    {
+        QDBusObject dobj = con.findObject(con.baseService(), "/p2");
+        QString xml = dobj.introspect();
+
+        QDBusIntrospection::Object tree =
+            QDBusIntrospection::parseObject(xml);
+        QVERIFY(tree.childObjects.contains("q"));
+    }
+
+    q.setParent(0);
+    {
+        QDBusObject dobj = con.findObject(con.baseService(), "/p2");
+        QString xml = dobj.introspect();
+
+        QDBusIntrospection::Object tree =
+            QDBusIntrospection::parseObject(xml);
+        QVERIFY(!tree.childObjects.contains("q"));
+    }
+}    
+
+QTEST_MAIN(tst_QDBusAbstractAdaptor)
+
+#include "tst_qdbusabstractadaptor.moc"