From d54ababd5f67bb621c1b3a911d0853c23df817a1 Mon Sep 17 00:00:00 2001 From: Thiago Macieira Date: Tue, 28 Mar 2006 18:58:58 +0000 Subject: * test/qt/*: Sync with KDE Subversion revision 523647. Update the testcases to the new API. Remove testcases for classes that are no longer public or have been removed. --- ChangeLog | 6 + test/qt/Makefile.am | 12 +- test/qt/common.h | 133 +++++++- test/qt/ping.cpp | 333 ++++++++++++++++---- test/qt/qpong.cpp | 11 +- test/qt/tst_qdbusabstractadaptor.cpp | 579 +++++++++++++++++++++++------------ test/qt/tst_qdbusconnection.cpp | 90 ------ test/qt/tst_qdbusinterface.cpp | 104 +++---- test/qt/tst_qdbusobject.cpp | 207 ------------- test/qt/tst_qdbustype.cpp | 273 ----------------- test/qt/tst_qdbusxmlparser.cpp | 578 ---------------------------------- 11 files changed, 843 insertions(+), 1483 deletions(-) delete mode 100644 test/qt/tst_qdbusobject.cpp delete mode 100644 test/qt/tst_qdbustype.cpp delete mode 100644 test/qt/tst_qdbusxmlparser.cpp diff --git a/ChangeLog b/ChangeLog index 8b1b98be..04b5aa92 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,9 @@ +2006-03-28 Thiago Macieira + + * test/qt/*: Sync with KDE Subversion revision 523647. + Update the testcases to the new API. Remove testcases for + classes that are no longer public or have been removed. + 2006-03-28 Thiago Macieira * qt/*: diff --git a/test/qt/Makefile.am b/test/qt/Makefile.am index 94283eb4..f7a8efa9 100644 --- a/test/qt/Makefile.am +++ b/test/qt/Makefile.am @@ -1,33 +1,26 @@ 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=qdbustype qdbusxmlparser qdbusconnection qpong ping qdbusobject qdbusinterface qdbusabstractadaptor hal +TEST_BINARIES=qdbusconnection qpong ping qdbusinterface qdbusabstractadaptor hal TESTS= else TEST_BINARIES= TESTS= endif - noinst_PROGRAMS= $(TEST_BINARIES) qpong_SOURCES= qpong.cpp ping_SOURCES= ping.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 common.h qdbusabstractadaptor_SOURCES= tst_qdbusabstractadaptor.cpp common.h hal_SOURCES = tst_hal.cpp qpong.o: qpong.moc ping.o: ping.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_qdbusabstractadaptor.o: tst_qdbusabstractadaptor.moc tst_hal.o: tst_hal.moc @@ -38,4 +31,5 @@ TEST_LIBS=$(DBUS_QTESTLIB_LIBS) $(top_builddir)/qt/libdbus-qt4-1.la LDADD=$(TEST_LIBS) -CLEANFILES=tst_qdbusconnection.moc +clean-local: + -rm *.moc diff --git a/test/qt/common.h b/test/qt/common.h index e3c78bd6..943d3d95 100644 --- a/test/qt/common.h +++ b/test/qt/common.h @@ -1,3 +1,17 @@ +#include // isnan + +Q_DECLARE_METATYPE(QVariant) +Q_DECLARE_METATYPE(QList) +Q_DECLARE_METATYPE(QList) +Q_DECLARE_METATYPE(QList) +Q_DECLARE_METATYPE(QList) +Q_DECLARE_METATYPE(QList) +Q_DECLARE_METATYPE(QList) +Q_DECLARE_METATYPE(QList) +Q_DECLARE_METATYPE(QList) +#if 0 +#include "../qdbusintrospection_p.h" + // just to make it easier: typedef QDBusIntrospection::Interfaces InterfaceMap; typedef QDBusIntrospection::Objects ObjectMap; @@ -17,7 +31,7 @@ Q_DECLARE_METATYPE(PropertyMap) inline QDBusIntrospection::Argument arg(const char* type, const char *name = 0) { QDBusIntrospection::Argument retval; - retval.type = QDBusType(type); + retval.type = QLatin1String(type); retval.name = QLatin1String(name); return retval; } @@ -40,12 +54,10 @@ QString printable(const QDBusIntrospection::Method& m) QString result = "method " + m.name + "("; foreach (QDBusIntrospection::Argument arg, m.inputArgs) result += QString("in %1 %2, ") - .arg(arg.type.toString(QDBusType::ConventionalNames)) - .arg(arg.name); + .arg(arg.type, arg.name); foreach (QDBusIntrospection::Argument arg, m.outputArgs) result += QString("out %1 %2, ") - .arg(arg.type.toString(QDBusType::ConventionalNames)) - .arg(arg.name); + .arg(arg.type, 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()); @@ -59,8 +71,7 @@ QString printable(const QDBusIntrospection::Signal& s) QString result = "signal " + s.name + "("; foreach (QDBusIntrospection::Argument arg, s.outputArgs) result += QString("out %1 %2, ") - .arg(arg.type.toString(QDBusType::ConventionalNames)) - .arg(arg.name); + .arg(arg.type, 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()); @@ -78,7 +89,7 @@ QString printable(const QDBusIntrospection::Property& p) result = "property write %1 %2, "; else result = "property readwrite %1 %2, "; - result = result.arg(p.type.toString(QDBusType::ConventionalNames)).arg(p.name); + result = result.arg(p.type, p.name); AnnotationsMap::const_iterator it = p.annotations.begin(); for ( ; it != p.annotations.end(); ++it) @@ -125,3 +136,109 @@ namespace QTest { return printableMap(map); } } +#endif +bool compare(const QVariantList &l1, const QVariantList &l2); +bool compare(const QVariantMap &m1, const QVariantMap &m2); +bool compare(const QVariant &v1, const QVariant &v2); + +bool compare(const QList &l1, const QList &l2) +{ + if (l1.count() != l2.count()) + return false; + + QList::ConstIterator it1 = l1.constBegin(); + QList::ConstIterator it2 = l2.constBegin(); + QList::ConstIterator end = l1.constEnd(); + for ( ; it1 != end; ++it1, ++it2) + if (isnan(*it1) && isnan(*it2)) + continue; + else if (*it1 != *it2) + return false; + return true; +} + +bool compare(const QVariant &v1, const QVariant &v2) +{ + if (v1.userType() != v2.userType()) + return false; + + int id = v1.userType(); + if (id == QVariant::List) + return compare(v1.toList(), v2.toList()); + + else if (id == QVariant::Map) + return compare(v1.toMap(), v2.toMap()); + + else if (id < int(QVariant::UserType)) // yes, v1.type() + // QVariant can compare + return v1 == v2; + + else if (id == QMetaType::UChar) + return qvariant_cast(v1) == qvariant_cast(v2); + + else if (id == QMetaType::Short) + return qvariant_cast(v1) == qvariant_cast(v2); + + else if (id == QMetaType::UShort) + return qvariant_cast(v1) == qvariant_cast(v2); + + else if (id == qMetaTypeId()) + return compare(qvariant_cast(v1), qvariant_cast(v2)); + + else if (id == qMetaTypeId >()) + return qvariant_cast >(v1) == qvariant_cast >(v2); + + else if (id == qMetaTypeId >()) + return qvariant_cast >(v1) == qvariant_cast >(v2); + + else if (id == qMetaTypeId >()) + return qvariant_cast >(v1) == qvariant_cast >(v2); + + else if (id == qMetaTypeId >()) + return qvariant_cast >(v1) == qvariant_cast >(v2); + + else if (id == qMetaTypeId >()) + return qvariant_cast >(v1) == qvariant_cast >(v2); + + else if (id == qMetaTypeId >()) + return qvariant_cast >(v1) == qvariant_cast >(v2); + + else if (id == qMetaTypeId >()) + return qvariant_cast >(v2) == qvariant_cast >(v2); + + else if (id == qMetaTypeId >()) + return compare(qvariant_cast >(v1), qvariant_cast >(v2)); + + else + return false; // unknown type +} + +bool compare(const QVariantList &l1, const QVariantList &l2) +{ + if (l1.count() != l2.size()) + return false; + QVariantList::ConstIterator i1 = l1.constBegin(); + QVariantList::ConstIterator i2 = l2.constBegin(); + QVariantList::ConstIterator end = l1.constEnd(); + for ( ; i1 != end; ++i1, ++i2) { + if (!compare(*i1, *i2)) + return false; + } + return true; +} + +bool compare(const QVariantMap &m1, const QVariantMap &m2) +{ + if (m1.count() != m2.size()) + return false; + QVariantMap::ConstIterator i1 = m1.constBegin(); + QVariantMap::ConstIterator end = m1.constEnd(); + for ( ; i1 != end; ++i1) { + QVariantMap::ConstIterator i2 = m2.find(i1.key()); + if (i2 == m2.constEnd()) + return false; + if (!compare(*i1, *i2)) + return false; + } + return true; +} diff --git a/test/qt/ping.cpp b/test/qt/ping.cpp index 1777a804..1cdbfca5 100644 --- a/test/qt/ping.cpp +++ b/test/qt/ping.cpp @@ -1,8 +1,9 @@ -#define DBUS_API_SUBJECT_TO_CHANGE #include #include #include +#include "common.h" + class Ping: public QObject { Q_OBJECT @@ -12,8 +13,23 @@ public slots: void cleanupTestCase(); private slots: - void sendPing_data(); - void sendPing(); + void sendBasic_data(); + void sendBasic(); + + void sendVariant_data(); + void sendVariant(); + + void sendArrays_data(); + void sendArrays(); + + void sendArrayOfArrays_data(); + void sendArrayOfArrays(); + + void sendStringMap_data(); + void sendStringMap(); + + void sendStringMapOfMap_data(); + void sendStringMapOfMap(); private: QProcess proc; @@ -31,75 +47,181 @@ void Ping::cleanupTestCase() proc.close(); } -Q_DECLARE_METATYPE(QVariant) - -void Ping::sendPing_data() +void Ping::sendBasic_data() { QTest::addColumn("value"); + QTest::addColumn("sig"); - QTest::newRow("string") << QVariant("ping"); - QTest::newRow("int") << QVariant(1); - QTest::newRow("double") << QVariant(42.5); + // basic types: + QTest::newRow("bool") << QVariant(false) << "b"; + QTest::newRow("bool2") << QVariant(true) << "b"; + QTest::newRow("byte") << qVariantFromValue(uchar(1)) << "y"; + QTest::newRow("int16") << qVariantFromValue(short(2)) << "n"; + QTest::newRow("uint16") << qVariantFromValue(ushort(3)) << "q"; + QTest::newRow("int") << QVariant(1) << "i"; + QTest::newRow("uint") << QVariant(2U) << "u"; + QTest::newRow("int64") << QVariant(Q_INT64_C(3)) << "x"; + QTest::newRow("uint64") << QVariant(Q_UINT64_C(4)) << "t"; + QTest::newRow("double") << QVariant(42.5) << "d"; + QTest::newRow("string") << QVariant("ping") << "s"; + QTest::newRow("emptystring") << QVariant("") << "s"; +} +void Ping::sendVariant_data() +{ + sendBasic_data(); + + // add a few more: + QVariant nested(1); + QTest::newRow("variant") << nested << "v"; + + QVariant nested2; + qVariantSetValue(nested2, nested); + QTest::newRow("variant-variant") << nested2 << "v"; +} + +void Ping::sendArrays_data() +{ + QTest::addColumn("value"); + QTest::addColumn("sig"); + + // arrays: QStringList strings; + QTest::newRow("emptystringlist") << QVariant(strings) << "as"; strings << "hello" << "world"; - QTest::newRow("stringlist") << QVariant(strings); - - QList ints; - ints << 42 << -43 << 44 << 45; - QTest::newRow("intlist") << QVariant(ints); - - QList uints; - uints << uint(12) << uint(13) << uint(14); - QTest::newRow("uintlist") << QVariant(uints); - - QList llints; - llints << Q_INT64_C(99) << Q_INT64_C(-100); - QTest::newRow("llintlist") << QVariant(llints); - - QList ullints; - ullints << Q_UINT64_C(66) << Q_UINT64_C(67); - QTest::newRow("ullintlist") << QVariant(ullints); - - QList doubles; - doubles << 1.2 << 2.2 << 4.4; - QTest::newRow("doublelist") << QVariant(doubles); - - QList stackedInts; - stackedInts << 4 << ints << 5; - QTest::newRow("stackedInts") << QVariant(stackedInts); - - QList stackedUInts; - stackedUInts << uint(3) << uints << uint(4); - QTest::newRow("stackedUInts") << QVariant(stackedUInts); - - QList stackedLlints; - stackedLlints << Q_INT64_C(49) << llints << Q_INT64_C(-160); - QTest::newRow("stackedLlintlist") << QVariant(stackedLlints); - - QList stackedUllints; - stackedUllints << Q_UINT64_C(56) << ullints << Q_UINT64_C(57); - QTest::newRow("stackedullintlist") << QVariant(stackedUllints); - - QList stackedDoubles; - stackedDoubles << 6.2 << doubles << 6.4; - QTest::newRow("stackedDoublelist") << QVariant(stackedDoubles); - - QMap map; - map["foo"] = "bar"; - map["kde"] = "great"; - QTest::newRow("map") << QVariant(map); - - QList byteArrays; - byteArrays << QByteArray("test1") << QByteArray("t2"); - QTest::newRow("bytearray") << QVariant(byteArrays); - - QList lists; - lists << QVariant(byteArrays) << QVariant(byteArrays); - QTest::newRow("listoflists") << QVariant(lists); + QTest::newRow("stringlist") << QVariant(strings) << "as"; + + QByteArray bytearray(""); // empty, not null + QTest::newRow("emptybytearray") << QVariant(bytearray) << "ay"; + bytearray = "foo"; + QTest::newRow("bytearray") << QVariant(bytearray) << "ay"; + + QList bools; + QTest::newRow("emptyboollist") << qVariantFromValue(bools) << "ab"; + bools << false << true << false; + QTest::newRow("boollist") << qVariantFromValue(bools) << "ab"; + + QList shorts; + QTest::newRow("emptyshortlist") << qVariantFromValue(shorts) << "an"; + shorts << 42 << -43 << 44 << 45 << -32768 << 32767; + QTest::newRow("shortlist") << qVariantFromValue(shorts) << "an"; + + QList ushorts; + QTest::newRow("emptyushortlist") << qVariantFromValue(ushorts) << "aq"; + ushorts << 12u << 13u << 14u << 15 << 65535; + QTest::newRow("ushortlist") << qVariantFromValue(ushorts) << "aq"; + + QList ints; + QTest::newRow("emptyintlist") << qVariantFromValue(ints) << "ai"; + ints << 42 << -43 << 44 << 45 << 2147483647 << -2147483647-1; + QTest::newRow("intlist") << qVariantFromValue(ints) << "ai"; + + QList uints; + QTest::newRow("emptyuintlist") << qVariantFromValue(uints) << "au"; + uints << uint(12) << uint(13) << uint(14) << 4294967295U; + QTest::newRow("uintlist") << qVariantFromValue(uints) << "au"; + + QList llints; + QTest::newRow("emptyllintlist") << qVariantFromValue(llints) << "ax"; + llints << Q_INT64_C(99) << Q_INT64_C(-100) + << Q_INT64_C(-9223372036854775807)-1 << Q_INT64_C(9223372036854775807); + QTest::newRow("llintlist") << qVariantFromValue(llints) << "ax"; + + QList ullints; + QTest::newRow("emptyullintlist") << qVariantFromValue(ullints) << "at"; + ullints << Q_UINT64_C(66) << Q_UINT64_C(67) + << Q_UINT64_C(18446744073709551615); + QTest::newRow("ullintlist") << qVariantFromValue(ullints) << "at"; + + QList doubles; + QTest::newRow("emptydoublelist") << qVariantFromValue(doubles) << "ad"; + doubles << 1.2 << 2.2 << 4.4 + << -std::numeric_limits::infinity() + << std::numeric_limits::infinity() + << std::numeric_limits::quiet_NaN(); + QTest::newRow("doublelist") << qVariantFromValue(doubles) << "ad"; + + QVariantList variants; + QTest::newRow("emptyvariantlist") << QVariant(variants) << "av"; + variants << QString("Hello") << QByteArray("World") << 42 << -43.0 << 44U << Q_INT64_C(-45) + << Q_UINT64_C(46) << true << qVariantFromValue(short(-47)); + for (int i = 0; i < variants.count(); ++i) { + QVariant tmp = variants.at(i); + qVariantSetValue(variants[i], tmp); + } + QTest::newRow("variantlist") << QVariant(variants) << "av"; +} + +void Ping::sendArrayOfArrays_data() +{ + sendArrays_data(); +} + +void Ping::sendStringMap_data() +{ + sendBasic_data(); + + QVariant nested; + qVariantSetValue(nested, QVariant(1)); + QTest::newRow("variant") << nested << "v"; + + QVariant nested2; + qVariantSetValue(nested2, nested); + QTest::newRow("variant-variant") << nested2 << "v"; + + sendArrays_data(); +} + +void Ping::sendStringMapOfMap_data() +{ + sendStringMap_data(); +} + +void Ping::sendBasic() +{ + QFETCH(QVariant, value); + + QDBusConnection &con = QDBus::sessionBus(); + + QVERIFY(con.isConnected()); + + QDBusMessage msg = QDBusMessage::methodCall("org.kde.selftest", + "/org/kde/selftest", "org.kde.selftest", "ping"); + msg << value; + + QDBusMessage reply = con.sendWithReply(msg); + // qDebug() << reply; + + QCOMPARE(reply.count(), msg.count()); + QTEST(reply.signature(), "sig"); + for (int i = 0; i < reply.count(); ++i) + QVERIFY(compare(reply.at(i), msg.at(i))); +} + +void Ping::sendVariant() +{ + QFETCH(QVariant, value); + QVariant tmp = value; + qVariantSetValue(value, tmp); + + QDBusConnection &con = QDBus::sessionBus(); + + QVERIFY(con.isConnected()); + + QDBusMessage msg = QDBusMessage::methodCall("org.kde.selftest", + "/org/kde/selftest", "org.kde.selftest", "ping"); + msg << value; + + QDBusMessage reply = con.sendWithReply(msg); + // qDebug() << reply; + + QCOMPARE(reply.count(), msg.count()); + QCOMPARE(reply.signature(), QString("v")); + for (int i = 0; i < reply.count(); ++i) + QVERIFY(compare(reply.at(i), msg.at(i))); } -void Ping::sendPing() +void Ping::sendArrays() { QFETCH(QVariant, value); @@ -115,9 +237,90 @@ void Ping::sendPing() // qDebug() << reply; QCOMPARE(reply.count(), msg.count()); + QTEST(reply.signature(), "sig"); for (int i = 0; i < reply.count(); ++i) - QCOMPARE(reply.at(i), msg.at(i)); + QVERIFY(compare(reply.at(i), msg.at(i))); } +void Ping::sendArrayOfArrays() +{ + QFETCH(QVariant, value); + + QDBusConnection &con = QDBus::sessionBus(); + + QVERIFY(con.isConnected()); + + QDBusMessage msg = QDBusMessage::methodCall("org.kde.selftest", + "/org/kde/selftest", "org.kde.selftest", "ping"); + msg << QVariant(QVariantList() << value << value); + + QDBusMessage reply = con.sendWithReply(msg); + // qDebug() << reply; + + QCOMPARE(reply.count(), msg.count()); + QFETCH(QString, sig); + QCOMPARE(reply.signature(), "a" + sig); + for (int i = 0; i < reply.count(); ++i) + QVERIFY(compare(reply.at(i), msg.at(i))); +} + +void Ping::sendStringMap() +{ + QFETCH(QVariant, value); + + QDBusConnection &con = QDBus::sessionBus(); + + QVERIFY(con.isConnected()); + + QDBusMessage msg = QDBusMessage::methodCall("org.kde.selftest", + "/org/kde/selftest", "org.kde.selftest", "ping"); + + QVariantMap map; + map["foo"] = value; + map["bar"] = value; + msg << QVariant(map); + + QDBusMessage reply = con.sendWithReply(msg); + // qDebug() << reply; + + QCOMPARE(reply.count(), msg.count()); + QFETCH(QString, sig); + QCOMPARE(reply.signature(), "a{s" + sig + "}"); + for (int i = 0; i < reply.count(); ++i) + QVERIFY(compare(reply.at(i), msg.at(i))); +} + +void Ping::sendStringMapOfMap() +{ + QFETCH(QVariant, value); + + QDBusConnection &con = QDBus::sessionBus(); + + QVERIFY(con.isConnected()); + + QDBusMessage msg = QDBusMessage::methodCall("org.kde.selftest", + "/org/kde/selftest", "org.kde.selftest", "ping"); + + QVariantMap map; + map["foo"] = value; + map["bar"] = value; + + QVariantMap map2; + map2["foo"] = map; + msg << QVariant(map2); + + QDBusMessage reply = con.sendWithReply(msg); + // qDebug() << reply; + + QCOMPARE(reply.count(), msg.count()); + QFETCH(QString, sig); + QCOMPARE(reply.signature(), "a{sa{s" + sig + "}}"); + + QEXPECT_FAIL("", "libdbus returns an empty set for un unknown reason", Abort); + for (int i = 0; i < reply.count(); ++i) + QVERIFY(compare(reply.at(i), msg.at(i))); +} + + QTEST_MAIN(Ping) #include "ping.moc" diff --git a/test/qt/qpong.cpp b/test/qt/qpong.cpp index 38e5c78d..4a3e9763 100644 --- a/test/qt/qpong.cpp +++ b/test/qt/qpong.cpp @@ -1,6 +1,6 @@ -#define DBUS_API_SUBJECT_TO_CHANGE #include #include +#include class Pong: public QObject { @@ -11,6 +11,7 @@ public slots: { QDBusMessage reply = QDBusMessage::methodReply(msg); reply << static_cast >(msg); + reply.setSignature(msg.signature()); if (!msg.connection().send(reply)) exit(1); } @@ -21,7 +22,13 @@ int main(int argc, char *argv[]) QCoreApplication app(argc, argv); QDBusConnection &con = QDBus::sessionBus(); - if (!con.requestName("org.kde.selftest")) + QDBusMessage msg = QDBusMessage::methodCall(DBUS_SERVICE_DBUS, + DBUS_PATH_DBUS, + DBUS_INTERFACE_DBUS, + "RequestName"); + msg << "org.kde.selftest" << 0U; + msg = con.sendWithReply(msg); + if (msg.type() != QDBusMessage::ReplyMessage) exit(2); Pong pong; diff --git a/test/qt/tst_qdbusabstractadaptor.cpp b/test/qt/tst_qdbusabstractadaptor.cpp index 5c1c609d..ec3f0470 100644 --- a/test/qt/tst_qdbusabstractadaptor.cpp +++ b/test/qt/tst_qdbusabstractadaptor.cpp @@ -3,15 +3,12 @@ #include -#define DBUS_API_SUBJECT_TO_CHANGE #include #include "common.h" -Q_DECLARE_METATYPE(QVariant) - const char *slotSpy; -QString propSpy; +QString valueSpy; namespace QTest { char *toString(QDBusMessage::MessageType t) @@ -39,8 +36,6 @@ class tst_QDBusAbstractAdaptor: public QObject Q_OBJECT private slots: - void initTestCase(); - void methodCalls_data(); void methodCalls(); void signalEmissions_data(); @@ -50,9 +45,9 @@ private slots: void overloadedSignalEmission(); void readProperties(); void writeProperties(); - void adaptorIntrospection_data(); - void adaptorIntrospection(); - void objectTreeIntrospection(); + + void typeMatching_data(); + void typeMatching(); }; class QDBusSignalSpy: public QObject @@ -88,10 +83,6 @@ class Interface1: public QDBusAbstractAdaptor public: Interface1(QObject *parent) : QDBusAbstractAdaptor(parent) { } - - static QDBusIntrospection::Methods methodData; - static QDBusIntrospection::Signals signalData; - static QDBusIntrospection::Properties propertyData; }; class Interface2: public QDBusAbstractAdaptor @@ -111,7 +102,7 @@ public: { return __PRETTY_FUNCTION__; } void setProp2(const QString &value) - { slotSpy = __PRETTY_FUNCTION__; propSpy = value; } + { slotSpy = __PRETTY_FUNCTION__; valueSpy = value; } void emitSignal(const QString &, const QVariant &) { emit signal(); } @@ -121,11 +112,6 @@ public slots: signals: void signal(); - -public: - static QDBusIntrospection::Methods methodData; - static QDBusIntrospection::Signals signalData; - static QDBusIntrospection::Properties propertyData; }; class Interface3: public QDBusAbstractAdaptor @@ -145,7 +131,7 @@ public: { return __PRETTY_FUNCTION__; } void setProp2(const QString &value) - { slotSpy = __PRETTY_FUNCTION__; propSpy = value; } + { slotSpy = __PRETTY_FUNCTION__; valueSpy = value; } void emitSignal(const QString &name, const QVariant &value) { @@ -166,11 +152,6 @@ 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 @@ -190,7 +171,7 @@ public: { return __PRETTY_FUNCTION__; } void setProp2(const QString &value) - { slotSpy = __PRETTY_FUNCTION__; propSpy = value; } + { slotSpy = __PRETTY_FUNCTION__; valueSpy = value; } void emitSignal(const QString &, const QVariant &value) { @@ -219,84 +200,228 @@ signals: void signal(); void signal(int); void signal(const QString &); +}; +class MyObject: public QObject +{ + Q_OBJECT public: - static QDBusIntrospection::Methods methodData; - static QDBusIntrospection::Signals signalData; - static QDBusIntrospection::Properties propertyData; -}; + Interface1 *if1; + Interface2 *if2; + Interface3 *if3; + Interface4 *if4; + MyObject(int n = 4) + : if1(0), if2(0), if3(0), if4(0) + { + switch (n) + { + case 4: + if4 = new Interface4(this); + case 3: + if3 = new Interface3(this); + case 2: + if2 = new Interface2(this); + case 1: + if1 = new Interface1(this); + } + } +}; -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() +class TypesInterface: public QDBusAbstractAdaptor { - 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; -} + Q_OBJECT + Q_CLASSINFO("D-Bus Interface", "local.TypesInterface") +public: + TypesInterface(QObject *parent) + : QDBusAbstractAdaptor(parent) + { } + + union + { + bool b; + uchar uc; + short s; + ushort us; + int i; + uint ui; + qlonglong ll; + qulonglong ull; + double d; + } dataSpy; + QVariant variantSpy; + QString stringSpy; + QVariantList listSpy; + QStringList stringlistSpy; + QByteArray bytearraySpy; + QVariantMap mapSpy; + +public slots: + void methodBool(bool b) + { + slotSpy = __PRETTY_FUNCTION__; + dataSpy.b = b; + } + + void methodUChar(uchar uc) + { + slotSpy = __PRETTY_FUNCTION__; + dataSpy.uc = uc; + } + + void methodShort(short s) + { + slotSpy = __PRETTY_FUNCTION__; + dataSpy.s = s; + } + + void methodUShort(ushort us) + { + slotSpy = __PRETTY_FUNCTION__; + dataSpy.us = us; + } + + void methodInt(int i) + { + slotSpy = __PRETTY_FUNCTION__; + dataSpy.i = i; + } + + void methodUInt(uint ui) + { + slotSpy = __PRETTY_FUNCTION__; + dataSpy.ui = ui; + } + + void methodLongLong(qlonglong ll) + { + slotSpy = __PRETTY_FUNCTION__; + dataSpy.ll = ll; + } + + void methodULongLong(qulonglong ull) + { + slotSpy = __PRETTY_FUNCTION__; + dataSpy.ull = ull; + } + + void methodDouble(double d) + { + slotSpy = __PRETTY_FUNCTION__; + dataSpy.d = d; + } + + void methodString(const QString &s) + { + slotSpy = __PRETTY_FUNCTION__; + stringSpy = s; + } + + void methodVariant(const QVariant &v) + { + slotSpy = __PRETTY_FUNCTION__; + variantSpy = v; + } + + void methodList(const QVariantList &l) + { + slotSpy = __PRETTY_FUNCTION__; + listSpy = l; + } + + void methodStringList(const QStringList &sl) + { + slotSpy = __PRETTY_FUNCTION__; + stringlistSpy = sl; + } + + void methodByteArray(const QByteArray &ba) + { + slotSpy = __PRETTY_FUNCTION__; + bytearraySpy = ba; + } + + void methodMap(const QVariantMap &m) + { + slotSpy = __PRETTY_FUNCTION__; + mapSpy = m; + } + + bool retrieveBool() + { + return dataSpy.b; + } + + uchar retrieveUChar() + { + return dataSpy.uc; + } + + short retrieveShort() + { + return dataSpy.s; + } + + ushort retrieveUShort() + { + return dataSpy.us; + } + + int retrieveInt() + { + return dataSpy.i; + } + + uint retrieveUInt() + { + return dataSpy.ui; + } + + qlonglong retrieveLongLong() + { + return dataSpy.ll; + } + + qulonglong retrieveULongLong() + { + return dataSpy.ull; + } + + double retrieveDouble() + { + return dataSpy.d; + } + + QString retrieveString() + { + return stringSpy; + } + + QVariant retrieveVariant() + { + return variantSpy; + } + + QVariantList retrieveList() + { + return listSpy; + } + + QStringList retrieveStringList() + { + return stringlistSpy; + } + + QByteArray retrieveByteArray() + { + return bytearraySpy; + } + + QVariantMap retrieveMap() + { + return mapSpy; + } +}; void tst_QDBusAbstractAdaptor::methodCalls_data() { @@ -313,93 +438,78 @@ void tst_QDBusAbstractAdaptor::methodCalls() QDBusConnection &con = QDBus::sessionBus(); QVERIFY(con.isConnected()); - QDBusObject dobj = con.findObject(con.baseService(), "/"); - QVERIFY(dobj.isValid()); + //QDBusInterface *empty = con.findInterface(con.baseService(), "/", QString()); + QDBusInterface *if1 = con.findInterface(con.baseService(), "/", "local.Interface1"); + QDBusInterface *if2 = con.findInterface(con.baseService(), "/", "local.Interface2"); + QDBusInterface *if3 = con.findInterface(con.baseService(), "/", "local.Interface3"); + QDBusInterface *if4 = con.findInterface(con.baseService(), "/", "local.Interface4"); - //QDBusInterface empty(dobj, QString()); - QDBusInterface if1(dobj, "local.Interface1"); - QDBusInterface if2(dobj, "local.Interface2"); - QDBusInterface if3(dobj, "local.Interface3"); - QDBusInterface if4(dobj, "local.Interface4"); + QObject deleter; + if1->setParent(&deleter); + if2->setParent(&deleter); + if3->setParent(&deleter); + if4->setParent(&deleter); // must fail: no object - //QCOMPARE(empty.call("method").type(), QDBusMessage::ErrorMessage); - QCOMPARE(if1.call("method").type(), QDBusMessage::ErrorMessage); - - QObject obj; - con.registerObject("/", &obj); + //QCOMPARE(empty->call("method").type(), QDBusMessage::ErrorMessage); + QCOMPARE(if1->call("method").type(), QDBusMessage::ErrorMessage); 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); - } + MyObject obj(nInterfaces); + con.registerObject("/", &obj); // must fail: no such method - QCOMPARE(if1.call("method").type(), QDBusMessage::ErrorMessage); + 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(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(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(if3->call("methodInt", 42).type(), QDBusMessage::ReplyMessage); QCOMPARE(slotSpy, "void Interface3::methodInt(int)"); - QCOMPARE(if3.call("methodString", QString("")).type(), QDBusMessage::ReplyMessage); + 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(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(if4->call("method.i", 42).type(), QDBusMessage::ReplyMessage); QCOMPARE(slotSpy, "void Interface4::method(int)"); - QCOMPARE(if4.call("method.s", QString()).type(), QDBusMessage::ReplyMessage); + 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, +static void emitSignal(MyObject *obj, const QString &iface, const QString &name, const QVariant ¶meter) { - 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); + obj->if2->emitSignal(name, parameter); else if (iface.endsWith('3')) - if3->emitSignal(name, parameter); + obj->if3->emitSignal(name, parameter); else if (iface.endsWith('4')) - if4->emitSignal(name, parameter); + obj->if4->emitSignal(name, parameter); QTest::qWait(200); } @@ -426,22 +536,29 @@ void tst_QDBusAbstractAdaptor::signalEmissions() QDBusConnection &con = QDBus::sessionBus(); QVERIFY(con.isConnected()); - QDBusObject dobj = con.findObject(con.baseService(), "/"); - QVERIFY(dobj.isValid()); + MyObject obj(3); + con.registerObject("/", &obj); - //QDBusInterface empty(dobj, QString()); - QDBusInterface if2(dobj, "local.Interface2"); - QDBusInterface if3(dobj, "local.Interface3"); + //QDBusInterface empty = con.findInterface(con.baseService(), "/", QString()); + QDBusInterface *if2 = con.findInterface(con.baseService(), "/", "local.Interface2"); + QDBusInterface *if3 = con.findInterface(con.baseService(), "/", "local.Interface3"); + QObject deleter; + if2->setParent(&deleter); + if3->setParent(&deleter); // 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))); + con.connect(con.baseService(), "/", "local.Interface2", "signal", + &spy, SLOT(slot(QDBusMessage))); + con.connect(con.baseService(), "/", "local.Interface3", "signalVoid", + &spy, SLOT(slot(QDBusMessage))); + con.connect(con.baseService(), "/", "local.Interface3", "signalInt", + &spy, SLOT(slot(QDBusMessage))); + con.connect(con.baseService(), "/", "local.Interface3", "signalString", + &spy, SLOT(slot(QDBusMessage))); - emitSignal(con, interface, name, parameter); + emitSignal(&obj, interface, name, parameter); QCOMPARE(spy.count, 1); QCOMPARE(spy.interface, interface); @@ -454,10 +571,10 @@ void tst_QDBusAbstractAdaptor::signalEmissions() { 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")); + emitSignal(&obj, "local.Interface2", "signal", QVariant()); + emitSignal(&obj, "local.Interface3", "signalVoid", QVariant()); + emitSignal(&obj, "local.Interface3", "signalInt", QVariant(1)); + emitSignal(&obj, "local.Interface3", "signalString", QVariant("foo")); QCOMPARE(spy.count, 1); QCOMPARE(spy.interface, interface); @@ -472,15 +589,14 @@ void tst_QDBusAbstractAdaptor::sameSignalDifferentPaths() QDBusConnection &con = QDBus::sessionBus(); QVERIFY(con.isConnected()); - QObject obj; - Interface2 *if2 = new Interface2(&obj); + MyObject obj(2); 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()); + obj.if2->emitSignal(QString(), QVariant()); QTest::qWait(200); QCOMPARE(spy.count, 1); @@ -491,7 +607,7 @@ void tst_QDBusAbstractAdaptor::sameSignalDifferentPaths() // now connect the other one spy.count = 0; con.connect(con.baseService(), "/p2", "local.Interface2", "signal", &spy, SLOT(slot(QDBusMessage))); - if2->emitSignal(QString(), QVariant()); + obj.if2->emitSignal(QString(), QVariant()); QTest::qWait(200); QCOMPARE(spy.count, 2); @@ -511,19 +627,25 @@ void tst_QDBusAbstractAdaptor::overloadedSignalEmission() QDBusConnection &con = QDBus::sessionBus(); QVERIFY(con.isConnected()); + MyObject obj; + con.registerObject("/", &obj); + QString interface = "local.Interface4"; QString name = "signal"; QFETCH(QVariant, parameter); - QDBusInterface if4 = con.findInterface(con.baseService(), "/", interface); + //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))); + con.connect(con.baseService(), "/", "local.Interface4", "signal", "", + &spy, SLOT(slot(QDBusMessage))); + con.connect(con.baseService(), "/", "local.Interface4", "signal", "i", + &spy, SLOT(slot(QDBusMessage))); + con.connect(con.baseService(), "/", "local.Interface4", "signal", "s", + &spy, SLOT(slot(QDBusMessage))); - emitSignal(con, interface, name, parameter); + emitSignal(&obj, interface, name, parameter); QCOMPARE(spy.count, 1); QCOMPARE(spy.interface, interface); @@ -537,9 +659,9 @@ void tst_QDBusAbstractAdaptor::overloadedSignalEmission() { 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")); + emitSignal(&obj, "local.Interface4", "signal", QVariant()); + emitSignal(&obj, "local.Interface4", "signal", QVariant(1)); + emitSignal(&obj, "local.Interface4", "signal", QVariant("foo")); QCOMPARE(spy.count, 1); QCOMPARE(spy.interface, interface); @@ -554,24 +676,21 @@ void tst_QDBusAbstractAdaptor::readProperties() QDBusConnection &con = QDBus::sessionBus(); QVERIFY(con.isConnected()); - QObject obj; - new Interface2(&obj); - new Interface3(&obj); - new Interface4(&obj); + MyObject 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); + 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); + QVariant value = iface->property(propname.toLatin1()); - QVERIFY(value.type == QDBusType('s')); - QVERIFY(value.value.type() == QVariant::String); - QCOMPARE(value.value.toString(), QString("QString %1::%2() const").arg(name, propname)); + QCOMPARE(value.userType(), int(QVariant::String)); + QCOMPARE(value.toString(), QString("QString %1::%2() const").arg(name, propname)); } + iface->deleteLater(); } } @@ -580,28 +699,28 @@ void tst_QDBusAbstractAdaptor::writeProperties() QDBusConnection &con = QDBus::sessionBus(); QVERIFY(con.isConnected()); - QObject obj; - new Interface2(&obj); - new Interface3(&obj); - new Interface4(&obj); + MyObject 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); + QDBusInterface *iface = con.findInterface(con.baseService(), "/", "local." + name); - QDBusVariant value(name); + QVariant value(name); - propSpy.clear(); - iface.setProperty("prop1", value); - QVERIFY(propSpy.isEmpty()); // call mustn't have succeeded + valueSpy.clear(); + iface->setProperty("prop1", value); + QVERIFY(valueSpy.isEmpty()); // call mustn't have succeeded - iface.setProperty("prop2", value); - QCOMPARE(propSpy, name); + iface->setProperty("prop2", value); + QCOMPARE(valueSpy, name); QCOMPARE(QString(slotSpy), QString("void %1::setProp2(const QString&)").arg(name)); + + iface->deleteLater(); } } +#if 0 void tst_QDBusAbstractAdaptor::adaptorIntrospection_data() { methodCalls_data(); @@ -785,7 +904,79 @@ void tst_QDBusAbstractAdaptor::objectTreeIntrospection() QDBusIntrospection::parseObject(xml); QVERIFY(!tree.childObjects.contains("q")); } -} +} +#endif + +static inline QVariant nest(const QVariant& v) +{ + QVariant ret; + qVariantSetValue(ret, v); + return ret; +} + +void tst_QDBusAbstractAdaptor::typeMatching_data() +{ + QTest::addColumn("basename"); + QTest::addColumn("signature"); + QTest::addColumn("value"); + + QTest::newRow("bool") << "Bool" << "b" << QVariant(true); + QTest::newRow("byte") << "UChar" << "y" << qVariantFromValue(uchar(42)); + QTest::newRow("short") << "Short" << "n" << qVariantFromValue(short(-43)); + QTest::newRow("ushort") << "UShort" << "q" << qVariantFromValue(ushort(44)); + QTest::newRow("int") << "Int" << "i" << QVariant(42); + QTest::newRow("uint") << "UInt" << "u" << QVariant(42U); + QTest::newRow("qlonglong") << "LongLong" << "x" << QVariant(Q_INT64_C(42)); + QTest::newRow("qulonglong") << "ULongLong" << "t" << QVariant(Q_UINT64_C(42)); + QTest::newRow("double") << "Double" << "d" << QVariant(2.5); + QTest::newRow("string") << "String" << "s" << QVariant("Hello, World!"); + + QTest::newRow("variant") << "Variant" << "v" << nest(QVariant("Hello again!")); + QTest::newRow("list") << "List" << "av" << QVariant(QVariantList() + << nest(42) + << nest(QString("foo")) + << nest(QByteArray("bar")) + << nest(nest(QString("baz")))); + QTest::newRow("stringlist") << "StringList" << "as" << QVariant(QStringList() << "Hello" << "world"); + QTest::newRow("bytearray") << "ByteArray" << "ay" << QVariant(QByteArray("foo")); + + QVariantMap map; + map["one"] = nest(1); // int + map["The answer to life, the Universe and everything"] = nest(42u); // uint + map["In the beginning..."] = nest(QString("There was nothing")); // string + map["but Unix came and said"] = nest(QByteArray("\"Hello, World\"")); // bytearray + map["two"] = nest(qVariantFromValue(short(2))); // short + QTest::newRow("map") << "Map" << "a{sv}" << QVariant(map); +} + +void tst_QDBusAbstractAdaptor::typeMatching() +{ + QObject obj; + new TypesInterface(&obj); + + QDBusConnection &con = QDBus::sessionBus(); + con.registerObject("/types", &obj); + + QFETCH(QString, basename); + QFETCH(QString, signature); + QFETCH(QVariant, value); + + QDBusMessage reply; + QDBusInterface *iface = con.findInterface(con.baseService(), "/types", "local.TypesInterface"); + + reply = iface->callWithArgs("method" + basename + '.' + signature, QVariantList() << value); + QCOMPARE(reply.type(), QDBusMessage::ReplyMessage); + + reply = iface->call("retrieve" + basename); + QCOMPARE(reply.type(), QDBusMessage::ReplyMessage); + QCOMPARE(reply.count(), 1); + + const QVariant &retval = reply.at(0); + QCOMPARE(retval.userType(), value.userType()); + QVERIFY(compare(retval, value)); + + iface->deleteLater(); +} QTEST_MAIN(tst_QDBusAbstractAdaptor) diff --git a/test/qt/tst_qdbusconnection.cpp b/test/qt/tst_qdbusconnection.cpp index 52fb9ff9..224a02c6 100644 --- a/test/qt/tst_qdbusconnection.cpp +++ b/test/qt/tst_qdbusconnection.cpp @@ -3,7 +3,6 @@ #include -#define DBUS_API_SUBJECT_TO_CHANGE #include class MyObject: public QObject @@ -28,12 +27,6 @@ private slots: void send(); void sendAsync(); void sendSignal(); - void requestName_data(); - void requestName(); - void getNameOwner_data(); - void getNameOwner(); - void releaseName_data(); - void releaseName(); void registerObject(); @@ -159,89 +152,6 @@ void tst_QDBusConnection::addConnection() } } -void tst_QDBusConnection::requestName_data() -{ - QTest::addColumn("requestedName"); - QTest::addColumn("flags"); - QTest::addColumn("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 = QDBus::sessionBus(); - - 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("name"); - QTest::addColumn("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 = QDBus::sessionBus().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 = QDBus::sessionBus(); - QVERIFY(con.isConnected()); - - QString result = con.getNameOwner(name); - - QCOMPARE(result, expectedResult); -} - -void tst_QDBusConnection::releaseName_data() -{ - requestName_data(); -} - -void tst_QDBusConnection::releaseName() -{ - QDBusConnection &con = QDBus::sessionBus(); - - QVERIFY(con.isConnected()); - - QFETCH(QString, requestedName); - //QFETCH(int, flags); - QFETCH(bool, expectedResult); - - bool result = con.releaseName(requestedName); - - QCOMPARE(result, expectedResult); -} - void tst_QDBusConnection::registerObject() { QDBusConnection &con = QDBus::sessionBus(); diff --git a/test/qt/tst_qdbusinterface.cpp b/test/qt/tst_qdbusinterface.cpp index a7f8c704..46dde97a 100644 --- a/test/qt/tst_qdbusinterface.cpp +++ b/test/qt/tst_qdbusinterface.cpp @@ -20,7 +20,6 @@ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * */ -#define DBUS_API_SUBJECT_TO_CHANGE 1 #include #include #include @@ -28,10 +27,11 @@ #include #include +#include "common.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[] = @@ -142,7 +142,6 @@ private slots: void call_data(); void call(); - void introspect_data(); void introspect(); void signal(); @@ -152,7 +151,6 @@ void tst_QDBusInterface::initTestCase() { QDBusConnection &con = QDBus::sessionBus(); QVERIFY(con.isConnected()); - QVERIFY(con.requestName( TEST_SERVICE_NAME )); con.registerObject("/", &obj, QDBusConnection::ExportAdaptors | QDBusConnection::ExportSlots); } @@ -169,16 +167,21 @@ void tst_QDBusInterface::call_data() 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; + QTest::newRow("int-int16") << "ping.n" << input << (QVariantList() << qVariantFromValue(short(1))); // try doing some conversions QVariantList output; output << qVariantFromValue(1U); QTest::newRow("int-uint") << "ping.u" << input << output; + +#if QT_VERSION >= 0x040200 + output.clear(); + output << qVariantFromValue(ushort(1)); QTest::newRow("int-uint16") << "ping.q" << input << output; +#endif - QTest::newRow("int-int64") << "ping.x" << input << (QVariantList() << qVariantFromValue(1LL)); - QTest::newRow("int-uint64") << "ping.t" << input << (QVariantList() << qVariantFromValue(1ULL)); + QTest::newRow("int-int64") << "ping.x" << input << (QVariantList() << qVariantFromValue(Q_INT64_C(1))); + QTest::newRow("int-uint64") << "ping.t" << input << (QVariantList() << qVariantFromValue(Q_UINT64_C(1))); QTest::newRow("int-double") << "ping.d" << input << (QVariantList() << qVariantFromValue(1.0)); output.clear(); @@ -192,13 +195,23 @@ void tst_QDBusInterface::call_data() output.clear(); output << qVariantFromValue(1); - QTest::newRow("string-int") << "ping.i" << input << input; + QTest::newRow("string-int") << "ping.i" << input << output; + +#if QT_VERSION >= 0x040200 + output.clear(); + output << qVariantFromValue(short(1)); QTest::newRow("string-int16") << "ping.n" << input << input; +#endif output.clear(); output << qVariantFromValue(1U); QTest::newRow("string-uint") << "ping.u" << input << output; + +#if QT_VERSION >= 0x040200 + output.clear(); + output << qVariantFromValue(ushort(1)); QTest::newRow("string-uint16") << "ping.q" << input << output; +#endif QTest::newRow("string-int64") << "ping.x" << input << (QVariantList() << qVariantFromValue(1LL)); QTest::newRow("string-uint64") << "ping.t" << input << (QVariantList() << qVariantFromValue(1ULL)); @@ -219,8 +232,8 @@ void tst_QDBusInterface::call_data() void tst_QDBusInterface::call() { QDBusConnection &con = QDBus::sessionBus(); - QDBusInterface iface = con.findInterface(con.baseService(), QLatin1String("/"), - TEST_INTERFACE_NAME); + QDBusInterface *iface = con.findInterface(con.baseService(), QLatin1String("/"), + TEST_INTERFACE_NAME); QFETCH(QString, method); QFETCH(QVariantList, input); @@ -228,30 +241,30 @@ void tst_QDBusInterface::call() QDBusMessage reply; // try first callWithArgs: - reply = iface.callWithArgs(method, input); + reply = iface->callWithArgs(method, input); QCOMPARE(reply.type(), QDBusMessage::ReplyMessage); if (!output.isEmpty()) { QCOMPARE(reply.count(), output.count()); - QCOMPARE(static_cast(reply), output); + QVERIFY(compare(reply, output)); } // try the template methods if (input.isEmpty()) - reply = iface.call(method); + 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()); + reply = iface->call(method, input.at(0).toInt()); break; case QVariant::UInt: - reply = iface.call(method, input.at(0).toUInt()); + reply = iface->call(method, input.at(0).toUInt()); break; case QVariant::String: - reply = iface.call(method, input.at(0).toString()); + reply = iface->call(method, input.at(0).toString()); break; default: @@ -259,73 +272,50 @@ void tst_QDBusInterface::call() break; } else - reply = iface.call(method, input.at(0).toString(), input.at(1).toString()); + 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(reply), output); + QVERIFY(compare(reply, output)); } } -void tst_QDBusInterface::introspect_data() -{ - QTest::addColumn("service"); - QTest::newRow("base") << QDBus::sessionBus().baseService(); - QTest::newRow("name") << TEST_SERVICE_NAME; -} - void tst_QDBusInterface::introspect() { - QFETCH(QString, service); QDBusConnection &con = QDBus::sessionBus(); - QDBusInterface iface = con.findInterface(service, QLatin1String("/"), - TEST_INTERFACE_NAME); + QDBusInterface *iface = con.findInterface(QDBus::sessionBus().baseService(), QLatin1String("/"), + TEST_INTERFACE_NAME); + + const QMetaObject *mo = iface->metaObject(); - QDBusIntrospection::Methods mm = iface.methodData(); - QVERIFY(mm.count() == 2); + qDebug("Improve to a better testcase of QDBusMetaObject"); + QCOMPARE(mo->methodCount() - mo->methodOffset(), 3); + QVERIFY(mo->indexOfSignal(TEST_SIGNAL_NAME "(QString)") != -1); - QDBusIntrospection::Signals sm = iface.signalData(); - QVERIFY(sm.count() == 1); - QVERIFY(sm.contains(TEST_SIGNAL_NAME)); + QCOMPARE(mo->propertyCount() - mo->propertyOffset(), 1); + QVERIFY(mo->indexOfProperty("prop1") != -1); - QDBusIntrospection::Properties pm = iface.propertyData(); - QVERIFY(pm.count() == 1); - QVERIFY(pm.contains("prop1")); + iface->deleteLater(); } void tst_QDBusInterface::signal() { QDBusConnection &con = QDBus::sessionBus(); - QDBusInterface iface = con.findInterface(con.baseService(), QLatin1String("/"), - TEST_INTERFACE_NAME); - - QString signalName = TEST_SIGNAL_NAME; + QDBusInterface *iface = con.findInterface(con.baseService(), QLatin1String("/"), + TEST_INTERFACE_NAME); QString arg = "So long and thanks for all the fish"; { Spy spy; - iface.connect(signalName, &spy, SLOT(spySlot(QString))); + spy.connect(iface, SIGNAL(somethingHappened(QString)), SLOT(spySlot(QString))); - emitSignal(TEST_INTERFACE_NAME, signalName, arg); - QVERIFY(spy.count == 1); + emitSignal(TEST_INTERFACE_NAME, TEST_SIGNAL_NAME, arg); + QCOMPARE(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); - } + iface->deleteLater(); } QTEST_MAIN(tst_QDBusInterface) diff --git a/test/qt/tst_qdbusobject.cpp b/test/qt/tst_qdbusobject.cpp deleted file mode 100644 index 904e98b5..00000000 --- a/test/qt/tst_qdbusobject.cpp +++ /dev/null @@ -1,207 +0,0 @@ -/* -*- C++ -*- - * - * Copyright (C) 2006 Trolltech AS. All rights reserved. - * Author: Thiago Macieira - * - * 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. - * - */ -#define DBUS_API_SUBJECT_TO_CHANGE 1 -#include -#include -#include - -#include - -const char introspectionData[] = - "\n" - "" - - "" - "" - "" - "" - "" - - "" - "" - "" - "" - "" - "" - "" - ""; - -class IntrospectionAdaptor: public QDBusAbstractAdaptor -{ - Q_OBJECT - Q_CLASSINFO("D-Bus Interface", "org.freedesktop.DBus.Introspectable") -public: - IntrospectionAdaptor(QObject *parent) - : QDBusAbstractAdaptor(parent) - { } - -public slots: - - void Introspect(const QDBusMessage &msg) - { - QDBusMessage reply = QDBusMessage::methodReply(msg); - reply << ::introspectionData; - if (!msg.connection().send(reply)) - exit(1); - } -}; - -class MyObject: public QObject -{ - Q_OBJECT -public: - MyObject() - { - new IntrospectionAdaptor(this); - } - -public slots: - - void ping(const QDBusMessage &msg) - { - QDBusMessage reply = QDBusMessage::methodReply(msg); - reply << static_cast >(msg); - if (!msg.connection().send(reply)) - exit(1); - } -}; - -class tst_QDBusObject: public QObject -{ - Q_OBJECT - MyObject obj; - -private slots: - void initTestCase(); // connect to D-Bus - - void construction_data(); - void construction(); - - void introspection_data(); - void introspection(); -}; - -void tst_QDBusObject::initTestCase() -{ - QDBusConnection &con = QDBus::sessionBus(); - QVERIFY(con.isConnected()); - QVERIFY(con.requestName("com.trolltech.tst_qdbusobject")); - - con.registerObject("/", &obj, QDBusConnection::ExportAdaptors | QDBusConnection::ExportSlots); -} - -void tst_QDBusObject::construction_data() -{ - QTest::addColumn("service"); - QTest::addColumn("path"); - QTest::addColumn("isValid"); - QTest::addColumn("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 = QDBus::sessionBus(); - - QFETCH(QString, service); - QFETCH(QString, path); - QFETCH(bool, isValid); - //QFETCH(bool, exists); - - QDBusObject o = con.findObject(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("service"); - QTest::addColumn("path"); - QTest::addColumn("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 = QDBus::sessionBus(); - 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 = QDBus::sessionBus(); - - QFETCH(QString, service); - QFETCH(QString, path); - - QDBusObject o = con.findObject(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" - diff --git a/test/qt/tst_qdbustype.cpp b/test/qt/tst_qdbustype.cpp deleted file mode 100644 index 9520ae6d..00000000 --- a/test/qt/tst_qdbustype.cpp +++ /dev/null @@ -1,273 +0,0 @@ -/* -*- C++ -*- - * - * Copyright (C) 2006 Trolltech AS. All rights reserved. - * Author: Thiago Macieira - * - * 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. - * - */ -#define DBUS_API_SUBJECT_TO_CHANGE 1 -#include -#include - -#include - -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("signature"); - QTest::addColumn("type"); - QTest::addColumn("qvariantType"); - QTest::addColumn("isValid"); - QTest::addColumn("isBasic"); - QTest::addColumn("isContainer"); - QTest::addColumn("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" diff --git a/test/qt/tst_qdbusxmlparser.cpp b/test/qt/tst_qdbusxmlparser.cpp deleted file mode 100644 index d9085703..00000000 --- a/test/qt/tst_qdbusxmlparser.cpp +++ /dev/null @@ -1,578 +0,0 @@ -/* -*- C++ -*- - * - * Copyright (C) 2006 Trolltech AS. All rights reserved. - * Author: Thiago Macieira - * - * 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. - * - */ -#define DBUS_API_SUBJECT_TO_CHANGE 1 -#include -#include -#include - -#include - -#include "common.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(); -}; - -void tst_QDBusXmlParser::parsing_data() -{ - QTest::addColumn("xmlData"); - QTest::addColumn("interfaceCount"); - QTest::addColumn("objectCount"); - - QTest::newRow("null") << QString() << 0 << 0; - QTest::newRow("empty") << QString("") << 0 << 0; - - QTest::newRow("junk") << "" << 0 << 0; - QTest::newRow("interface-inside-junk") << "" - << 0 << 0; - QTest::newRow("object-inside-junk") << "" - << 0 << 0; - - QTest::newRow("zero-interfaces") << "" << 0 << 0; - QTest::newRow("one-interface") << "" << 1 << 0; - - - QTest::newRow("two-interfaces") << "" - "" - << 2 << 0; - - - QTest::newRow("one-object") << "" << 0 << 1; - QTest::newRow("two-objects") << "" << 0 << 2; - - QTest::newRow("i1o1") << "" << 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 = "\n"; - QFETCH(QString, xmlData); - - parsing_common(docType + xmlData); -} - -void tst_QDBusXmlParser::objectWithContent_data() -{ - QTest::addColumn("xmlData"); - QTest::addColumn("probedObject"); - QTest::addColumn("interfaceCount"); - QTest::addColumn("objectCount"); - - QTest::newRow("zero") << "" << "obj" << 0 << 0; - - QString xmlData = "" - "" - ""; - QTest::newRow("one-interface") << xmlData << "obj" << 1 << 0; - QTest::newRow("one-interface2") << xmlData << "obj2" << 0 << 0; - - xmlData = "" - "" - "" - ""; - QTest::newRow("two-interfaces") << xmlData << "obj" << 2 << 0; - QTest::newRow("two-interfaces2") << xmlData << "obj2" << 0 << 0; - - xmlData = "" - "" - "" - "" - "" - ""; - QTest::newRow("two-nodes-two-interfaces") << xmlData << "obj" << 2 << 0; - QTest::newRow("two-nodes-one-interface") << xmlData << "obj2" << 1 << 0; - - xmlData = "" - "" - ""; - QTest::newRow("one-object") << xmlData << "obj" << 0 << 1; - QTest::newRow("one-object2") << xmlData << "obj2" << 0 << 0; - - xmlData = "" - "" - "" - ""; - QTest::newRow("two-objects") << xmlData << "obj" << 0 << 2; - QTest::newRow("two-objects2") << xmlData << "obj2" << 0 << 0; - - xmlData = "" - "" - "" - "" - "" - ""; - 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& 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("xmlDataFragment"); - QTest::addColumn("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") << "" << map; - - // add another method without arguments - method.name = "Bar"; - map << method; - QTest::newRow("two-methods") << "" - "" - << map; - - // invert the order of the XML declaration - QTest::newRow("two-methods-inverse") << "" - "" - << 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") << - "" - "" - "" - << map; - - // arguments - map.clear(); - method.annotations.clear(); - - method.name = "Method"; - method.inputArgs << arg("s"); - map << method; - QTest::newRow("one-in") << - "" - "" - "" << map; - - // two arguments - method.inputArgs << arg("v"); - map.clear(); - map << method; - QTest::newRow("two-in") << - "" - "" - "" - "" << map; - - // one invalid arg - QTest::newRow("two-in-one-invalid") << - "" - "" - "" // this line should be ignored - "" - "" << map; - - // one out argument - method.inputArgs.clear(); - method.outputArgs << arg("s"); - map.clear(); - map << method; - QTest::newRow("one-out") << - "" - "" - "" << map; - - // two in and one out - method.inputArgs << arg("s") << arg("v"); - map.clear(); - map << method; - QTest::newRow("two-in-one-out") << - "" - "" - "" - "" - "" << 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") << - "" - "" - "" << map; - - // two args with name - method.inputArgs << arg("i", "bar"); - map.clear(); - map << method; - QTest::newRow("two-in-with-name") << - "" - "" - "" - "" << 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") << - "" - "" - "" - "" - "" - "" - "" - "" - "" - "" - "" - "" << map; -} - -void tst_QDBusXmlParser::methods() -{ - QString xmlHeader = "" - "", - xmlFooter = "" - ""; - - 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("xmlDataFragment"); - QTest::addColumn("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") << "" << map; - - // add another signal without arguments - signal.name = "Bar"; - map << signal; - QTest::newRow("two-signals") << "" - "" - << map; - - // invert the order of the XML declaration - QTest::newRow("two-signals-inverse") << "" - "" - << 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") << - "" - "" - "" - << map; - - // one out argument - map.clear(); - signal.annotations.clear(); - signal.outputArgs << arg("s"); - signal.name = "Signal"; - map.clear(); - map << signal; - QTest::newRow("one-out") << - "" - "" - "" << map; - - // without saying which direction it is - QTest::newRow("one-out-no-direction") << - "" - "" - "" << map; - - // two args with name - signal.outputArgs << arg("i", "bar"); - map.clear(); - map << signal; - QTest::newRow("two-out-with-name") << - "" - "" - "" - "" << 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") << - "" - "" - "" - "" - "" - "" - "" - "" << map; -} - -void tst_QDBusXmlParser::signals_() -{ - QString xmlHeader = "" - "", - xmlFooter = "" - ""; - - 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("xmlDataFragment"); - QTest::addColumn("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") << "" << map; - - // one writable signal - prop.access = QDBusIntrospection::Property::Write; - map.clear(); - map << prop; - QTest::newRow("one-writable") << "" << map; - - // one read- & writable signal - prop.access = QDBusIntrospection::Property::ReadWrite; - map.clear(); - map << prop; - QTest::newRow("one-read-writable") << "" - << map; - - // two, mixed properties - prop.name = "bar"; - prop.type = QDBusType("i"); - prop.access = QDBusIntrospection::Property::Read; - map << prop; - QTest::newRow("two") << - "" - "" << map; - - // invert the order of the declaration - QTest::newRow("two") << - "" - "" << 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") << - "" - "" - "" - "" - "" << map; - - // and now change the order - QTest::newRow("complex2") << - "" - "" - "" - "" - "" << map; -} - -void tst_QDBusXmlParser::properties() -{ - QString xmlHeader = "" - "", - xmlFooter = "" - ""; - - 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" -- cgit