INCLUDES=-I$(top_srcdir) -I$(top_srcdir)/qt $(DBUS_CLIENT_CFLAGS) $(DBUS_QT_CFLAGS) $(DBUS_QTESTLIB_CFLAGS) -DDBUS_COMPILATION
if DBUS_BUILD_TESTS
-TEST_BINARIES=qdbusconnection
+TEST_BINARIES=qdbusconnection qdbusobject qdbusinterface qdbustype qdbusxmlparser hal
TESTS=
else
TEST_BINARIES=
noinst_PROGRAMS= $(TEST_BINARIES)
-qdbusconnection_SOURCES= \
- tst_qdbusconnection.cpp
+qdbusconnection_SOURCES= tst_qdbusconnection.cpp
+qdbusobject_SOURCES= tst_qdbusobject.cpp
+qdbusinterface_SOURCES= tst_qdbusinterface.cpp
+qdbustype_SOURCES= tst_qdbustype.cpp
+qdbusxmlparser_SOURCES= tst_qdbusxmlparser.cpp
+hal_SOURCES = tst_hal.cpp
-tst_qdbusconnection.cpp: tst_qdbusconnection.moc
+tst_qdbusconnection.o: tst_qdbusconnection.moc
+tst_qdbusobject.o: tst_qdbusobject.moc
+tst_qdbusinterface.o: tst_qdbusinterface.moc
+tst_qdbustype.o: tst_qdbustype.moc
+tst_qdbusxmlparser.o: tst_qdbusxmlparser.moc
+tst_hal.o: tst_hal.moc
-tst_qdbusconnection.moc:
- $(QT_MOC) $(srcdir)/tst_qdbusconnection.cpp > tst_qdbusconnection.moc
+%.moc: %.cpp
+ $(QT_MOC) $< > $@
TEST_LIBS=$(DBUS_QTESTLIB_LIBS) $(top_builddir)/qt/libdbus-qt4-1.la
-qdbusconnection_LDADD=$(TEST_LIBS)
+LDADD=$(TEST_LIBS)
CLEANFILES=tst_qdbusconnection.moc
--- /dev/null
+#include <qcoreapplication.h>
+#include <qdebug.h>
+
+#include <QtTest/QtTest>
+#include <dbus/qdbus.h>
+
+class tst_Hal: public QObject
+{
+ Q_OBJECT
+
+private slots:
+ void getDevices();
+ void lock();
+};
+
+class Spy: public QObject
+{
+ Q_OBJECT
+public:
+ int count;
+ QDBusConnection conn;
+
+ Spy(QDBusConnection c) : count(0), conn(c)
+ { }
+
+public slots:
+ void spySlot(int, const QVariantList&)
+ {
+ ++count;
+ QDBusMessage msg = QDBusMessage::methodCall("org.freedesktop.Hal",
+ "/org/freedesktop/Hal/devices/acpi_CPU0",
+ "org.freedesktop.Hal.Device", "GetProperty");
+ msg << "info.locked";
+
+ QDBusMessage reply = conn.sendWithReply(msg);
+ QVERIFY(!reply.isEmpty());
+ }
+};
+
+
+void tst_Hal::getDevices()
+{
+ QDBusConnection con = QDBusConnection::addConnection(QDBusConnection::SystemBus);
+ QVERIFY(con.isConnected());
+
+ QDBusMessage msg = QDBusMessage::methodCall("org.freedesktop.Hal",
+ "/org/freedesktop/Hal/Manager", "org.freedesktop.Hal.Manager",
+ "GetAllDevices");
+
+ QDBusMessage reply = con.sendWithReply(msg);
+ QVERIFY(!reply.isEmpty());
+ qDebug() << reply;
+}
+
+void tst_Hal::lock()
+{
+ QDBusConnection con = QDBusConnection::addConnection(QDBusConnection::SystemBus);
+ QVERIFY(con.isConnected());
+
+ Spy spy( con );
+
+ con.connect("org.freedesktop.Hal", "/org/freedesktop/Hal/devices/acpi_CPU0",
+ "org.freedesktop.Hal.Device", "PropertyModified",
+ &spy, SLOT(spySlot(int, QVariantList)));
+ QDBusMessage msg = QDBusMessage::methodCall("org.freedesktop.Hal",
+ "/org/freedesktop/Hal/devices/acpi_CPU0", "org.freedesktop.Hal.Device",
+ "Lock");
+ msg << "No reason...";
+
+ QDBusMessage reply = con.sendWithReply(msg);
+ qDebug() << reply;
+ QCOMPARE(spy.count, 3);
+ QCOMPARE(reply.type(), QDBusMessage::ReplyMessage);
+}
+
+QTEST_MAIN(tst_Hal)
+
+#include "tst_hal.moc"
Q_OBJECT
private slots:
+ void init();
+ void cleanupTestCase();
void addConnection();
void connect();
void send();
void sendAsync();
void sendSignal();
+ void requestName_data();
+ void requestName();
+ void getNameOwner_data();
+ void getNameOwner();
+ void releaseName_data();
+ void releaseName();
};
class QDBusSpy: public QObject
int serial;
};
+void tst_QDBusConnection::init()
+{
+ if (qstrcmp(QTest::currentTestFunction(), "addConnection") == 0)
+ return;
+
+ QDBusConnection::addConnection(QDBusConnection::SessionBus);
+ QVERIFY(QDBusConnection().isConnected());
+}
+
+void tst_QDBusConnection::cleanupTestCase()
+{
+ QDBusConnection::closeConnection();
+
+ QVERIFY(!QDBusConnection().isConnected());
+}
+
void tst_QDBusConnection::sendSignal()
{
- QDBusConnection con = QDBusConnection::addConnection(
- QDBusConnection::SessionBus);
+ QDBusConnection con;
QVERIFY(con.isConnected());
void tst_QDBusConnection::send()
{
- QDBusConnection con = QDBusConnection::addConnection(
- QDBusConnection::SessionBus);
+ QDBusConnection con;
QVERIFY(con.isConnected());
void tst_QDBusConnection::sendAsync()
{
- QDBusConnection con = QDBusConnection::addConnection(QDBusConnection::SessionBus);
+ QDBusConnection con;
QVERIFY(con.isConnected());
QDBusSpy spy;
{
QDBusSpy spy;
- QDBusConnection con = QDBusConnection::addConnection(
- QDBusConnection::SessionBus);
+ QDBusConnection con;
- con.connect("/org/kde/selftest", "org.kde.selftest", "ping", &spy,
+ con.connect(con.baseService(), "/org/kde/selftest", "org.kde.selftest", "ping", &spy,
SLOT(handlePing(QString)));
QDBusMessage msg = QDBusMessage::signal("/org/kde/selftest", "org.kde.selftest",
}
}
+void tst_QDBusConnection::requestName_data()
+{
+ QTest::addColumn<QString>("requestedName");
+ QTest::addColumn<int>("flags");
+ QTest::addColumn<bool>("expectedResult");
+
+ QTest::newRow("null") << QString() << (int)QDBusConnection::NoReplace << false;
+ QTest::newRow("empty") << QString("") << (int)QDBusConnection::NoReplace << false;
+ QTest::newRow("invalid") << "./invalid name" << (int)QDBusConnection::NoReplace << false;
+// QTest::newRow("existing") << "org.freedesktop.DBus"
+// << (int)QDBusConnection::NoReplace << false;
+
+ QTest::newRow("ok1") << "com.trolltech.QtDBUS.tst_qdbusconnection"
+ << (int)QDBusConnection::NoReplace << true;
+}
+
+void tst_QDBusConnection::requestName()
+{
+ QDBusConnection con;
+
+ QVERIFY(con.isConnected());
+
+ QFETCH(QString, requestedName);
+ QFETCH(int, flags);
+ QFETCH(bool, expectedResult);
+
+ bool result = con.requestName(requestedName, (QDBusConnection::NameRequestMode)flags);
+
+// QEXPECT_FAIL("existing", "For whatever reason, the bus lets us replace this name", Abort);
+ QCOMPARE(result, expectedResult);
+}
+
+void tst_QDBusConnection::getNameOwner_data()
+{
+ QTest::addColumn<QString>("name");
+ QTest::addColumn<QString>("expectedResult");
+
+ QTest::newRow("null") << QString() << QString();
+ QTest::newRow("empty") << QString("") << QString();
+
+ QTest::newRow("invalid") << ".invalid" << QString();
+ QTest::newRow("non-existent") << "com.trolltech.QtDBUS.foo" << QString();
+
+ QTest::newRow("bus") << "org.freedesktop.DBus" << "org.freedesktop.DBus";
+
+ QString base = QDBusConnection().baseService();
+ QTest::newRow("address") << base << base;
+ QTest::newRow("self") << "com.trolltech.QtDBUS.tst_qdbusconnection" << base;
+}
+
+void tst_QDBusConnection::getNameOwner()
+{
+ QFETCH(QString, name);
+ QFETCH(QString, expectedResult);
+
+ QDBusConnection con;
+ QVERIFY(con.isConnected());
+
+ QString result = con.getNameOwner(name);
+
+ QCOMPARE(result, expectedResult);
+}
+
+void tst_QDBusConnection::releaseName_data()
+{
+ requestName_data();
+}
+
+void tst_QDBusConnection::releaseName()
+{
+ QDBusConnection con;
+
+ QVERIFY(con.isConnected());
+
+ QFETCH(QString, requestedName);
+ //QFETCH(int, flags);
+ QFETCH(bool, expectedResult);
+
+ bool result = con.releaseName(requestedName);
+
+ QCOMPARE(result, expectedResult);
+}
+
QTEST_MAIN(tst_QDBusConnection)
#include "tst_qdbusconnection.moc"
--- /dev/null
+/* -*- C++ -*-
+ *
+ * Copyright (C) 2006 Trolltech AS. All rights reserved.
+ * Author: Thiago Macieira <thiago.macieira@trolltech.com>
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+#include <qcoreapplication.h>
+#include <qmetatype.h>
+#include <QtTest/QtTest>
+
+#include <dbus/qdbus.h>
+#include <QtCore/qvariant.h>
+
+Q_DECLARE_METATYPE(QVariantList)
+
+#define TEST_INTERFACE_NAME "com.trolltech.QtDBus.MyObject"
+#define TEST_SERVICE_NAME "com.trolltech.QtDBus.tst_qdbusinterface"
+#define TEST_SIGNAL_NAME "somethingHappened"
+
+const char introspectionData[] =
+ "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n"
+ "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
+ "<node>"
+
+ "<interface name=\"org.freedesktop.DBus.Introspectable\">"
+ "<method name=\"Introspect\">"
+ "<arg name=\"data\" direction=\"out\" type=\"s\"/>"
+ "</method>"
+ "</interface>"
+
+ "<interface name=\"" TEST_INTERFACE_NAME "\">"
+ "<method name=\"ping\">"
+ "<arg name=\"ping\" direction=\"in\" type=\"v\"/>"
+ "<arg name=\"pong\" direction=\"out\" type=\"v\"/>"
+ "</method>"
+ "<method name=\"ping\">"
+ "<arg name=\"ping1\" direction=\"in\" type=\"v\"/>"
+ "<arg name=\"ping2\" direction=\"in\" type=\"v\"/>"
+ "<arg name=\"pong1\" direction=\"out\" type=\"v\"/>"
+ "<arg name=\"pong2\" direction=\"out\" type=\"v\"/>"
+ "</method>"
+ "<signal name=\"" TEST_SIGNAL_NAME "\">"
+ "<arg type=\"s\"/>"
+ "</signal>"
+ "<property name=\"prop1\" access=\"readwrite\" type=\"i\" />"
+ "</interface>"
+ "<node name=\"subObject\"/>"
+ "</node>";
+
+class MyObject: public QObject
+{
+ Q_OBJECT
+public slots:
+
+ void ping(const QDBusMessage &msg)
+ {
+ QDBusConnection con = QDBusConnection::addConnection(QDBusConnection::SessionBus);
+ QDBusMessage reply = QDBusMessage::methodReply(msg);
+ reply << static_cast<QList<QVariant> >(msg);
+ if (!con.send(reply))
+ exit(1);
+ }
+
+ void Introspect(const QDBusMessage &msg)
+ {
+ QDBusConnection con = QDBusConnection::addConnection(QDBusConnection::SessionBus);
+ QDBusMessage reply = QDBusMessage::methodReply(msg);
+ reply << ::introspectionData;
+ if (!con.send(reply))
+ exit(1);
+ }
+};
+
+class Spy: public QObject
+{
+ Q_OBJECT
+public:
+ QString received;
+ int count;
+
+ Spy() : count(0)
+ { }
+
+public slots:
+ void spySlot(const QString& arg)
+ {
+ received = arg;
+ ++count;
+ }
+};
+
+// helper function
+void emitSignal(const QString &interface, const QString &name, const QString &arg)
+{
+ QDBusMessage msg = QDBusMessage::signal("/", interface, name);
+ msg << arg;
+ QDBusConnection().send(msg);
+
+ QTest::qWait(200);
+}
+
+class tst_QDBusInterface: public QObject
+{
+ Q_OBJECT
+ MyObject obj;
+private slots:
+ void initTestCase();
+ void cleanupTestCase();
+
+ void call_data();
+ void call();
+
+ void introspect_data();
+ void introspect();
+
+ void signal();
+};
+
+void tst_QDBusInterface::initTestCase()
+{
+ QDBusConnection con = QDBusConnection::addConnection(QDBusConnection::SessionBus);
+ QVERIFY(con.isConnected());
+ QVERIFY(con.requestName( TEST_SERVICE_NAME ));
+
+ con.registerObject("/", "org.freedesktop.DBus.Introspectable", &obj);
+ con.registerObject("/", TEST_INTERFACE_NAME, &obj);
+}
+
+void tst_QDBusInterface::cleanupTestCase()
+{
+ QDBusConnection::closeConnection();
+ QVERIFY(!QDBusConnection().isConnected());
+}
+
+void tst_QDBusInterface::call_data()
+{
+ QTest::addColumn<QString>("method");
+ QTest::addColumn<QVariantList>("input");
+ QTest::addColumn<QVariantList>("output");
+
+ QVariantList input;
+ QTest::newRow("empty") << "ping" << input << input;
+
+ input << qVariantFromValue(1);
+ QTest::newRow("int") << "ping" << input << input;
+ QTest::newRow("int-int") << "ping.i" << input << input;
+ QTest::newRow("int-int16") << "ping.n" << input << input;
+
+ // try doing some conversions
+ QVariantList output;
+ output << qVariantFromValue(1U);
+ QTest::newRow("int-uint") << "ping.u" << input << output;
+ QTest::newRow("int-uint16") << "ping.q" << input << output;
+
+ QTest::newRow("int-int64") << "ping.x" << input << (QVariantList() << qVariantFromValue(1LL));
+ QTest::newRow("int-uint64") << "ping.t" << input << (QVariantList() << qVariantFromValue(1ULL));
+ QTest::newRow("int-double") << "ping.d" << input << (QVariantList() << qVariantFromValue(1.0));
+
+ output.clear();
+ output << QString("1");
+ QTest::newRow("int-string") << "ping.s" << input << output;
+
+ // try from string now
+ input = output;
+ QTest::newRow("string") << "ping" << input << output;
+ QTest::newRow("string-string") << "ping.s" << input << output;
+
+ output.clear();
+ output << qVariantFromValue(1);
+ QTest::newRow("string-int") << "ping.i" << input << input;
+ QTest::newRow("string-int16") << "ping.n" << input << input;
+
+ output.clear();
+ output << qVariantFromValue(1U);
+ QTest::newRow("string-uint") << "ping.u" << input << output;
+ QTest::newRow("string-uint16") << "ping.q" << input << output;
+
+ QTest::newRow("string-int64") << "ping.x" << input << (QVariantList() << qVariantFromValue(1LL));
+ QTest::newRow("string-uint64") << "ping.t" << input << (QVariantList() << qVariantFromValue(1ULL));
+ QTest::newRow("string-double") << "ping.d" << input << (QVariantList() << qVariantFromValue(1.0));
+
+ // two args (must be strings!)
+ input.clear();
+ input << QString("Hello") << QString("World");
+ output = input;
+ QTest::newRow("two-strings") << "ping" << input << output;
+ QTest::newRow("two-strings") << "ping.ss" << input << output;
+
+ // this should drop one of the arguments
+ output.removeLast();
+ QTest::newRow("last-dropped") << "ping.s" << input << output;
+}
+
+void tst_QDBusInterface::call()
+{
+ QDBusConnection con;
+ QDBusInterface iface(con, con.baseService(), QLatin1String("/"),
+ TEST_INTERFACE_NAME);
+
+ QFETCH(QString, method);
+ QFETCH(QVariantList, input);
+ QFETCH(QVariantList, output);
+
+ QDBusMessage reply;
+ // try first callWithArgs:
+ reply = iface.callWithArgs(method, input);
+
+ QCOMPARE(reply.type(), QDBusMessage::ReplyMessage);
+ if (!output.isEmpty()) {
+ QCOMPARE(reply.count(), output.count());
+ QCOMPARE(static_cast<QVariantList>(reply), output);
+ }
+
+ // try the template methods
+ if (input.isEmpty())
+ reply = iface.call(method);
+ else if (input.count() == 1)
+ switch (input.at(0).type())
+ {
+ case QVariant::Int:
+ reply = iface.call(method, input.at(0).toInt());
+ break;
+
+ case QVariant::UInt:
+ reply = iface.call(method, input.at(0).toUInt());
+ break;
+
+ case QVariant::String:
+ reply = iface.call(method, input.at(0).toString());
+ break;
+
+ default:
+ QFAIL("Unknown type. Please update the test case");
+ break;
+ }
+ else
+ reply = iface.call(method, input.at(0).toString(), input.at(1).toString());
+
+ QCOMPARE(reply.type(), QDBusMessage::ReplyMessage);
+ if (!output.isEmpty()) {
+ QCOMPARE(reply.count(), output.count());
+ QCOMPARE(static_cast<QVariantList>(reply), output);
+ }
+}
+
+void tst_QDBusInterface::introspect_data()
+{
+ QTest::addColumn<QString>("service");
+ QTest::newRow("base") << QDBusConnection().baseService();
+ QTest::newRow("name") << TEST_SERVICE_NAME;
+}
+
+void tst_QDBusInterface::introspect()
+{
+ QFETCH(QString, service);
+ QDBusConnection con;
+ QDBusInterface iface(con, service, QLatin1String("/"),
+ TEST_INTERFACE_NAME);
+
+ QDBusIntrospection::Methods mm = iface.methodData();
+ QVERIFY(mm.count() == 2);
+
+ QDBusIntrospection::Signals sm = iface.signalData();
+ QVERIFY(sm.count() == 1);
+ QVERIFY(sm.contains(TEST_SIGNAL_NAME));
+
+ QDBusIntrospection::Properties pm = iface.propertyData();
+ QVERIFY(pm.count() == 1);
+ QVERIFY(pm.contains("prop1"));
+}
+
+void tst_QDBusInterface::signal()
+{
+ QDBusConnection con;
+ QDBusInterface iface(con, con.baseService(), QLatin1String("/"),
+ TEST_INTERFACE_NAME);
+
+ QString signalName = TEST_SIGNAL_NAME;
+
+ QString arg = "So long and thanks for all the fish";
+ {
+ Spy spy;
+ iface.connect(signalName, &spy, SLOT(spySlot(QString)));
+
+ emitSignal(TEST_INTERFACE_NAME, signalName, arg);
+ QVERIFY(spy.count == 1);
+ QCOMPARE(spy.received, arg);
+ }
+
+ QDBusIntrospection::Signals sm = iface.signalData();
+ QVERIFY(sm.contains(signalName));
+
+ const QDBusIntrospection::Signal& signal = sm.value(signalName);
+ QCOMPARE(signal.name, signalName);
+ QVERIFY(!signal.outputArgs.isEmpty());
+ {
+ Spy spy;
+ iface.connect(signal, &spy, SLOT(spySlot(QString)));
+
+ emitSignal(TEST_INTERFACE_NAME, signalName, arg);
+ QVERIFY(spy.count == 1);
+ QCOMPARE(spy.received, arg);
+ }
+}
+
+QTEST_MAIN(tst_QDBusInterface)
+
+#include "tst_qdbusinterface.moc"
+
--- /dev/null
+/* -*- C++ -*-
+ *
+ * Copyright (C) 2006 Trolltech AS. All rights reserved.
+ * Author: Thiago Macieira <thiago.macieira@trolltech.com>
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+#include <qcoreapplication.h>
+#include <qmetatype.h>
+#include <QtTest/QtTest>
+
+#include <dbus/qdbus.h>
+
+const char introspectionData[] =
+ "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n"
+ "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n"
+ "<node>"
+
+ "<interface name=\"org.freedesktop.DBus.Introspectable\">"
+ "<method name=\"Introspect\">"
+ "<arg name=\"data\" direction=\"out\" type=\"s\"/>"
+ "</method>"
+ "</interface>"
+
+ "<interface name=\"com.trolltech.tst_qdbusobject.MyObject\">"
+ "<method name=\"ping\">"
+ "<arg name=\"ping\" direction=\"in\" type=\"v\"/>"
+ "<arg name=\"pong\" direction=\"out\" type=\"v\"/>"
+ "</method>"
+ "</interface>"
+ "<node name=\"subObject\"/>"
+ "</node>";
+
+class MyObject: public QObject
+{
+ Q_OBJECT
+public slots:
+
+ void ping(const QDBusMessage &msg)
+ {
+ QDBusConnection con = QDBusConnection::addConnection(QDBusConnection::SessionBus);
+ QDBusMessage reply = QDBusMessage::methodReply(msg);
+ reply << static_cast<QList<QVariant> >(msg);
+ if (!con.send(reply))
+ exit(1);
+ }
+
+ void Introspect(const QDBusMessage &msg)
+ {
+ QDBusConnection con = QDBusConnection::addConnection(QDBusConnection::SessionBus);
+ QDBusMessage reply = QDBusMessage::methodReply(msg);
+ reply << ::introspectionData;
+ if (!con.send(reply))
+ exit(1);
+ }
+};
+
+class tst_QDBusObject: public QObject
+{
+ Q_OBJECT
+ MyObject obj;
+
+private slots:
+ void initTestCase(); // connect to D-Bus
+ void cleanupTestCase(); // disconnect from D-Bus
+
+ void construction_data();
+ void construction();
+
+ void introspection_data();
+ void introspection();
+};
+
+void tst_QDBusObject::initTestCase()
+{
+ QDBusConnection con = QDBusConnection::addConnection(QDBusConnection::SessionBus);
+ QVERIFY(con.isConnected());
+ QVERIFY(con.requestName("com.trolltech.tst_qdbusobject"));
+
+ con.registerObject("/", "org.freedesktop.DBus.Introspectable", &obj);
+ con.registerObject("/", "com.trolltech.tst_qdbusobject.MyObject", &obj);
+}
+
+void tst_QDBusObject::cleanupTestCase()
+{
+ QDBusConnection::closeConnection();
+ QVERIFY(!QDBusConnection().isConnected());
+}
+
+void tst_QDBusObject::construction_data()
+{
+ QTest::addColumn<QString>("service");
+ QTest::addColumn<QString>("path");
+ QTest::addColumn<bool>("isValid");
+ QTest::addColumn<bool>("exists");
+
+ QTest::newRow("null") << QString() << QString() << false << false;
+
+ QTest::newRow("invalid1") << "foo.foo1" << "" << false << false;
+ QTest::newRow("invalid2") << "foo.foo1" << "foo.bar" << false << false;
+ QTest::newRow("invalid3") << "foo.foo1" << "/foo.bar" << false << false;
+ QTest::newRow("invalid4") << "" << "/" << false << false;
+ QTest::newRow("invalid5") << "foo" << "/" << false << false;
+ QTest::newRow("invalid6") << ".foo" << "/" << false << false;
+
+ QTest::newRow("invalid7") << "org.freedesktop.DBus" << "" << false << false;
+ QTest::newRow("invalid8") << "org.freedesktop.DBus" << "foo.bar" << false << false;
+ QTest::newRow("invalid9") << "org.freedesktop.DBus" << "/foo.bar" << false << false;
+
+ QTest::newRow("existing") << "org.freedesktop.DBus" << "/" << true << true;
+ QTest::newRow("non-existing") << "org.freedesktop.DBus" << "/foo" << true << false;
+}
+
+void tst_QDBusObject::construction()
+{
+ QDBusConnection con; // default
+
+ QFETCH(QString, service);
+ QFETCH(QString, path);
+ QFETCH(bool, isValid);
+ //QFETCH(bool, exists);
+
+ QDBusObject o(con, service, path);
+ QCOMPARE(o.isValid(), isValid);
+
+ if (isValid) {
+ QCOMPARE(o.service(), service);
+ QCOMPARE(o.path(), path);
+ }
+ else {
+ QVERIFY(o.service().isNull());
+ QVERIFY(o.path().isNull());
+ }
+
+ //QCOMPARE(o.exists(), exists);
+}
+
+void tst_QDBusObject::introspection_data()
+{
+ QTest::addColumn<QString>("service");
+ QTest::addColumn<QString>("path");
+ QTest::addColumn<QStringList>("interfaces");
+
+ QStringList interfaces;
+ QTest::newRow("nowhere") << QString() << QString() << interfaces;
+
+ // IMPORTANT!
+ // Keep the interface list sorted!
+ interfaces << "org.freedesktop.DBus" << DBUS_INTERFACE_INTROSPECTABLE;
+ QTest::newRow("server") << "org.freedesktop.DBus" << "/" << interfaces;
+
+ QDBusConnection con;
+ interfaces.clear();
+ interfaces << "com.trolltech.tst_qdbusobject.MyObject" << DBUS_INTERFACE_INTROSPECTABLE;
+
+ QTest::newRow("self1") << con.baseService() << "/" << interfaces;
+ QTest::newRow("self2") << "com.trolltech.tst_qdbusobject" << "/" << interfaces;
+}
+
+void tst_QDBusObject::introspection()
+{
+ QDBusConnection con;
+
+ QFETCH(QString, service);
+ QFETCH(QString, path);
+
+ QDBusObject o(con, service, path);
+
+ if (!o.isValid())
+ QVERIFY(o.introspect().isEmpty());
+ else {
+ QFETCH(QStringList, interfaces);
+ QStringList parsed = o.interfaces();
+ parsed.sort();
+ QCOMPARE(parsed.count(), interfaces.count());
+ QCOMPARE(parsed, interfaces);
+ }
+}
+
+QTEST_MAIN(tst_QDBusObject)
+
+#include "tst_qdbusobject.moc"
+
--- /dev/null
+/* -*- C++ -*-
+ *
+ * Copyright (C) 2006 Trolltech AS. All rights reserved.
+ * Author: Thiago Macieira <thiago.macieira@trolltech.com>
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+#include <qcoreapplication.h>
+#include <QtTest/QtTest>
+
+#include <dbus/qdbus.h>
+
+class tst_QDBusType: public QObject
+{
+ Q_OBJECT
+
+private slots:
+ void fromType_data();
+ void fromType();
+ void fromSignature_data();
+ void fromSignature();
+ void arrayOf_data();
+ void arrayOf();
+ void mapOf_data();
+ void mapOf();
+};
+
+inline QTestData &operator<<(QTestData &data, QVariant::Type t)
+{
+ return data << int(t);
+}
+
+void tst_QDBusType::fromType_data()
+{
+ fromSignature_data();
+}
+
+void tst_QDBusType:: arrayOf_data()
+{
+ fromSignature_data();
+}
+
+void tst_QDBusType::mapOf_data()
+{
+ fromSignature_data();
+}
+
+void tst_QDBusType::fromSignature_data()
+{
+ QTest::addColumn<QString>("signature");
+ QTest::addColumn<char>("type");
+ QTest::addColumn<int>("qvariantType");
+ QTest::addColumn<bool>("isValid");
+ QTest::addColumn<bool>("isBasic");
+ QTest::addColumn<bool>("isContainer");
+ QTest::addColumn<int>("subtypeCount");
+
+ QTest::newRow("null") << QString() << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("empty") << QString("") << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("invalid") << QString("~") << '\0' << QVariant::Invalid << false << false << false << 0;
+
+ // integers:
+ QTest::newRow("byte") << "y" << 'y' << QVariant::UInt << true << true << false << 0;
+ QTest::newRow("boolean") << "b" << 'b' << QVariant::Bool << true << true << false << 0;
+ QTest::newRow("int16") << "n" << 'n' << QVariant::Int << true << true << false << 0;
+ QTest::newRow("uint16") << "q" << 'q' << QVariant::UInt << true << true << false << 0;
+ QTest::newRow("int32") << "i" << 'i' << QVariant::Int << true << true << false << 0;
+ QTest::newRow("uint32") << "u" << 'u' << QVariant::UInt << true << true << false << 0;
+ QTest::newRow("int64") << "x" << 'x' << QVariant::LongLong << true << true << false << 0;
+ QTest::newRow("uint64") << "t" << 't' << QVariant::ULongLong << true << true << false << 0;
+
+ // double:
+ QTest::newRow("double") << "d" << 'd' << QVariant::Double << true << true << false << 0;
+
+ // string types:
+ QTest::newRow("string") << "s" << 's' << QVariant::String << true << true << false << 0;
+ QTest::newRow("objpath") << "o" << 'o' << QVariant::String << true << true << false << 0;
+ QTest::newRow("signature")<<"g" << 'g' << QVariant::String << true << true << false << 0;
+
+ // variant
+ QTest::newRow("variant") << "v" << 'v' << QVariant::UserType << true << false << true << 0;
+
+ // compound types:
+ QTest::newRow("struct-empty") << "()" << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("struct-invalid") << "(~)" << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("struct-unterminated")<< "(iii" << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("struct-bad-nest") << "(i(i)((i)i)" << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("struct1") << "(i)" << 'r' << QVariant::List << true << false << true << 1;
+ QTest::newRow("struct2") << "(ii)" << 'r' << QVariant::List << true << false << true << 2;
+
+ QTest::newRow("array-empty") << "a" << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("array-invalid") << "a~" << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("array-simple") << "ab" << 'a' << QVariant::List << true << false << true << 1;
+ QTest::newRow("bytearray") << "ay" << 'a' << QVariant::ByteArray << true << false << true << 1;
+ QTest::newRow("stringlist") << "as" << 'a' << QVariant::StringList << true << false << true << 1;
+
+ QTest::newRow("map-empty") << "e" << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("map-invalid1") << "a{}" << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("map-invalid2") << "a{~}" << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("map-invalid3") << "a{e}" << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("map-invalid4") << "a{i}" << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("map-invalid5") << "a{(i)d}" << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("map-invalid6") << "{}" << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("map-invalid7") << "{i}" << '\0' << QVariant::Invalid << false << false << false << 0;
+ //QTest::newRow("map-invalid8") << "{is}" << '\0' << QVariant::Invalid << false << false << false << 0; // this is valid when "a" is prepended
+ QTest::newRow("map-bad-nesting") << "a{i(s}" << '\0' << QVariant::Invalid << false << false << false << 0;
+ QTest::newRow("map-ok1") << "a{is}" << 'a' << QVariant::Map << true << false << true << 1;
+ QTest::newRow("map-ok2") << "a{sv}" << 'a' << QVariant::Map << true << false << true << 1;
+
+ // compound of compounds:
+ QTest::newRow("struct-struct") << "((i))" << 'r' << QVariant::List << true << false << true << 1;
+ QTest::newRow("struct-structs") << "((ii)d(i))" << 'r' << QVariant::List << true << false << true << 3;
+ QTest::newRow("map-struct") << "a{s(ii)}" << 'a' << QVariant::Map << true << false << true << 1;
+ QTest::newRow("map-stringlist") << "a{sas}" << 'a' << QVariant::Map << true << false << true << 1;
+ QTest::newRow("map-map") << "a{ia{sv}}" << 'a' << QVariant::Map << true << false << true << 1;
+ QTest::newRow("array-struct") << "a(ii)" << 'a' << QVariant::List << true << false << true << 1;
+ QTest::newRow("array-array") << "aai" << 'a' << QVariant::List << true << false << true << 1;
+ QTest::newRow("array-map") << "aa{sv}" << 'a' << QVariant::List << true << false << true << 1;
+}
+
+void tst_QDBusType::fromType()
+{
+ QFETCH(QString, signature);
+ if (signature.length() != 1)
+ // can't transform to typecode
+ return;
+
+ QFETCH(char, type);
+ QFETCH(int, qvariantType);
+ QFETCH(bool, isValid);
+ QFETCH(bool, isBasic);
+ QFETCH(bool, isContainer);
+
+ QDBusType t(signature.at(0).toLatin1());
+
+ QCOMPARE((char)t.dbusType(), type);
+ QCOMPARE(t.qvariantType(), QVariant::Type(qvariantType));
+ QCOMPARE(t.isValid(), isValid);
+ QCOMPARE(t.isBasic(), isBasic);
+ QCOMPARE(t.isContainer(), isContainer);
+}
+
+void tst_QDBusType::fromSignature()
+{
+ QFETCH(QString, signature);
+ QFETCH(char, type);
+ QFETCH(int, qvariantType);
+ QFETCH(bool, isValid);
+ QFETCH(bool, isBasic);
+ QFETCH(bool, isContainer);
+ QFETCH(int, subtypeCount);
+
+ QDBusType t(signature);
+
+ QCOMPARE((char)t.dbusType(), type);
+ QCOMPARE(t.qvariantType(), QVariant::Type(qvariantType));
+ QCOMPARE(t.isValid(), isValid);
+ QCOMPARE(t.isBasic(), isBasic);
+ QCOMPARE(t.isContainer(), isContainer);
+
+ if (isValid)
+ QCOMPARE(QLatin1String(t.dbusSignature()), signature);
+
+ QCOMPARE(t.subTypes().count(), subtypeCount);
+}
+
+void tst_QDBusType::arrayOf()
+{
+ QFETCH(QString, signature);
+ QFETCH(char, type);
+ QFETCH(int, qvariantType);
+ QFETCH(bool, isValid);
+ QFETCH(bool, isBasic);
+ QFETCH(bool, isContainer);
+ QFETCH(int, subtypeCount);
+
+ QDBusType arr("a" + signature.toLatin1());
+ QCOMPARE(arr.isValid(), isValid);
+ QVERIFY(!arr.isBasic());
+
+ if (isValid) {
+ QVERIFY(arr.isContainer());
+ QVERIFY(arr.isArray());
+ QCOMPARE((char)arr.dbusType(), 'a');
+ QCOMPARE(arr.subTypes().count(), 1);
+
+ // handle special cases:
+ if (type == 'y')
+ QCOMPARE(arr.qvariantType(), QVariant::ByteArray);
+ else if (type == 's' || type == 'o' || type == 'g')
+ QCOMPARE(arr.qvariantType(), QVariant::StringList);
+ else
+ QCOMPARE(arr.qvariantType(), QVariant::List);
+
+ // handle the array element now:
+ QDBusType t = arr.arrayElement();
+
+ QCOMPARE((char)t.dbusType(), type);
+ QCOMPARE(t.qvariantType(), QVariant::Type(qvariantType));
+ QCOMPARE(t.isValid(), isValid);
+ QCOMPARE(t.isBasic(), isBasic);
+ QCOMPARE(t.isContainer(), isContainer);
+
+ QCOMPARE(QLatin1String(t.dbusSignature()), signature);
+
+ QCOMPARE(t.subTypes().count(), subtypeCount);
+ }
+}
+
+void tst_QDBusType::mapOf()
+{
+ QFETCH(QString, signature);
+ QFETCH(char, type);
+ QFETCH(int, qvariantType);
+ QFETCH(bool, isValid);
+ QFETCH(bool, isBasic);
+ QFETCH(bool, isContainer);
+ QFETCH(int, subtypeCount);
+
+ QDBusType map("a{s" + signature.toLatin1() + '}');
+ QCOMPARE(map.isValid(), isValid);
+ QVERIFY(!map.isBasic());
+
+ if (isValid) {
+ QVERIFY(map.isContainer());
+ QVERIFY(map.isArray());
+ QVERIFY(map.isMap());
+ QCOMPARE((char)map.dbusType(), 'a');
+ QCOMPARE(map.subTypes().count(), 1);
+
+ // handle the array element now:
+ QDBusType dict_entry = map.arrayElement();
+ QVERIFY(dict_entry.isValid());
+ QVERIFY(dict_entry.isContainer());
+ QVERIFY(!dict_entry.isMap());
+ QVERIFY(!dict_entry.isArray());
+
+ QVERIFY(map.mapKey().isBasic());
+
+ // handle the value:
+ QDBusType t = map.mapValue();
+
+ QCOMPARE((char)t.dbusType(), type);
+ QCOMPARE(t.qvariantType(), QVariant::Type(qvariantType));
+ QCOMPARE(t.isValid(), isValid);
+ QCOMPARE(t.isBasic(), isBasic);
+ QCOMPARE(t.isContainer(), isContainer);
+
+ QCOMPARE(QLatin1String(t.dbusSignature()), signature);
+
+ QCOMPARE(t.subTypes().count(), subtypeCount);
+ }
+}
+
+QTEST_MAIN(tst_QDBusType)
+
+#include "tst_qdbustype.moc"
--- /dev/null
+/* -*- C++ -*-
+ *
+ * Copyright (C) 2006 Trolltech AS. All rights reserved.
+ * Author: Thiago Macieira <thiago.macieira@trolltech.com>
+ *
+ * Licensed under the Academic Free License version 2.1
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+#include <qcoreapplication.h>
+#include <qmetatype.h>
+#include <QtTest/QtTest>
+
+#include <dbus/qdbus.h>
+
+class tst_QDBusXmlParser: public QObject
+{
+ Q_OBJECT
+
+private:
+ void parsing_common(const QString&);
+
+private slots:
+ void parsing_data();
+ void parsing();
+ void parsingWithDoctype_data();
+ void parsingWithDoctype();
+
+ void objectWithContent_data();
+ void objectWithContent();
+
+ void methods_data();
+ void methods();
+ void signals__data();
+ void signals_();
+ void properties_data();
+ void properties();
+};
+
+// just to make it easier:
+typedef QDBusIntrospection::Interfaces InterfaceMap;
+typedef QDBusIntrospection::Objects ObjectMap;
+typedef QDBusIntrospection::Arguments ArgumentList;
+typedef QDBusIntrospection::Annotations AnnotationsMap;
+typedef QDBusIntrospection::Methods MethodMap;
+typedef QDBusIntrospection::Signals SignalMap;
+typedef QDBusIntrospection::Properties PropertyMap;
+
+Q_DECLARE_METATYPE(QDBusIntrospection::Method)
+Q_DECLARE_METATYPE(QDBusIntrospection::Signal)
+Q_DECLARE_METATYPE(QDBusIntrospection::Property)
+Q_DECLARE_METATYPE(MethodMap)
+Q_DECLARE_METATYPE(SignalMap)
+Q_DECLARE_METATYPE(PropertyMap)
+
+inline QDBusIntrospection::Argument arg(const char* type, const char *name = 0)
+{
+ QDBusIntrospection::Argument retval;
+ retval.type = QDBusType(type);
+ retval.name = QLatin1String(name);
+ return retval;
+}
+
+template<typename T>
+inline QMap<QString, T>& operator<<(QMap<QString, T>& map, const T& m)
+{ map.insert(m.name, m); return map; }
+
+inline const char* mapName(const MethodMap&)
+{ return "MethodMap"; }
+
+inline const char* mapName(const SignalMap&)
+{ return "SignalMap"; }
+
+inline const char* mapName(const PropertyMap&)
+{ return "PropertyMap"; }
+
+QString printable(const QDBusIntrospection::Method& m)
+{
+ QString result = m.name + "(";
+ foreach (QDBusIntrospection::Argument arg, m.inputArgs)
+ result += QString("in %1 %2, ")
+ .arg(arg.type.toString(QDBusType::ConventionalNames))
+ .arg(arg.name);
+ foreach (QDBusIntrospection::Argument arg, m.outputArgs)
+ result += QString("out %1 %2, ")
+ .arg(arg.type.toString(QDBusType::ConventionalNames))
+ .arg(arg.name);
+ AnnotationsMap::const_iterator it = m.annotations.begin();
+ for ( ; it != m.annotations.end(); ++it)
+ result += QString("%1 \"%2\", ").arg(it.key()).arg(it.value());
+
+ if (result.length() > 1)
+ result.truncate(result.length() - 2);
+ result += ")";
+ return result;
+}
+
+QString printable(const QDBusIntrospection::Signal& s)
+{
+ QString result = s.name + "(";
+ foreach (QDBusIntrospection::Argument arg, s.outputArgs)
+ result += QString("out %1 %2, ")
+ .arg(arg.type.toString(QDBusType::ConventionalNames))
+ .arg(arg.name);
+ AnnotationsMap::const_iterator it = s.annotations.begin();
+ for ( ; it != s.annotations.end(); ++it)
+ result += QString("%1 \"%2\", ").arg(it.key()).arg(it.value());
+
+ if (result.length() > 1)
+ result.truncate(result.length() - 2);
+ result += ")";
+ return result;
+}
+
+QString printable(const QDBusIntrospection::Property& p)
+{
+ QString result;
+ if (p.access == QDBusIntrospection::Property::Read)
+ result = "read %1 %2, ";
+ else if (p.access == QDBusIntrospection::Property::Write)
+ result = "write %1 %2, ";
+ else
+ result = "readwrite %1 %2, ";
+ result = result.arg(p.type.toString(QDBusType::ConventionalNames)).arg(p.name);
+
+ AnnotationsMap::const_iterator it = p.annotations.begin();
+ for ( ; it != p.annotations.end(); ++it)
+ result += QString("%1 \"%2\", ").arg(it.key()).arg(it.value());
+
+ if (result.length() > 1)
+ result.truncate(result.length() - 2);
+ return result;
+}
+
+template<typename T>
+char* printableMap(const QMap<QString, T>& map)
+{
+ QString contents = "\n";
+ typename QMap<QString, T>::const_iterator it = map.begin();
+ for ( ; it != map.end(); ++it) {
+ if (it.key() != it.value().name)
+ contents += it.value().name + ":";
+ contents += printable(it.value());
+ contents += ";\n";
+ }
+
+ QString result("%1(size = %2): {%3}");
+ return qstrdup(qPrintable(result
+ .arg(mapName(map))
+ .arg(map.size())
+ .arg(contents)));
+}
+
+namespace QTest {
+ template<>
+ inline char* toString(const MethodMap& map)
+ {
+ return printableMap(map);
+ }
+
+ template<>
+ inline char* toString(const SignalMap& map)
+ {
+ return printableMap(map);
+ }
+
+ template<>
+ inline char* toString(const PropertyMap& map)
+ {
+ return printableMap(map);
+ }
+}
+
+void tst_QDBusXmlParser::parsing_data()
+{
+ QTest::addColumn<QString>("xmlData");
+ QTest::addColumn<int>("interfaceCount");
+ QTest::addColumn<int>("objectCount");
+
+ QTest::newRow("null") << QString() << 0 << 0;
+ QTest::newRow("empty") << QString("") << 0 << 0;
+
+ QTest::newRow("junk") << "<junk/>" << 0 << 0;
+ QTest::newRow("interface-inside-junk") << "<junk><interface name=\"iface.iface1\" /></junk>"
+ << 0 << 0;
+ QTest::newRow("object-inside-junk") << "<junk><node name=\"obj1\" /></junk>"
+ << 0 << 0;
+
+ QTest::newRow("zero-interfaces") << "<node/>" << 0 << 0;
+ QTest::newRow("one-interface") << "<node><interface name=\"iface.iface1\" /></node>" << 1 << 0;
+
+
+ QTest::newRow("two-interfaces") << "<node><interface name=\"iface.iface1\" />"
+ "<interface name=\"iface.iface2\"></node>"
+ << 2 << 0;
+
+
+ QTest::newRow("one-object") << "<node><node name=\"obj1\"/></node>" << 0 << 1;
+ QTest::newRow("two-objects") << "<node><node name=\"obj1\"/><node name=\"obj2\"></node>" << 0 << 2;
+
+ QTest::newRow("i1o1") << "<node><interface name=\"iface.iface1\"><node name=\"obj1\"></node>" << 1 << 1;
+
+}
+
+void tst_QDBusXmlParser::parsing_common(const QString &xmlData)
+{
+ QDBusIntrospection::ObjectTree obj =
+ QDBusIntrospection::parseObjectTree(xmlData, "local.testing", "/");
+ QFETCH(int, interfaceCount);
+ QFETCH(int, objectCount);
+ QCOMPARE(obj.interfaces.count(), interfaceCount);
+ QCOMPARE(obj.childObjects.count(), objectCount);
+
+ // also verify the naming
+ int i = 0;
+ foreach (QString name, obj.interfaces)
+ QCOMPARE(name, QString("iface.iface%1").arg(++i));
+
+ i = 0;
+ foreach (QString name, obj.childObjects)
+ QCOMPARE(name, QString("obj%1").arg(++i));
+}
+
+void tst_QDBusXmlParser::parsing()
+{
+ QFETCH(QString, xmlData);
+
+ parsing_common(xmlData);
+}
+
+void tst_QDBusXmlParser::parsingWithDoctype_data()
+{
+ parsing_data();
+}
+
+void tst_QDBusXmlParser::parsingWithDoctype()
+{
+ QString docType = "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n"
+ "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n";
+ QFETCH(QString, xmlData);
+
+ parsing_common(docType + xmlData);
+}
+
+void tst_QDBusXmlParser::objectWithContent_data()
+{
+ QTest::addColumn<QString>("xmlData");
+ QTest::addColumn<QString>("probedObject");
+ QTest::addColumn<int>("interfaceCount");
+ QTest::addColumn<int>("objectCount");
+
+ QTest::newRow("zero") << "<node><node name=\"obj\"/></node>" << "obj" << 0 << 0;
+
+ QString xmlData = "<node><node name=\"obj\">"
+ "<interface name=\"iface.iface1\" />"
+ "</node></node>";
+ QTest::newRow("one-interface") << xmlData << "obj" << 1 << 0;
+ QTest::newRow("one-interface2") << xmlData << "obj2" << 0 << 0;
+
+ xmlData = "<node><node name=\"obj\">"
+ "<interface name=\"iface.iface1\" />"
+ "<interface name=\"iface.iface2\" />"
+ "</node></node>";
+ QTest::newRow("two-interfaces") << xmlData << "obj" << 2 << 0;
+ QTest::newRow("two-interfaces2") << xmlData << "obj2" << 0 << 0;
+
+ xmlData = "<node><node name=\"obj\">"
+ "<interface name=\"iface.iface1\" />"
+ "<interface name=\"iface.iface2\" />"
+ "</node><node name=\"obj2\">"
+ "<interface name=\"iface.iface1\" />"
+ "</node></node>";
+ QTest::newRow("two-nodes-two-interfaces") << xmlData << "obj" << 2 << 0;
+ QTest::newRow("two-nodes-one-interface") << xmlData << "obj2" << 1 << 0;
+
+ xmlData = "<node><node name=\"obj\">"
+ "<node name=\"obj1\" />"
+ "</node></node>";
+ QTest::newRow("one-object") << xmlData << "obj" << 0 << 1;
+ QTest::newRow("one-object2") << xmlData << "obj2" << 0 << 0;
+
+ xmlData = "<node><node name=\"obj\">"
+ "<node name=\"obj1\" />"
+ "<node name=\"obj2\" />"
+ "</node></node>";
+ QTest::newRow("two-objects") << xmlData << "obj" << 0 << 2;
+ QTest::newRow("two-objects2") << xmlData << "obj2" << 0 << 0;
+
+ xmlData = "<node><node name=\"obj\">"
+ "<node name=\"obj1\" />"
+ "<node name=\"obj2\" />"
+ "</node><node name=\"obj2\">"
+ "<node name=\"obj1\" />"
+ "</node></node>";
+ QTest::newRow("two-nodes-two-objects") << xmlData << "obj" << 0 << 2;
+ QTest::newRow("two-nodes-one-object") << xmlData << "obj2" << 0 << 1;
+}
+
+void tst_QDBusXmlParser::objectWithContent()
+{
+ QFETCH(QString, xmlData);
+ QFETCH(QString, probedObject);
+
+ QDBusIntrospection::ObjectTree tree =
+ QDBusIntrospection::parseObjectTree(xmlData, "local.testing", "/");
+
+ const ObjectMap &om = tree.childObjectData;
+
+ if (om.contains(probedObject)) {
+ const QSharedDataPointer<QDBusIntrospection::ObjectTree>& obj = om.value(probedObject);
+ QVERIFY(obj != 0);
+
+ QFETCH(int, interfaceCount);
+ QFETCH(int, objectCount);
+
+ QCOMPARE(obj->interfaces.count(), interfaceCount);
+ QCOMPARE(obj->childObjects.count(), objectCount);
+
+ // verify the object names
+ int i = 0;
+ foreach (QString name, obj->interfaces)
+ QCOMPARE(name, QString("iface.iface%1").arg(++i));
+
+ i = 0;
+ foreach (QString name, obj->childObjects)
+ QCOMPARE(name, QString("obj%1").arg(++i));
+ }
+}
+
+void tst_QDBusXmlParser::methods_data()
+{
+ QTest::addColumn<QString>("xmlDataFragment");
+ QTest::addColumn<MethodMap>("methodMap");
+
+ MethodMap map;
+ QTest::newRow("no-methods") << QString() << map;
+
+ // one method without arguments
+ QDBusIntrospection::Method method;
+ method.name = "Foo";
+ map << method;
+ QTest::newRow("one-method") << "<method name=\"Foo\"/>" << map;
+
+ // add another method without arguments
+ method.name = "Bar";
+ map << method;
+ QTest::newRow("two-methods") << "<method name=\"Foo\"/>"
+ "<method name=\"Bar\"/>"
+ << map;
+
+ // invert the order of the XML declaration
+ QTest::newRow("two-methods-inverse") << "<method name=\"Bar\"/>"
+ "<method name=\"Foo\"/>"
+ << map;
+
+ // add a third, with annotations
+ method.name = "Baz";
+ method.annotations.insert("foo.testing", "nothing to see here");
+ map << method;
+ QTest::newRow("method-with-annotation") <<
+ "<method name=\"Foo\"/>"
+ "<method name=\"Bar\"/>"
+ "<method name=\"Baz\"><annotation name=\"foo.testing\" value=\"nothing to see here\"></method>"
+ << map;
+
+ // arguments
+ map.clear();
+ method.annotations.clear();
+
+ method.name = "Method";
+ method.inputArgs << arg("s");
+ map << method;
+ QTest::newRow("one-in") <<
+ "<method name=\"Method\">"
+ "<arg type=\"s\" direction=\"in\"/>"
+ "</method>" << map;
+
+ // two arguments
+ method.inputArgs << arg("v");
+ map.clear();
+ map << method;
+ QTest::newRow("two-in") <<
+ "<method name=\"Method\">"
+ "<arg type=\"s\" direction=\"in\"/>"
+ "<arg type=\"v\" direction=\"in\"/>"
+ "</method>" << map;
+
+ // one invalid arg
+ QTest::newRow("two-in-one-invalid") <<
+ "<method name=\"Method\">"
+ "<arg type=\"s\" direction=\"in\"/>"
+ "<arg type=\"~\" name=\"invalid\" direction=\"in\"/>" // this line should be ignored
+ "<arg type=\"v\" direction=\"in\"/>"
+ "</method>" << map;
+
+ // one out argument
+ method.inputArgs.clear();
+ method.outputArgs << arg("s");
+ map.clear();
+ map << method;
+ QTest::newRow("one-out") <<
+ "<method name=\"Method\">"
+ "<arg type=\"s\" direction=\"out\"/>"
+ "</method>" << map;
+
+ // two in and one out
+ method.inputArgs << arg("s") << arg("v");
+ map.clear();
+ map << method;
+ QTest::newRow("two-in-one-out") <<
+ "<method name=\"Method\">"
+ "<arg type=\"s\" direction=\"in\"/>"
+ "<arg type=\"v\" direction=\"in\"/>"
+ "<arg type=\"s\" direction=\"out\"/>"
+ "</method>" << map;
+
+ // let's try an arg with name
+ method.outputArgs.clear();
+ method.inputArgs.clear();
+ method.inputArgs << arg("s", "foo");
+ map.clear();
+ map << method;
+ QTest::newRow("one-in-with-name") <<
+ "<method name=\"Method\">"
+ "<arg type=\"s\" name=\"foo\" direction=\"in\"/>"
+ "</method>" << map;
+
+ // two args with name
+ method.inputArgs << arg("i", "bar");
+ map.clear();
+ map << method;
+ QTest::newRow("two-in-with-name") <<
+ "<method name=\"Method\">"
+ "<arg type=\"s\" name=\"foo\" direction=\"in\"/>"
+ "<arg type=\"i\" name=\"bar\" direction=\"in\"/>"
+ "</method>" << map;
+
+ // one complex
+ map.clear();
+ method = QDBusIntrospection::Method();
+
+ // Method1(in STRING arg1, in BYTE arg2, out ARRAY of STRING)
+ method.inputArgs << arg("s", "arg1") << arg("y", "arg2");
+ method.outputArgs << arg("as");
+ method.name = "Method1";
+ map << method;
+
+ // Method2(in ARRAY of DICT_ENTRY of (STRING,VARIANT) variantMap, in UINT32 index,
+ // out STRING key, out VARIANT value)
+ // with annotation "foo.equivalent":"QVariantMap"
+ method = QDBusIntrospection::Method();
+ method.inputArgs << arg("a{sv}", "variantMap") << arg("u", "index");
+ method.outputArgs << arg("s", "key") << arg("v", "value");
+ method.annotations.insert("foo.equivalent", "QVariantMap");
+ method.name = "Method2";
+ map << method;
+
+ QTest::newRow("complex") <<
+ "<method name=\"Method1\">"
+ "<arg name=\"arg1\" type=\"s\" direction=\"in\"/>"
+ "<arg name=\"arg2\" type=\"y\" direction=\"in\"/>"
+ "<arg type=\"as\" direction=\"out\"/>"
+ "</method>"
+ "<method name=\"Method2\">"
+ "<arg name=\"variantMap\" type=\"a{sv}\" direction=\"in\"/>"
+ "<arg name=\"index\" type=\"u\" direction=\"in\"/>"
+ "<arg name=\"key\" type=\"s\" direction=\"out\"/>"
+ "<arg name=\"value\" type=\"v\" direction=\"out\"/>"
+ "<annotation name=\"foo.equivalent\" value=\"QVariantMap\"/>"
+ "</method>" << map;
+}
+
+void tst_QDBusXmlParser::methods()
+{
+ QString xmlHeader = "<node>"
+ "<interface name=\"iface.iface1\">",
+ xmlFooter = "</interface>"
+ "</node>";
+
+ QFETCH(QString, xmlDataFragment);
+
+ QDBusIntrospection::Interface iface =
+ QDBusIntrospection::parseInterface(xmlHeader + xmlDataFragment + xmlFooter);
+
+ QCOMPARE(iface.name, QString("iface.iface1"));
+
+ QFETCH(MethodMap, methodMap);
+ MethodMap parsedMap = iface.methods;
+
+ QCOMPARE(methodMap.count(), parsedMap.count());
+ QCOMPARE(methodMap, parsedMap);
+}
+
+void tst_QDBusXmlParser::signals__data()
+{
+ QTest::addColumn<QString>("xmlDataFragment");
+ QTest::addColumn<SignalMap>("signalMap");
+
+ SignalMap map;
+ QTest::newRow("no-signals") << QString() << map;
+
+ // one signal without arguments
+ QDBusIntrospection::Signal signal;
+ signal.name = "Foo";
+ map << signal;
+ QTest::newRow("one-signal") << "<signal name=\"Foo\"/>" << map;
+
+ // add another signal without arguments
+ signal.name = "Bar";
+ map << signal;
+ QTest::newRow("two-signals") << "<signal name=\"Foo\"/>"
+ "<signal name=\"Bar\"/>"
+ << map;
+
+ // invert the order of the XML declaration
+ QTest::newRow("two-signals-inverse") << "<signal name=\"Bar\"/>"
+ "<signal name=\"Foo\"/>"
+ << map;
+
+ // add a third, with annotations
+ signal.name = "Baz";
+ signal.annotations.insert("foo.testing", "nothing to see here");
+ map << signal;
+ QTest::newRow("signal-with-annotation") <<
+ "<signal name=\"Foo\"/>"
+ "<signal name=\"Bar\"/>"
+ "<signal name=\"Baz\"><annotation name=\"foo.testing\" value=\"nothing to see here\"></signal>"
+ << map;
+
+ // one out argument
+ map.clear();
+ signal.annotations.clear();
+ signal.outputArgs << arg("s");
+ signal.name = "Signal";
+ map.clear();
+ map << signal;
+ QTest::newRow("one-out") <<
+ "<signal name=\"Signal\">"
+ "<arg type=\"s\" direction=\"out\"/>"
+ "</signal>" << map;
+
+ // without saying which direction it is
+ QTest::newRow("one-out-no-direction") <<
+ "<signal name=\"Signal\">"
+ "<arg type=\"s\"/>"
+ "</signal>" << map;
+
+ // two args with name
+ signal.outputArgs << arg("i", "bar");
+ map.clear();
+ map << signal;
+ QTest::newRow("two-out-with-name") <<
+ "<signal name=\"Signal\">"
+ "<arg type=\"s\" direction=\"out\"/>"
+ "<arg type=\"i\" name=\"bar\"/>"
+ "</signal>" << map;
+
+ // one complex
+ map.clear();
+ signal = QDBusIntrospection::Signal();
+
+ // Signal1(out ARRAY of STRING)
+ signal.outputArgs << arg("as");
+ signal.name = "Signal1";
+ map << signal;
+
+ // Signal2(out STRING key, out VARIANT value)
+ // with annotation "foo.equivalent":"QVariantMap"
+ signal = QDBusIntrospection::Signal();
+ signal.outputArgs << arg("s", "key") << arg("v", "value");
+ signal.annotations.insert("foo.equivalent", "QVariantMap");
+ signal.name = "Signal2";
+ map << signal;
+
+ QTest::newRow("complex") <<
+ "<signal name=\"Signal1\">"
+ "<arg type=\"as\" direction=\"out\"/>"
+ "</signal>"
+ "<signal name=\"Signal2\">"
+ "<arg name=\"key\" type=\"s\" direction=\"out\"/>"
+ "<arg name=\"value\" type=\"v\" direction=\"out\"/>"
+ "<annotation name=\"foo.equivalent\" value=\"QVariantMap\"/>"
+ "</signal>" << map;
+}
+
+void tst_QDBusXmlParser::signals_()
+{
+ QString xmlHeader = "<node>"
+ "<interface name=\"iface.iface1\">",
+ xmlFooter = "</interface>"
+ "</node>";
+
+ QFETCH(QString, xmlDataFragment);
+
+ QDBusIntrospection::Interface iface =
+ QDBusIntrospection::parseInterface(xmlHeader + xmlDataFragment + xmlFooter);
+
+ QCOMPARE(iface.name, QString("iface.iface1"));
+
+ QFETCH(SignalMap, signalMap);
+ SignalMap parsedMap = iface.signals_;
+
+ QCOMPARE(signalMap.count(), parsedMap.count());
+ QCOMPARE(signalMap, parsedMap);
+}
+
+void tst_QDBusXmlParser::properties_data()
+{
+ QTest::addColumn<QString>("xmlDataFragment");
+ QTest::addColumn<PropertyMap>("propertyMap");
+
+ PropertyMap map;
+ QTest::newRow("no-signals") << QString() << map;
+
+ // one readable signal
+ QDBusIntrospection::Property prop;
+ prop.name = "foo";
+ prop.type = QDBusType("s");
+ prop.access = QDBusIntrospection::Property::Read;
+ map << prop;
+ QTest::newRow("one-readable") << "<property name=\"foo\" type=\"s\" access=\"read\"/>" << map;
+
+ // one writable signal
+ prop.access = QDBusIntrospection::Property::Write;
+ map.clear();
+ map << prop;
+ QTest::newRow("one-writable") << "<property name=\"foo\" type=\"s\" access=\"write\"/>" << map;
+
+ // one read- & writable signal
+ prop.access = QDBusIntrospection::Property::ReadWrite;
+ map.clear();
+ map << prop;
+ QTest::newRow("one-read-writable") << "<property name=\"foo\" type=\"s\" access=\"readwrite\"/>"
+ << map;
+
+ // two, mixed properties
+ prop.name = "bar";
+ prop.type = QDBusType("i");
+ prop.access = QDBusIntrospection::Property::Read;
+ map << prop;
+ QTest::newRow("two") <<
+ "<property name=\"foo\" type=\"s\" access=\"readwrite\"/>"
+ "<property name=\"bar\" type=\"i\" access=\"read\"/>" << map;
+
+ // invert the order of the declaration
+ QTest::newRow("two") <<
+ "<property name=\"bar\" type=\"i\" access=\"read\"/>"
+ "<property name=\"foo\" type=\"s\" access=\"readwrite\"/>" << map;
+
+ // add a third with annotations
+ prop.name = "baz";
+ prop.type = QDBusType("as");
+ prop.access = QDBusIntrospection::Property::Write;
+ prop.annotations.insert("foo.annotation", "Hello, World");
+ prop.annotations.insert("foo.annotation2", "Goodbye, World");
+ map << prop;
+ QTest::newRow("complex") <<
+ "<property name=\"bar\" type=\"i\" access=\"read\"/>"
+ "<property name=\"baz\" type=\"as\" access=\"write\">"
+ "<annotation name=\"foo.annotation\" value=\"Hello, World\" />"
+ "<annotation name=\"foo.annotation2\" value=\"Goodbye, World\" />"
+ "<property name=\"foo\" type=\"s\" access=\"readwrite\"/>" << map;
+
+ // and now change the order
+ QTest::newRow("complex2") <<
+ "<property name=\"baz\" type=\"as\" access=\"write\">"
+ "<annotation name=\"foo.annotation2\" value=\"Goodbye, World\" />"
+ "<annotation name=\"foo.annotation\" value=\"Hello, World\" />"
+ "<property name=\"bar\" type=\"i\" access=\"read\"/>"
+ "<property name=\"foo\" type=\"s\" access=\"readwrite\"/>" << map;
+}
+
+void tst_QDBusXmlParser::properties()
+{
+ QString xmlHeader = "<node>"
+ "<interface name=\"iface.iface1\">",
+ xmlFooter = "</interface>"
+ "</node>";
+
+ QFETCH(QString, xmlDataFragment);
+
+ QDBusIntrospection::Interface iface =
+ QDBusIntrospection::parseInterface(xmlHeader + xmlDataFragment + xmlFooter);
+
+ QCOMPARE(iface.name, QString("iface.iface1"));
+
+ QFETCH(PropertyMap, propertyMap);
+ PropertyMap parsedMap = iface.properties;
+
+ QCOMPARE(propertyMap.count(), parsedMap.count());
+ QCOMPARE(propertyMap, parsedMap);
+}
+
+QTEST_MAIN(tst_QDBusXmlParser)
+
+#include "tst_qdbusxmlparser.moc"
projects / platform / upstream / dbus.git / commitdiff