940d667eb4
In tst_QDBusMetaObject::types(), hold a QMetaObject obtained from QDBusMetaObject::createMetaObject() in a QScopedPointer instead of leaking it. Use correct return value type. This fixes the remaining errors in GCC 6.1 Linux ASan runs of tests/auto/dbus. Change-Id: I1df7f8e42d45f40ecf381fe7b684a8ab5ebee675 Reviewed-by: Alex Blasche <alexander.blasche@qt.io> Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
901 lines
27 KiB
C++
901 lines
27 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the test suite of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
#include <qcoreapplication.h>
|
|
#include <qmetatype.h>
|
|
#include <QtTest/QtTest>
|
|
|
|
#include <QtDBus/QtDBus>
|
|
#include <private/qdbusmetaobject_p.h>
|
|
|
|
class tst_QDBusMetaObject: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
QHash<QString, QDBusMetaObject *> map;
|
|
public slots:
|
|
void init();
|
|
|
|
private slots:
|
|
void initTestCase();
|
|
void types_data();
|
|
void types();
|
|
void methods_data();
|
|
void methods();
|
|
void _signals_data();
|
|
void _signals();
|
|
void properties_data();
|
|
void properties();
|
|
};
|
|
|
|
typedef QPair<QString,QString> StringPair;
|
|
|
|
struct Struct1 { }; // (s)
|
|
struct Struct4 // (ssa(ss)sayasx)
|
|
{
|
|
QString m1;
|
|
QString m2;
|
|
QList<StringPair> m3;
|
|
QString m4;
|
|
QByteArray m5;
|
|
QStringList m6;
|
|
qlonglong m7;
|
|
};
|
|
|
|
Q_DECLARE_METATYPE(Struct1)
|
|
Q_DECLARE_METATYPE(Struct4)
|
|
Q_DECLARE_METATYPE(StringPair)
|
|
|
|
Q_DECLARE_METATYPE(const QMetaObject*)
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
QDBusArgument &operator<<(QDBusArgument &arg, const Struct1 &)
|
|
{
|
|
arg.beginStructure();
|
|
arg << QString();
|
|
arg.endStructure();
|
|
return arg;
|
|
}
|
|
|
|
QDBusArgument &operator<<(QDBusArgument &arg, const StringPair &s)
|
|
{
|
|
arg.beginStructure();
|
|
arg << s.first << s.second;
|
|
arg.endStructure();
|
|
return arg;
|
|
}
|
|
|
|
QDBusArgument &operator<<(QDBusArgument &arg, const Struct4 &s)
|
|
{
|
|
arg.beginStructure();
|
|
arg << s.m1 << s.m2 << s.m3 << s.m4 << s.m5 << s.m6 << s.m7;
|
|
arg.endStructure();
|
|
return arg;
|
|
}
|
|
|
|
const QDBusArgument &operator>>(const QDBusArgument &arg, Struct1 &)
|
|
{ return arg; }
|
|
const QDBusArgument &operator>>(const QDBusArgument &arg, Struct4 &)
|
|
{ return arg; }
|
|
const QDBusArgument &operator>>(const QDBusArgument &arg, StringPair &)
|
|
{ return arg; }
|
|
QT_END_NAMESPACE
|
|
|
|
void tst_QDBusMetaObject::initTestCase()
|
|
{
|
|
qDBusRegisterMetaType<Struct1>();
|
|
qDBusRegisterMetaType<Struct4>();
|
|
qDBusRegisterMetaType<StringPair>();
|
|
|
|
qDBusRegisterMetaType<QList<Struct1> >();
|
|
qDBusRegisterMetaType<QList<Struct4> >();
|
|
}
|
|
|
|
void tst_QDBusMetaObject::init()
|
|
{
|
|
qDeleteAll(map);
|
|
map.clear();
|
|
}
|
|
|
|
// test classes
|
|
class TypesTest1: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(uchar);
|
|
};
|
|
const char TypesTest1_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"y\"/></signal>";
|
|
|
|
class TypesTest2: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(bool);
|
|
};
|
|
const char TypesTest2_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"b\"/></signal>";
|
|
|
|
class TypesTest3: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(short);
|
|
};
|
|
const char TypesTest3_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"n\"/></signal>";
|
|
|
|
class TypesTest4: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(ushort);
|
|
};
|
|
const char TypesTest4_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"q\"/></signal>";
|
|
|
|
class TypesTest5: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(int);
|
|
};
|
|
const char TypesTest5_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"i\"/></signal>";
|
|
|
|
class TypesTest6: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(uint);
|
|
};
|
|
const char TypesTest6_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"u\"/></signal>";
|
|
|
|
class TypesTest7: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(qlonglong);
|
|
};
|
|
const char TypesTest7_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"x\"/></signal>";
|
|
|
|
class TypesTest8: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(qulonglong);
|
|
};
|
|
const char TypesTest8_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"t\"/></signal>";
|
|
|
|
class TypesTest9: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(double);
|
|
};
|
|
const char TypesTest9_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"d\"/></signal>";
|
|
|
|
class TypesTest10: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(QString);
|
|
};
|
|
const char TypesTest10_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"s\"/></signal>";
|
|
|
|
class TypesTest11: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(QDBusObjectPath);
|
|
};
|
|
const char TypesTest11_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"o\"/></signal>";
|
|
|
|
class TypesTest12: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(QDBusSignature);
|
|
};
|
|
const char TypesTest12_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"g\"/></signal>";
|
|
|
|
class TypesTest13: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(QDBusVariant);
|
|
};
|
|
const char TypesTest13_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"v\"/></signal>";
|
|
|
|
class TypesTest14: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(QStringList);
|
|
};
|
|
const char TypesTest14_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"as\"/></signal>";
|
|
|
|
class TypesTest15: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(QByteArray);
|
|
};
|
|
const char TypesTest15_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"ay\"/></signal>";
|
|
|
|
class TypesTest16: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(StringPair);
|
|
};
|
|
const char TypesTest16_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"(ss)\"/>"
|
|
"<annotation name=\"org.qtproject.QtDBus.QtTypeName.Out0\" value=\"StringPair\"></signal>";
|
|
|
|
class TypesTest17: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(Struct1);
|
|
};
|
|
const char TypesTest17_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"(s)\"/>"
|
|
"<annotation name=\"org.qtproject.QtDBus.QtTypeName.Out0\" value=\"Struct1\"></signal>";
|
|
|
|
class TypesTest18: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(Struct4);
|
|
};
|
|
const char TypesTest18_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"(ssa(ss)sayasx)\"/>"
|
|
"<annotation name=\"org.qtproject.QtDBus.QtTypeName.Out0\" value=\"Struct4\"></signal>";
|
|
|
|
class TypesTest19: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(QVariantList);
|
|
};
|
|
const char TypesTest19_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"av\"/>"
|
|
"<annotation name=\"org.qtproject.QtDBus.QtTypeName.Out0\" value=\"QVariantList\"></signal>";
|
|
|
|
class TypesTest20: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(QVariantMap);
|
|
};
|
|
const char TypesTest20_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"a{sv}\"/>"
|
|
"<annotation name=\"org.qtproject.QtDBus.QtTypeName.Out0\" value=\"QVariantMap\"></signal>";
|
|
const char TypesTest20_oldxml[] =
|
|
"<signal name=\"signal\"><arg type=\"a{sv}\"/>"
|
|
"<annotation name=\"com.trolltech.QtDBus.QtTypeName.Out0\" value=\"QVariantMap\"></signal>";
|
|
|
|
|
|
void tst_QDBusMetaObject::types_data()
|
|
{
|
|
QTest::addColumn<const QMetaObject *>("metaobject");
|
|
QTest::addColumn<QString>("xml");
|
|
|
|
QTest::newRow("byte") << &TypesTest1::staticMetaObject << QString(TypesTest1_xml);
|
|
QTest::newRow("bool") << &TypesTest2::staticMetaObject << QString(TypesTest2_xml);
|
|
QTest::newRow("short") << &TypesTest3::staticMetaObject << QString(TypesTest3_xml);
|
|
QTest::newRow("ushort") << &TypesTest4::staticMetaObject << QString(TypesTest4_xml);
|
|
QTest::newRow("int") << &TypesTest5::staticMetaObject << QString(TypesTest5_xml);
|
|
QTest::newRow("uint") << &TypesTest6::staticMetaObject << QString(TypesTest6_xml);
|
|
QTest::newRow("qlonglong") << &TypesTest7::staticMetaObject << QString(TypesTest7_xml);
|
|
QTest::newRow("qulonglong") << &TypesTest8::staticMetaObject << QString(TypesTest8_xml);
|
|
QTest::newRow("double") << &TypesTest9::staticMetaObject << QString(TypesTest9_xml);
|
|
QTest::newRow("QString") << &TypesTest10::staticMetaObject << QString(TypesTest10_xml);
|
|
QTest::newRow("QDBusObjectPath") << &TypesTest11::staticMetaObject << QString(TypesTest11_xml);
|
|
QTest::newRow("QDBusSignature") << &TypesTest12::staticMetaObject << QString(TypesTest12_xml);
|
|
QTest::newRow("QDBusVariant") << &TypesTest13::staticMetaObject << QString(TypesTest13_xml);
|
|
QTest::newRow("QStringList") << &TypesTest14::staticMetaObject << QString(TypesTest14_xml);
|
|
QTest::newRow("QByteArray") << &TypesTest15::staticMetaObject << QString(TypesTest15_xml);
|
|
QTest::newRow("StringPair") << &TypesTest16::staticMetaObject << QString(TypesTest16_xml);
|
|
QTest::newRow("Struct1") << &TypesTest17::staticMetaObject << QString(TypesTest17_xml);
|
|
QTest::newRow("Struct4") << &TypesTest18::staticMetaObject << QString(TypesTest18_xml);
|
|
QTest::newRow("QVariantList") << &TypesTest19::staticMetaObject << QString(TypesTest19_xml);
|
|
QTest::newRow("QVariantMap") << &TypesTest20::staticMetaObject << QString(TypesTest20_xml);
|
|
QTest::newRow("QVariantMap-oldannotation") << &TypesTest20::staticMetaObject << QString(TypesTest20_oldxml);
|
|
}
|
|
|
|
void tst_QDBusMetaObject::types()
|
|
{
|
|
QFETCH(const QMetaObject*, metaobject);
|
|
QFETCH(QString, xml);
|
|
|
|
// add the rest of the XML tags
|
|
xml = QString("<node><interface name=\"local.Interface\">%1</interface></node>")
|
|
.arg(xml);
|
|
|
|
QDBusError error;
|
|
|
|
const QScopedPointer<QDBusMetaObject> result(QDBusMetaObject::createMetaObject("local.Interface", xml, map, error));
|
|
QVERIFY2(result, qPrintable(error.message()));
|
|
|
|
QCOMPARE(result->enumeratorCount(), 0);
|
|
QCOMPARE(result->classInfoCount(), 0);
|
|
|
|
// compare the meta objects
|
|
QCOMPARE(result->methodCount() - result->methodOffset(),
|
|
metaobject->methodCount() - metaobject->methodOffset());
|
|
QCOMPARE(result->propertyCount() - result->propertyOffset(),
|
|
metaobject->propertyCount() - metaobject->propertyOffset());
|
|
|
|
for (int i = metaobject->methodOffset(); i < metaobject->methodCount(); ++i) {
|
|
QMetaMethod expected = metaobject->method(i);
|
|
|
|
int methodIdx = result->indexOfMethod(expected.methodSignature().constData());
|
|
QVERIFY(methodIdx != -1);
|
|
QMetaMethod constructed = result->method(methodIdx);
|
|
|
|
QCOMPARE(int(constructed.access()), int(expected.access()));
|
|
QCOMPARE(int(constructed.methodType()), int(expected.methodType()));
|
|
QCOMPARE(constructed.name(), expected.name());
|
|
QCOMPARE(constructed.parameterCount(), expected.parameterCount());
|
|
QCOMPARE(constructed.parameterNames(), expected.parameterNames());
|
|
QCOMPARE(constructed.parameterTypes(), expected.parameterTypes());
|
|
for (int j = 0; j < constructed.parameterCount(); ++j)
|
|
QCOMPARE(constructed.parameterType(j), expected.parameterType(j));
|
|
QCOMPARE(constructed.tag(), expected.tag());
|
|
QCOMPARE(constructed.typeName(), expected.typeName());
|
|
QCOMPARE(constructed.returnType(), expected.returnType());
|
|
}
|
|
|
|
for (int i = metaobject->propertyOffset(); i < metaobject->propertyCount(); ++i) {
|
|
QMetaProperty expected = metaobject->property(i);
|
|
|
|
int propIdx = result->indexOfProperty(expected.name());
|
|
QVERIFY(propIdx != -1);
|
|
QMetaProperty constructed = result->property(propIdx);
|
|
|
|
QCOMPARE(constructed.isDesignable(), expected.isDesignable());
|
|
QCOMPARE(constructed.isEditable(), expected.isEditable());
|
|
QCOMPARE(constructed.isEnumType(), expected.isEnumType());
|
|
QCOMPARE(constructed.isFlagType(), expected.isFlagType());
|
|
QCOMPARE(constructed.isReadable(), expected.isReadable());
|
|
QCOMPARE(constructed.isResettable(), expected.isResettable());
|
|
QCOMPARE(constructed.isScriptable(), expected.isScriptable());
|
|
QCOMPARE(constructed.isStored(), expected.isStored());
|
|
QCOMPARE(constructed.isUser(), expected.isUser());
|
|
QCOMPARE(constructed.isWritable(), expected.isWritable());
|
|
QCOMPARE(constructed.typeName(), expected.typeName());
|
|
QCOMPARE(constructed.type(), expected.type());
|
|
QCOMPARE(constructed.userType(), expected.userType());
|
|
}
|
|
}
|
|
|
|
class MethodTest1: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public slots:
|
|
void method() { }
|
|
};
|
|
const char MethodTest1_xml[] =
|
|
"<method name=\"method\" />";
|
|
|
|
class MethodTest2: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public slots:
|
|
void method(int) { }
|
|
};
|
|
const char MethodTest2_xml[] =
|
|
"<method name=\"method\"><arg direction=\"in\" type=\"i\"/></method>";
|
|
|
|
class MethodTest3: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public slots:
|
|
void method(int input0) { Q_UNUSED(input0); }
|
|
};
|
|
const char MethodTest3_xml[] =
|
|
"<method name=\"method\"><arg direction=\"in\" type=\"i\" name=\"input0\"/></method>";
|
|
|
|
class MethodTest4: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public slots:
|
|
int method() { return 0; }
|
|
};
|
|
const char MethodTest4_xml[] =
|
|
"<method name=\"method\"><arg direction=\"out\" type=\"i\"/></method>";
|
|
const char MethodTest4_xml2[] =
|
|
"<method name=\"method\"><arg direction=\"out\" type=\"i\" name=\"thisShouldNeverBeSeen\"/></method>";
|
|
|
|
class MethodTest5: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public slots:
|
|
int method(int input0) { return input0; }
|
|
};
|
|
const char MethodTest5_xml[] =
|
|
"<method name=\"method\">"
|
|
"<arg direction=\"in\" type=\"i\" name=\"input0\"/>"
|
|
"<arg direction=\"out\" type=\"i\"/>"
|
|
"</method>";
|
|
|
|
class MethodTest6: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public slots:
|
|
int method(int input0, int input1) { Q_UNUSED(input0); return input1; }
|
|
};
|
|
const char MethodTest6_xml[] =
|
|
"<method name=\"method\">"
|
|
"<arg direction=\"in\" type=\"i\" name=\"input0\"/>"
|
|
"<arg direction=\"out\" type=\"i\"/>"
|
|
"<arg direction=\"in\" type=\"i\" name=\"input1\"/>"
|
|
"</method>";
|
|
|
|
class MethodTest7: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public slots:
|
|
int method(int input0, int input1, int &output1) { output1 = input1; return input0; }
|
|
};
|
|
const char MethodTest7_xml[] =
|
|
"<method name=\"method\">"
|
|
"<arg direction=\"in\" type=\"i\" name=\"input0\"/>"
|
|
"<arg direction=\"in\" type=\"i\" name=\"input1\"/>"
|
|
"<arg direction=\"out\" type=\"i\"/>"
|
|
"<arg direction=\"out\" type=\"i\" name=\"output1\"/>"
|
|
"</method>";
|
|
|
|
class MethodTest8: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public slots:
|
|
int method(int input0, int input1, int &output1, int &output2) { output1 = output2 = input1; return input0; }
|
|
};
|
|
const char MethodTest8_xml[] =
|
|
"<method name=\"method\">"
|
|
"<arg direction=\"in\" type=\"i\" name=\"input0\"/>"
|
|
"<arg direction=\"in\" type=\"i\" name=\"input1\"/>"
|
|
"<arg direction=\"out\" type=\"i\"/>"
|
|
"<arg direction=\"out\" type=\"i\" name=\"output1\"/>"
|
|
"<arg direction=\"out\" type=\"i\" name=\"output2\"/>"
|
|
"</method>";
|
|
|
|
class MethodTest9: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
public slots:
|
|
Q_NOREPLY void method(int) { }
|
|
};
|
|
const char MethodTest9_xml[] =
|
|
"<method name=\"method\">"
|
|
"<arg direction=\"in\" type=\"i\"/>"
|
|
"<annotation name=\"org.freedesktop.DBus.Method.NoReply\" value=\"true\"/>"
|
|
"</method>";
|
|
|
|
void tst_QDBusMetaObject::methods_data()
|
|
{
|
|
QTest::addColumn<const QMetaObject *>("metaobject");
|
|
QTest::addColumn<QString>("xml");
|
|
|
|
QTest::newRow("void-void") << &MethodTest1::staticMetaObject << QString(MethodTest1_xml);
|
|
QTest::newRow("void-int") << &MethodTest2::staticMetaObject << QString(MethodTest2_xml);
|
|
QTest::newRow("void-int-with-name") << &MethodTest3::staticMetaObject << QString(MethodTest3_xml);
|
|
QTest::newRow("int-void") << &MethodTest4::staticMetaObject << QString(MethodTest4_xml);
|
|
QTest::newRow("int-void2") << &MethodTest4::staticMetaObject << QString(MethodTest4_xml2);
|
|
QTest::newRow("int-int") << &MethodTest5::staticMetaObject << QString(MethodTest5_xml);
|
|
QTest::newRow("int-int,int") << &MethodTest6::staticMetaObject << QString(MethodTest6_xml);
|
|
QTest::newRow("int,int-int,int") << &MethodTest7::staticMetaObject << QString(MethodTest7_xml);
|
|
QTest::newRow("int,int,int-int,int") << &MethodTest8::staticMetaObject << QString(MethodTest8_xml);
|
|
QTest::newRow("Q_ASYNC") << &MethodTest9::staticMetaObject << QString(MethodTest9_xml);
|
|
}
|
|
|
|
void tst_QDBusMetaObject::methods()
|
|
{
|
|
types();
|
|
}
|
|
|
|
class SignalTest1: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal();
|
|
};
|
|
const char SignalTest1_xml[] =
|
|
"<signal name=\"signal\" />";
|
|
|
|
class SignalTest2: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(int);
|
|
};
|
|
const char SignalTest2_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"i\"/></signal>";
|
|
|
|
class SignalTest3: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(int output0);
|
|
};
|
|
const char SignalTest3_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"i\" name=\"output0\"/></signal>";
|
|
|
|
class SignalTest4: public QObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
signals:
|
|
void signal(int output0, int);
|
|
};
|
|
const char SignalTest4_xml[] =
|
|
"<signal name=\"signal\"><arg type=\"i\" name=\"output0\"/><arg type=\"i\"/></signal>";
|
|
|
|
void tst_QDBusMetaObject::_signals_data()
|
|
{
|
|
QTest::addColumn<const QMetaObject *>("metaobject");
|
|
QTest::addColumn<QString>("xml");
|
|
|
|
QTest::newRow("empty") << &SignalTest1::staticMetaObject << QString(SignalTest1_xml);
|
|
QTest::newRow("int") << &SignalTest2::staticMetaObject << QString(SignalTest2_xml);
|
|
QTest::newRow("int output0") << &SignalTest3::staticMetaObject << QString(SignalTest3_xml);
|
|
QTest::newRow("int output0,int") << &SignalTest4::staticMetaObject << QString(SignalTest4_xml);
|
|
}
|
|
|
|
void tst_QDBusMetaObject::_signals()
|
|
{
|
|
types();
|
|
}
|
|
|
|
class PropertyTest1: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(int property READ property)
|
|
public:
|
|
int property() { return 0; }
|
|
void setProperty(int) { }
|
|
};
|
|
const char PropertyTest1_xml[] =
|
|
"<property name=\"property\" type=\"i\" access=\"read\"/>";
|
|
|
|
class PropertyTest2: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(int property READ property WRITE setProperty)
|
|
public:
|
|
int property() { return 0; }
|
|
void setProperty(int) { }
|
|
};
|
|
const char PropertyTest2_xml[] =
|
|
"<property name=\"property\" type=\"i\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest3: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(int property WRITE setProperty)
|
|
public:
|
|
int property() { return 0; }
|
|
void setProperty(int) { }
|
|
};
|
|
const char PropertyTest3_xml[] =
|
|
"<property name=\"property\" type=\"i\" access=\"write\"/>";
|
|
|
|
class PropertyTest4: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(Struct1 property WRITE setProperty)
|
|
public:
|
|
Struct1 property() { return Struct1(); }
|
|
void setProperty(Struct1) { }
|
|
};
|
|
const char PropertyTest4_xml[] =
|
|
"<property name=\"property\" type=\"(s)\" access=\"write\">"
|
|
"<annotation name=\"org.qtproject.QtDBus.QtTypeName\" value=\"Struct1\"/>"
|
|
"</property>";
|
|
|
|
class PropertyTest_b: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(bool property READ property WRITE setProperty)
|
|
public:
|
|
bool property() { return false; }
|
|
void setProperty(bool) { }
|
|
};
|
|
const char PropertyTest_b_xml[] =
|
|
"<property name=\"property\" type=\"b\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_y: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(uchar property READ property WRITE setProperty)
|
|
public:
|
|
uchar property() { return 0; }
|
|
void setProperty(uchar) { }
|
|
};
|
|
const char PropertyTest_y_xml[] =
|
|
"<property name=\"property\" type=\"y\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_n: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(short property READ property WRITE setProperty)
|
|
public:
|
|
short property() { return 0; }
|
|
void setProperty(short) { }
|
|
};
|
|
const char PropertyTest_n_xml[] =
|
|
"<property name=\"property\" type=\"n\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_q: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(ushort property READ property WRITE setProperty)
|
|
public:
|
|
ushort property() { return 0; }
|
|
void setProperty(ushort) { }
|
|
};
|
|
const char PropertyTest_q_xml[] =
|
|
"<property name=\"property\" type=\"q\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_u: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(uint property READ property WRITE setProperty)
|
|
public:
|
|
uint property() { return 0; }
|
|
void setProperty(uint) { }
|
|
};
|
|
const char PropertyTest_u_xml[] =
|
|
"<property name=\"property\" type=\"u\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_x: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(qlonglong property READ property WRITE setProperty)
|
|
public:
|
|
qlonglong property() { return 0; }
|
|
void setProperty(qlonglong) { }
|
|
};
|
|
const char PropertyTest_x_xml[] =
|
|
"<property name=\"property\" type=\"x\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_t: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(qulonglong property READ property WRITE setProperty)
|
|
public:
|
|
qulonglong property() { return 0; }
|
|
void setProperty(qulonglong) { }
|
|
};
|
|
const char PropertyTest_t_xml[] =
|
|
"<property name=\"property\" type=\"t\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_d: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(double property READ property WRITE setProperty)
|
|
public:
|
|
double property() { return 0; }
|
|
void setProperty(double) { }
|
|
};
|
|
const char PropertyTest_d_xml[] =
|
|
"<property name=\"property\" type=\"d\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_s: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(QString property READ property WRITE setProperty)
|
|
public:
|
|
QString property() { return QString(); }
|
|
void setProperty(QString) { }
|
|
};
|
|
const char PropertyTest_s_xml[] =
|
|
"<property name=\"property\" type=\"s\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_v: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(QDBusVariant property READ property WRITE setProperty)
|
|
public:
|
|
QDBusVariant property() { return QDBusVariant(); }
|
|
void setProperty(QDBusVariant) { }
|
|
};
|
|
const char PropertyTest_v_xml[] =
|
|
"<property name=\"property\" type=\"v\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_o: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(QDBusObjectPath property READ property WRITE setProperty)
|
|
public:
|
|
QDBusObjectPath property() { return QDBusObjectPath(); }
|
|
void setProperty(QDBusObjectPath) { }
|
|
};
|
|
const char PropertyTest_o_xml[] =
|
|
"<property name=\"property\" type=\"o\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_g: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(QDBusSignature property READ property WRITE setProperty)
|
|
public:
|
|
QDBusSignature property() { return QDBusSignature(); }
|
|
void setProperty(QDBusSignature) { }
|
|
};
|
|
const char PropertyTest_g_xml[] =
|
|
"<property name=\"property\" type=\"g\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_h: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(QDBusUnixFileDescriptor property READ property WRITE setProperty)
|
|
public:
|
|
QDBusUnixFileDescriptor property() { return QDBusUnixFileDescriptor(); }
|
|
void setProperty(QDBusUnixFileDescriptor) { }
|
|
};
|
|
const char PropertyTest_h_xml[] =
|
|
"<property name=\"property\" type=\"h\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_ay: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(QByteArray property READ property WRITE setProperty)
|
|
public:
|
|
QByteArray property() { return QByteArray(); }
|
|
void setProperty(QByteArray) { }
|
|
};
|
|
const char PropertyTest_ay_xml[] =
|
|
"<property name=\"property\" type=\"ay\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_as: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(QStringList property READ property WRITE setProperty)
|
|
public:
|
|
QStringList property() { return QStringList(); }
|
|
void setProperty(QStringList) { }
|
|
};
|
|
const char PropertyTest_as_xml[] =
|
|
"<property name=\"property\" type=\"as\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_av: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(QVariantList property READ property WRITE setProperty)
|
|
public:
|
|
QVariantList property() { return QVariantList(); }
|
|
void setProperty(QVariantList) { }
|
|
};
|
|
const char PropertyTest_av_xml[] =
|
|
"<property name=\"property\" type=\"av\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_ao: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(QList<QDBusObjectPath> property READ property WRITE setProperty)
|
|
public:
|
|
QList<QDBusObjectPath> property() { return QList<QDBusObjectPath>(); }
|
|
void setProperty(QList<QDBusObjectPath>) { }
|
|
};
|
|
const char PropertyTest_ao_xml[] =
|
|
"<property name=\"property\" type=\"ao\" access=\"readwrite\"/>";
|
|
|
|
class PropertyTest_ag: public QObject
|
|
{
|
|
Q_OBJECT
|
|
Q_PROPERTY(QList<QDBusSignature> property READ property WRITE setProperty)
|
|
public:
|
|
QList<QDBusSignature> property() { return QList<QDBusSignature>(); }
|
|
void setProperty(QList<QDBusSignature>) { }
|
|
};
|
|
const char PropertyTest_ag_xml[] =
|
|
"<property name=\"property\" type=\"ag\" access=\"readwrite\"/>";
|
|
|
|
void tst_QDBusMetaObject::properties_data()
|
|
{
|
|
QTest::addColumn<const QMetaObject *>("metaobject");
|
|
QTest::addColumn<QString>("xml");
|
|
|
|
QTest::newRow("read") << &PropertyTest1::staticMetaObject << QString(PropertyTest1_xml);
|
|
QTest::newRow("readwrite") << &PropertyTest2::staticMetaObject << QString(PropertyTest2_xml);
|
|
QTest::newRow("write") << &PropertyTest3::staticMetaObject << QString(PropertyTest3_xml);
|
|
QTest::newRow("customtype") << &PropertyTest4::staticMetaObject << QString(PropertyTest4_xml);
|
|
|
|
QTest::newRow("bool") << &PropertyTest_b::staticMetaObject << QString(PropertyTest_b_xml);
|
|
QTest::newRow("byte") << &PropertyTest_y::staticMetaObject << QString(PropertyTest_y_xml);
|
|
QTest::newRow("short") << &PropertyTest_n::staticMetaObject << QString(PropertyTest_n_xml);
|
|
QTest::newRow("ushort") << &PropertyTest_q::staticMetaObject << QString(PropertyTest_q_xml);
|
|
QTest::newRow("uint") << &PropertyTest_u::staticMetaObject << QString(PropertyTest_u_xml);
|
|
QTest::newRow("qlonglong") << &PropertyTest_x::staticMetaObject << QString(PropertyTest_x_xml);
|
|
QTest::newRow("qulonglong") << &PropertyTest_t::staticMetaObject << QString(PropertyTest_t_xml);
|
|
QTest::newRow("double") << &PropertyTest_d::staticMetaObject << QString(PropertyTest_d_xml);
|
|
QTest::newRow("QString") << &PropertyTest_s::staticMetaObject << QString(PropertyTest_s_xml);
|
|
QTest::newRow("QDBusVariant") << &PropertyTest_v::staticMetaObject << QString(PropertyTest_v_xml);
|
|
QTest::newRow("QDBusObjectPath") << &PropertyTest_o::staticMetaObject << QString(PropertyTest_o_xml);
|
|
QTest::newRow("QDBusSignature") << &PropertyTest_g::staticMetaObject << QString(PropertyTest_g_xml);
|
|
QTest::newRow("QDBusUnixFileDescriptor") << &PropertyTest_h::staticMetaObject << QString(PropertyTest_h_xml);
|
|
QTest::newRow("QByteArray") << &PropertyTest_ay::staticMetaObject << QString(PropertyTest_ay_xml);
|
|
QTest::newRow("QStringList") << &PropertyTest_as::staticMetaObject << QString(PropertyTest_as_xml);
|
|
QTest::newRow("QVariantList") << &PropertyTest_av::staticMetaObject << QString(PropertyTest_av_xml);
|
|
QTest::newRow("QList<QDBusObjectPath>") << &PropertyTest_ao::staticMetaObject << QString(PropertyTest_ao_xml);
|
|
QTest::newRow("QList<QDBusSignature>") << &PropertyTest_ag::staticMetaObject << QString(PropertyTest_ag_xml);
|
|
}
|
|
|
|
void tst_QDBusMetaObject::properties()
|
|
{
|
|
types();
|
|
}
|
|
|
|
|
|
QTEST_MAIN(tst_QDBusMetaObject)
|
|
#include "tst_qdbusmetaobject.moc"
|