summaryrefslogtreecommitdiffstats
path: root/tests/auto/qmetaobject/tst_qmetaobject.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tests/auto/qmetaobject/tst_qmetaobject.cpp')
-rw-r--r--tests/auto/qmetaobject/tst_qmetaobject.cpp791
1 files changed, 791 insertions, 0 deletions
diff --git a/tests/auto/qmetaobject/tst_qmetaobject.cpp b/tests/auto/qmetaobject/tst_qmetaobject.cpp
new file mode 100644
index 0000000..b3b7f33
--- /dev/null
+++ b/tests/auto/qmetaobject/tst_qmetaobject.cpp
@@ -0,0 +1,791 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+
+#include <qobject.h>
+#include <qmetaobject.h>
+#include <qlabel.h>
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+struct MyStruct
+{
+ int i;
+};
+
+namespace MyNamespace {
+ class MyClass : public QObject
+ {
+ Q_OBJECT
+ Q_PROPERTY(MyEnum myEnum READ myEnum WRITE setMyEnum)
+ Q_PROPERTY(MyFlags myFlags READ myFlags WRITE setMyFlags)
+
+ Q_ENUMS(MyEnum)
+ Q_FLAGS(MyFlags)
+ public:
+ enum MyEnum {
+ MyEnum1,
+ MyEnum2,
+ MyEnum3
+ };
+
+ enum MyFlag {
+ MyFlag1 = 0x01,
+ MyFlag2 = 0x02,
+ MyFlag3 = 0x04
+ };
+ Q_DECLARE_FLAGS(MyFlags, MyFlag)
+
+ MyEnum myEnum() const { return m_enum; }
+ void setMyEnum(MyEnum val) { m_enum = val; }
+
+ MyFlags myFlags() const { return m_flags; }
+ void setMyFlags(MyFlags val) { m_flags = val; }
+
+ MyClass(QObject *parent = 0)
+ : QObject(parent),
+ m_enum(MyEnum1),
+ m_flags(MyFlag1|MyFlag2)
+ { }
+ private:
+ MyEnum m_enum;
+ MyFlags m_flags;
+ };
+ Q_DECLARE_OPERATORS_FOR_FLAGS(MyClass::MyFlags)
+}
+
+
+class tst_QMetaObject : public QObject
+{
+ Q_OBJECT
+ Q_ENUMS(EnumType)
+ Q_PROPERTY(EnumType value WRITE setValue READ getValue)
+ Q_PROPERTY(EnumType value2 WRITE set_value READ get_value)
+ Q_PROPERTY(MyStruct value3 WRITE setVal3 READ val3)
+ Q_PROPERTY(QList<QVariant> value4 WRITE setVal4 READ val4)
+ Q_PROPERTY(QVariantList value5 WRITE setVal5 READ val5)
+ Q_PROPERTY(int value6 READ value6 NOTIFY value6Changed)
+ Q_PROPERTY(MyStruct value7 READ value7 WRITE setVal7 NOTIFY value7Changed)
+ Q_PROPERTY(int value8 READ value8 NOTIFY value8Changed)
+
+public:
+ enum EnumType { EnumType1 };
+
+ tst_QMetaObject();
+ ~tst_QMetaObject();
+
+ void setValue(EnumType) {}
+ EnumType getValue() const { return EnumType1; }
+
+ void set_value(EnumType) {}
+ EnumType get_value() const { return EnumType1; }
+
+ void setVal3(MyStruct) {}
+ MyStruct val3() const { MyStruct s = {42}; return s; }
+
+ void setVal4(const QList<QVariant> &list) { value4 = list; }
+ QList<QVariant> val4() const { return value4; }
+
+ void setVal5(const QVariantList &list) { value5 = list; }
+ QVariantList val5() const { return value5; }
+
+ int value6() const { return 1; }
+
+ void setVal7(MyStruct) {}
+ MyStruct value7() const { MyStruct s = {42}; return s; }
+
+ int value8() const { return 1; }
+
+ QList<QVariant> value4;
+ QVariantList value5;
+
+public slots:
+ void initTestCase();
+ void cleanupTestCase();
+ void init();
+ void cleanup();
+private slots:
+ void connectSlotsByName();
+ void invokeMetaMember();
+ void invokeQueuedMetaMember();
+ void invokeCustomTypes();
+ void invokeMetaConstructor();
+ void qtMetaObjectInheritance();
+ void normalizedSignature_data();
+ void normalizedSignature();
+ void normalizedType_data();
+ void normalizedType();
+ void customPropertyType();
+ void checkScope();
+ void propertyNotify();
+
+ void stdSet();
+ void classInfo();
+
+signals:
+ void value6Changed();
+ void value7Changed(const QString &);
+};
+
+tst_QMetaObject::tst_QMetaObject()
+{
+
+}
+
+tst_QMetaObject::~tst_QMetaObject()
+{
+
+}
+
+void tst_QMetaObject::initTestCase()
+{
+}
+
+void tst_QMetaObject::cleanupTestCase()
+{
+}
+
+void tst_QMetaObject::init()
+{
+}
+
+void tst_QMetaObject::cleanup()
+{
+}
+
+void tst_QMetaObject::stdSet()
+{
+ const QMetaObject *mo = metaObject();
+
+ QMetaProperty prop = mo->property(mo->indexOfProperty("value"));
+ QVERIFY(prop.isValid());
+ QVERIFY(prop.hasStdCppSet());
+
+ prop = mo->property(mo->indexOfProperty("value2"));
+ QVERIFY(prop.isValid());
+ QVERIFY(!prop.hasStdCppSet());
+}
+
+class CTestObject: public QObject
+{
+ Q_OBJECT
+
+public:
+ CTestObject(): QObject(), invokeCount1(0), invokeCount2(0)
+ {
+ }
+
+ void fire(const QString &name)
+ {
+ child = new QObject(this);
+ child->setObjectName(name);
+ QMetaObject::connectSlotsByName(this);
+ delete child; child = 0;
+ }
+
+ int invokeCount1;
+ int invokeCount2;
+ QObject *child;
+
+public slots:
+ void on_child1_destroyed(QObject *obj = 0) { ++invokeCount1; Q_ASSERT(obj && obj == child); }
+ void on_child2_destroyed() { ++invokeCount2; }
+};
+
+class CTestObjectOverloads: public QObject
+{
+ Q_OBJECT
+
+public:
+ CTestObjectOverloads(): invokeCount1(0), invokeCount2(0) {}
+
+ int invokeCount1;
+ int invokeCount2;
+ QObject *child;
+
+ void fire(const QString &name)
+ {
+ child = new QObject(this);
+ child->setObjectName(name);
+ QMetaObject::connectSlotsByName(this);
+ delete child; child = 0;
+ }
+
+private slots:
+ void on_child1_destroyed(QObject *obj) { ++invokeCount1; Q_ASSERT(obj && obj == child); }
+ void on_child1_destroyed() { ++invokeCount2; }
+};
+
+#if QT_VERSION >= 0x040200
+#define FUNCTION(x) "QMetaObject::" x ": "
+#else
+#define FUNCTION(x) "QMetaObject::" x "(): "
+#endif
+
+void tst_QMetaObject::connectSlotsByName()
+{
+ CTestObject obj;
+ QCOMPARE(obj.invokeCount1, 0);
+ QCOMPARE(obj.invokeCount2, 0);
+
+ QTest::ignoreMessage(QtWarningMsg, FUNCTION("connectSlotsByName") "No matching signal for on_child1_destroyed(QObject*)");
+ QTest::ignoreMessage(QtWarningMsg, FUNCTION("connectSlotsByName") "No matching signal for on_child2_destroyed()");
+ obj.fire("bubu");
+ QCOMPARE(obj.invokeCount1, 0);
+ QCOMPARE(obj.invokeCount2, 0);
+
+ QTest::ignoreMessage(QtWarningMsg, FUNCTION("connectSlotsByName") "No matching signal for on_child2_destroyed()");
+ obj.fire("child1");
+ QCOMPARE(obj.invokeCount1, 1);
+ QCOMPARE(obj.invokeCount2, 0);
+
+ QTest::ignoreMessage(QtWarningMsg, FUNCTION("connectSlotsByName") "No matching signal for on_child1_destroyed(QObject*)");
+ obj.fire("child2");
+ QCOMPARE(obj.invokeCount1, 1);
+ QCOMPARE(obj.invokeCount2, 1);
+
+ QTest::ignoreMessage(QtWarningMsg, FUNCTION("connectSlotsByName") "No matching signal for on_child2_destroyed()");
+ obj.fire("child1");
+ QCOMPARE(obj.invokeCount1, 2);
+ QCOMPARE(obj.invokeCount2, 1);
+
+ // now test with real overloads
+ CTestObjectOverloads obj2;
+ obj2.fire("child1");
+ QCOMPARE(obj2.invokeCount1, 1);
+ QCOMPARE(obj2.invokeCount2, 1);
+}
+
+class QtTestObject: public QObject
+{
+ Q_OBJECT
+
+public:
+ QtTestObject();
+ Q_INVOKABLE QtTestObject(QObject *parent);
+
+public slots:
+ void sl0();
+ QString sl1(QString s1);
+ void sl2(QString s1, QString s2);
+ void sl3(QString s1, QString s2, QString s3);
+ void sl4(QString s1, QString s2, QString s3, const QString s4);
+ void sl5(QString s1, QString s2, QString s3, QString s4, const QString &s5);
+ void sl6(QString s1, QString s2, QString s3, QString s4, const QString s5, QString s6);
+ void sl7(QString s1, QString s2, QString s3, QString s4, QString s5, QString s6, QString s7);
+ void sl8(QString s1, QString s2, QString s3, QString s4, QString s5, QString s6, QString s7,
+ QString s8);
+ void sl9(QString s1, QString s2, QString s3, QString s4, QString s5, QString s6, QString s7,
+ QString s8, QString s9);
+ void sl10(QString s1, QString s2, QString s3, QString s4, QString s5, QString s6, QString s7,
+ QString s8, QString s9, QString s10);
+ QObject *sl11();
+ const char *sl12();
+ QList<QString> sl13(QList<QString> l1);
+ void testSender();
+
+ void testReference(QString &str);
+
+ void testLongLong(qint64 ll1, quint64 ll2);
+
+signals:
+ void sig0();
+ QString sig1(QString s1);
+
+protected:
+ QtTestObject(QVariant) {}
+private:
+ QtTestObject(QVariant, QVariant) {}
+
+public:
+ QString slotResult;
+};
+
+QtTestObject::QtTestObject()
+{
+ connect(this, SIGNAL(sig0()), this, SLOT(sl0()));
+ connect(this, SIGNAL(sig1(QString)), this, SLOT(sl1(QString)));
+}
+
+QtTestObject::QtTestObject(QObject *parent)
+ : QObject(parent)
+{
+}
+
+void QtTestObject::sl0() { slotResult = "sl0"; };
+QString QtTestObject::sl1(QString s1) { slotResult = "sl1:" + s1; return "yessir"; }
+void QtTestObject::sl2(QString s1, QString s2) { slotResult = "sl2:" + s1 + s2; }
+void QtTestObject::sl3(QString s1, QString s2, QString s3)
+{ slotResult = "sl3:" + s1 + s2 + s3; }
+void QtTestObject::sl4(QString s1, QString s2, QString s3, const QString s4)
+{ slotResult = "sl4:" + s1 + s2 + s3 + s4; }
+void QtTestObject::sl5(QString s1, QString s2, QString s3, QString s4, const QString &s5)
+{ slotResult = "sl5:" + s1 + s2 + s3 + s4 + s5; }
+void QtTestObject::sl6(QString s1, QString s2, QString s3, QString s4,
+ const QString s5, QString s6)
+{ slotResult = "sl6:" + s1 + s2 + s3 + s4 + s5 + s6; }
+void QtTestObject::sl7(QString s1, QString s2, QString s3, QString s4, QString s5,
+ QString s6, QString s7)
+{ slotResult = "sl7:" + s1 + s2 + s3 + s4 + s5 + s6 + s7; }
+void QtTestObject::sl8(QString s1, QString s2, QString s3, QString s4, QString s5,
+ QString s6, QString s7, QString s8)
+{ slotResult = "sl8:" + s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8; }
+void QtTestObject::sl9(QString s1, QString s2, QString s3, QString s4, QString s5,
+ QString s6, QString s7, QString s8, QString s9)
+{ slotResult = "sl9:" + s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9; }
+void QtTestObject::sl10(QString s1, QString s2, QString s3, QString s4, QString s5,
+ QString s6, QString s7, QString s8, QString s9, QString s10)
+{ slotResult = "sl10:" + s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10; }
+QObject *QtTestObject::sl11()
+{ slotResult = "sl11"; return this; }
+const char *QtTestObject::sl12()
+{ slotResult = "sl12"; return "foo"; }
+QList<QString> QtTestObject::sl13(QList<QString> l1)
+{ slotResult = "sl13"; return l1; }
+void QtTestObject::testReference(QString &str)
+{ slotResult = "testReference:" + str; str = "gotcha"; }
+
+void QtTestObject::testLongLong(qint64 ll1, quint64 ll2)
+{ slotResult = "testLongLong:" + QString::number(ll1) + "," + QString::number(ll2); }
+
+void QtTestObject::testSender()
+{
+ slotResult.sprintf("%p", sender());
+}
+
+
+void tst_QMetaObject::invokeMetaMember()
+{
+ QtTestObject obj;
+
+ QString t1("1"); QString t2("2"); QString t3("3"); QString t4("4"); QString t5("5");
+ QString t6("6"); QString t7("7"); QString t8("8"); QString t9("9"); QString t10("X");
+
+ QVERIFY(!QMetaObject::invokeMethod(0, 0));
+ QVERIFY(!QMetaObject::invokeMethod(0, "sl0"));
+ QVERIFY(!QMetaObject::invokeMethod(&obj, 0));
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl0"));
+ QCOMPARE(obj.slotResult, QString("sl0"));
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl1", Q_ARG(QString, t1)));
+ QCOMPARE(obj.slotResult, QString("sl1:1"));
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl2", Q_ARG(const QString, t1), Q_ARG(QString, t2)));
+ QCOMPARE(obj.slotResult, QString("sl2:12"));
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl3", Q_ARG(QString, t1), Q_ARG(QString, t2), Q_ARG(QString, t3)));
+ QCOMPARE(obj.slotResult, QString("sl3:123"));
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl4", Q_ARG(QString, t1), Q_ARG(QString, t2), Q_ARG(QString, t3),
+ Q_ARG(QString, t4)));
+ QCOMPARE(obj.slotResult, QString("sl4:1234"));
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl5", Q_ARG(QString, t1), Q_ARG(QString, t2), Q_ARG(QString, t3),
+ Q_ARG(QString, t4), Q_ARG(QString, "5")));
+ QCOMPARE(obj.slotResult, QString("sl5:12345"));
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl6", Q_ARG(QString, t1), Q_ARG(QString, t2), Q_ARG(QString, t3),
+ Q_ARG(QString, t4), Q_ARG(QString, t5), Q_ARG(QString, t6)));
+ QCOMPARE(obj.slotResult, QString("sl6:123456"));
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl7", Q_ARG(QString, t1), Q_ARG(QString, t2), Q_ARG(QString, t3),
+ Q_ARG(QString, t4), Q_ARG(QString, t5), Q_ARG(QString, t6),
+ Q_ARG(QString, t7)));
+ QCOMPARE(obj.slotResult, QString("sl7:1234567"));
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl8", Q_ARG(QString, t1), Q_ARG(QString, t2), Q_ARG(QString, t3),
+ Q_ARG(QString, t4), Q_ARG(QString, t5), Q_ARG(QString, t6),
+ Q_ARG(QString, t7), Q_ARG(QString, t8)));
+ QCOMPARE(obj.slotResult, QString("sl8:12345678"));
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl9", Q_ARG(QString, t1), Q_ARG(QString, t2), Q_ARG(QString, t3),
+ Q_ARG(QString, t4), Q_ARG(QString, t5), Q_ARG(QString, t6),
+ Q_ARG(QString, t7), Q_ARG(QString, t8), Q_ARG(QString, t9)));
+ QCOMPARE(obj.slotResult, QString("sl9:123456789"));
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl11"));
+ QCOMPARE(obj.slotResult, QString("sl11"));
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "testSender"));
+ QCOMPARE(obj.slotResult, QString("0x0"));
+
+ QString refStr("whatever");
+ QVERIFY(QMetaObject::invokeMethod(&obj, "testReference", QGenericArgument("QString&", &refStr)));
+ QCOMPARE(obj.slotResult, QString("testReference:whatever"));
+ QCOMPARE(refStr, QString("gotcha"));
+
+ qint64 ll1 = -1;
+ quint64 ll2 = 0;
+ QVERIFY(QMetaObject::invokeMethod(&obj,
+ "testLongLong",
+ Q_ARG(qint64, ll1),
+ Q_ARG(quint64, ll2)));
+ QCOMPARE(obj.slotResult, QString("testLongLong:-1,0"));
+
+ QString exp;
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl1", Q_RETURN_ARG(QString, exp), Q_ARG(QString, "bubu")));
+ QCOMPARE(exp, QString("yessir"));
+ QCOMPARE(obj.slotResult, QString("sl1:bubu"));
+
+ QObject *ptr = 0;
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl11", Q_RETURN_ARG(QObject*,ptr)));
+ QCOMPARE(ptr, (QObject *)&obj);
+ QCOMPARE(obj.slotResult, QString("sl11"));
+ // try again with a space:
+ ptr = 0;
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl11", Q_RETURN_ARG(QObject * , ptr)));
+ QCOMPARE(ptr, (QObject *)&obj);
+ QCOMPARE(obj.slotResult, QString("sl11"));
+
+ const char *ptr2 = 0;
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl12", Q_RETURN_ARG(const char*, ptr2)));
+ QVERIFY(ptr2 != 0);
+ QCOMPARE(obj.slotResult, QString("sl12"));
+ // try again with a space:
+ ptr2 = 0;
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl12", Q_RETURN_ARG(char const * , ptr2)));
+ QVERIFY(ptr2 != 0);
+ QCOMPARE(obj.slotResult, QString("sl12"));
+
+ // test w/ template args
+ QList<QString> returnValue, argument;
+ argument << QString("one") << QString("two") << QString("three");
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl13",
+ Q_RETURN_ARG(QList<QString>, returnValue),
+ Q_ARG(QList<QString>, argument)));
+ QCOMPARE(returnValue, argument);
+ QCOMPARE(obj.slotResult, QString("sl13"));
+
+ //test signals
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sig0"));
+ QCOMPARE(obj.slotResult, QString("sl0"));
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sig1", Q_ARG(QString, "baba")));
+ QCOMPARE(obj.slotResult, QString("sl1:baba"));
+
+ exp.clear();
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sig1", Q_RETURN_ARG(QString, exp), Q_ARG(QString, "hehe")));
+ QCOMPARE(exp, QString("yessir"));
+ QCOMPARE(obj.slotResult, QString("sl1:hehe"));
+}
+
+void tst_QMetaObject::invokeQueuedMetaMember()
+{
+ QtTestObject obj;
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl0", Qt::QueuedConnection));
+ QVERIFY(obj.slotResult.isEmpty());
+ qApp->processEvents(QEventLoop::AllEvents);
+ QCOMPARE(obj.slotResult, QString("sl0"));
+ obj.slotResult = QString();
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl1", Qt::QueuedConnection, Q_ARG(QString, QString("hallo"))));
+ QVERIFY(obj.slotResult.isEmpty());
+ qApp->processEvents(QEventLoop::AllEvents);
+ QCOMPARE(obj.slotResult, QString("sl1:hallo"));
+ obj.slotResult = QString();
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl9", Qt::QueuedConnection, Q_ARG(QString, "1"), Q_ARG(QString, "2"),
+ Q_ARG(QString, "3"), Q_ARG(QString, "4"), Q_ARG(QString, "5"),
+ Q_ARG(QString, "6"), Q_ARG(QString, "7"), Q_ARG(QString, "8"),
+ Q_ARG(QString, "9")));
+ QVERIFY(obj.slotResult.isEmpty());
+ qApp->processEvents(QEventLoop::AllEvents);
+ QCOMPARE(obj.slotResult, QString("sl9:123456789"));
+
+ // signals
+
+ obj.slotResult.clear();
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sig0", Qt::QueuedConnection));
+ QVERIFY(obj.slotResult.isEmpty());
+ qApp->processEvents(QEventLoop::AllEvents);
+ QCOMPARE(obj.slotResult, QString("sl0"));
+
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sig1", Qt::QueuedConnection, Q_ARG(QString, "gogo")));
+ qApp->processEvents(QEventLoop::AllEvents);
+ QCOMPARE(obj.slotResult, QString("sl1:gogo"));
+
+ QString exp;
+ QTest::ignoreMessage(QtWarningMsg, "QMetaMethod::invoke: Unable to invoke methods with return values in queued connections");
+ QVERIFY(!QMetaObject::invokeMethod(&obj, "sig1", Qt::QueuedConnection, Q_RETURN_ARG(QString, exp),
+ Q_ARG(QString, "nono")));
+
+ qint64 ll1 = -1;
+ quint64 ll2 = 0;
+ QVERIFY(QMetaObject::invokeMethod(&obj,
+ "testLongLong",
+ Qt::QueuedConnection,
+ Q_ARG(qint64, ll1),
+ Q_ARG(quint64, ll2)));
+ qApp->processEvents(QEventLoop::AllEvents);
+ QCOMPARE(obj.slotResult, QString("testLongLong:-1,0"));
+}
+
+
+void tst_QMetaObject::qtMetaObjectInheritance()
+{
+ QVERIFY(QObject::staticMetaObject.superClass() == 0);
+ QCOMPARE(QLabel::staticMetaObject.indexOfEnumerator("Qt::Alignment"), -1);
+ QCOMPARE(QLabel::staticMetaObject.indexOfEnumerator("Alignment"), -1);
+ int indexOfAlignment = QLabel::staticMetaObject.indexOfProperty("alignment");
+ QVERIFY(indexOfAlignment != -1);
+ QMetaProperty alignment = QLabel::staticMetaObject.property(indexOfAlignment);
+ QVERIFY(alignment.isValid());
+ QCOMPARE(alignment.enumerator().name(), "Alignment");
+}
+
+struct MyType
+{
+ int i1, i2, i3;
+};
+
+class QtTestCustomObject: public QObject
+{
+ Q_OBJECT
+public:
+ QtTestCustomObject(): QObject(), sum(0) {}
+
+public slots:
+ void sl1(MyType myType);
+
+public:
+ int sum;
+};
+
+void QtTestCustomObject::sl1(MyType myType)
+{
+ sum = myType.i1 + myType.i2 + myType.i3;
+}
+
+void tst_QMetaObject::invokeCustomTypes()
+{
+ QtTestCustomObject obj;
+ MyType tp = {1, 1, 1};
+
+ QCOMPARE(obj.sum, 0);
+ QVERIFY(QMetaObject::invokeMethod(&obj, "sl1", Q_ARG(MyType, tp)));
+ QCOMPARE(obj.sum, 3);
+}
+
+void tst_QMetaObject::invokeMetaConstructor()
+{
+ const QMetaObject *mo = &QtTestObject::staticMetaObject;
+ {
+ QObject *obj = mo->newInstance();
+ QVERIFY(obj == 0);
+ }
+ {
+ QtTestObject obj;
+ QObject *obj2 = mo->newInstance(Q_ARG(QObject*, &obj));
+ QVERIFY(obj2 != 0);
+ QCOMPARE(obj2->parent(), (QObject*)&obj);
+ QVERIFY(qobject_cast<QtTestObject*>(obj2) != 0);
+ }
+}
+
+void tst_QMetaObject::normalizedSignature_data()
+{
+ QTest::addColumn<QString>("signature");
+ QTest::addColumn<QString>("result");
+
+ QTest::newRow("function") << "void foo()" << "void foo()";
+ QTest::newRow("spaces") << " void foo( ) " << "void foo()";
+ QTest::newRow("template args") << " void foo( QMap<a, a>, QList<b>) "
+ << "void foo(QMap<a,a>,QList<b>)";
+ QTest::newRow("rettype") << "QList<int, int> foo()" << "QList<int,int>foo()";
+ QTest::newRow("const rettype") << "const QString *foo()" << "const QString*foo()";
+ QTest::newRow("const ref") << "const QString &foo()" << "const QString&foo()";
+ QTest::newRow("reference") << "QString &foo()" << "QString&foo()";
+ QTest::newRow("const2") << "void foo(QString const *)" << "void foo(const QString*)";
+ QTest::newRow("const2") << "void foo(QString * const)" << "void foo(QString*const)";
+ QTest::newRow("const3") << "void foo(QString const &)" << "void foo(QString)";
+ QTest::newRow("const4") << "void foo(const int)" << "void foo(int)";
+ QTest::newRow("const5") << "void foo(const int, int const, const int &, int const &)"
+ << "void foo(int,int,int,int)";
+ QTest::newRow("const6") << "void foo(QList<const int>)" << "void foo(QList<const int>)";
+ QTest::newRow("const7") << "void foo(QList<const int*>)" << "void foo(QList<const int*>)";
+ QTest::newRow("const7") << "void foo(QList<int const*>)" << "void foo(QList<const int*>)";
+}
+
+void tst_QMetaObject::normalizedSignature()
+{
+ QFETCH(QString, signature);
+ QFETCH(QString, result);
+
+ QCOMPARE(QString::fromLatin1(QMetaObject::normalizedSignature(signature.toLatin1())), result);
+}
+
+void tst_QMetaObject::normalizedType_data()
+{
+ QTest::addColumn<QString>("type");
+ QTest::addColumn<QString>("result");
+
+ QTest::newRow("simple") << "int" << "int";
+ QTest::newRow("white") << " int " << "int";
+ QTest::newRow("const1") << "int const *" << "const int*";
+ QTest::newRow("const2") << "const int *" << "const int*";
+ QTest::newRow("template1") << "QList<int const *>" << "QList<const int*>";
+ QTest::newRow("template2") << "QList<const int *>" << "QList<const int*>";
+ QTest::newRow("template3") << "QMap<QString, int>" << "QMap<QString,int>";
+ QTest::newRow("template4") << "const QMap<QString, int> &" << "QMap<QString,int>";
+ QTest::newRow("template5") << "QList< ::Foo::Bar>" << "QList< ::Foo::Bar>";
+ QTest::newRow("template6") << "QList<::Foo::Bar>" << "QList<::Foo::Bar>";
+ QTest::newRow("template7") << "QList<QList<int> >" << "QList<QList<int> >";
+ QTest::newRow("value1") << "const QString &" << "QString";
+ QTest::newRow("value2") << "QString const &" << "QString";
+}
+
+void tst_QMetaObject::normalizedType()
+{
+ QFETCH(QString, type);
+ QFETCH(QString, result);
+
+ QCOMPARE(QString::fromLatin1(QMetaObject::normalizedType(type.toLatin1())), result);
+}
+
+void tst_QMetaObject::customPropertyType()
+{
+ QMetaProperty prop = metaObject()->property(metaObject()->indexOfProperty("value3"));
+
+ QCOMPARE(prop.type(), QVariant::UserType);
+ QCOMPARE(prop.userType(), 0);
+
+ qRegisterMetaType<MyStruct>("MyStruct");
+ QCOMPARE(prop.userType(), QMetaType::type("MyStruct"));
+
+ prop = metaObject()->property(metaObject()->indexOfProperty("value4"));
+ QCOMPARE(prop.type(), QVariant::List);
+
+ prop = metaObject()->property(metaObject()->indexOfProperty("value5"));
+ QCOMPARE(prop.type(), QVariant::List);
+}
+
+void tst_QMetaObject::checkScope()
+{
+ MyNamespace::MyClass obj;
+
+ const QMetaObject *mo = obj.metaObject();
+ QMetaEnum me = mo->enumerator(mo->indexOfEnumerator("MyEnum"));
+ QVERIFY(me.isValid());
+ QVERIFY(!me.isFlag());
+ QCOMPARE(QLatin1String(me.scope()), QLatin1String("MyNamespace::MyClass"));
+ QCOMPARE(me.keyToValue("MyNamespace::MyClass::MyEnum2"), 1);
+ QCOMPARE(me.keyToValue("MyClass::MyEnum2"), -1);
+ QCOMPARE(me.keyToValue("MyNamespace::MyEnum2"), -1);
+ QCOMPARE(me.keyToValue("MyEnum2"), 1);
+ QCOMPARE(me.keyToValue("MyEnum"), -1);
+ QCOMPARE(QLatin1String(me.valueToKey(1)), QLatin1String("MyEnum2"));
+
+ QMetaEnum mf = mo->enumerator(mo->indexOfEnumerator("MyFlags"));
+ QVERIFY(mf.isValid());
+ QVERIFY(mf.isFlag());
+ QCOMPARE(QLatin1String(mf.scope()), QLatin1String("MyNamespace::MyClass"));
+ QCOMPARE(mf.keysToValue("MyNamespace::MyClass::MyFlag2"), 2);
+ QCOMPARE(mf.keysToValue("MyClass::MyFlag2"), -1);
+ QCOMPARE(mf.keysToValue("MyNamespace::MyFlag2"), -1);
+ QCOMPARE(mf.keysToValue("MyFlag2"), 2);
+ QCOMPARE(mf.keysToValue("MyFlag"), -1);
+ QCOMPARE(QLatin1String(mf.valueToKey(2)), QLatin1String("MyFlag2"));
+ QCOMPARE(mf.keysToValue("MyNamespace::MyClass::MyFlag1|MyNamespace::MyClass::MyFlag2"), 3);
+ QCOMPARE(mf.keysToValue("MyClass::MyFlag1|MyClass::MyFlag2"), -1);
+ QCOMPARE(mf.keysToValue("MyNamespace::MyFlag1|MyNamespace::MyFlag2"), -1);
+ QCOMPARE(mf.keysToValue("MyFlag1|MyFlag2"), 3);
+ QCOMPARE(mf.keysToValue("MyFlag2|MyFlag2"), 2);
+ QCOMPARE(mf.keysToValue("MyFlag1|MyNamespace::MyClass::MyFlag2"), 3);
+ QCOMPARE(mf.keysToValue("MyNamespace::MyClass::MyFlag2|MyNamespace::MyClass::MyFlag2"), 2);
+ QCOMPARE(QLatin1String(mf.valueToKeys(3)), QLatin1String("MyFlag1|MyFlag2"));
+}
+
+void tst_QMetaObject::propertyNotify()
+{
+ const QMetaObject *mo = metaObject();
+
+ QMetaProperty prop = mo->property(mo->indexOfProperty("value6"));
+ QVERIFY(prop.isValid());
+ QVERIFY(prop.hasNotifySignal());
+ QMetaMethod signal = prop.notifySignal();
+ QCOMPARE(signal.signature(), "value6Changed()");
+
+ prop = mo->property(mo->indexOfProperty("value7"));
+ QVERIFY(prop.isValid());
+ QVERIFY(prop.hasNotifySignal());
+ signal = prop.notifySignal();
+ QCOMPARE(signal.signature(), "value7Changed(QString)");
+
+ prop = mo->property(mo->indexOfProperty("value8"));
+ QVERIFY(prop.isValid());
+ QVERIFY(!prop.hasNotifySignal());
+ signal = prop.notifySignal();
+ QCOMPARE(signal.signature(), (const char *)0);
+
+ prop = mo->property(mo->indexOfProperty("value"));
+ QVERIFY(prop.isValid());
+ QVERIFY(!prop.hasNotifySignal());
+ signal = prop.notifySignal();
+ QCOMPARE(signal.signature(), (const char *)0);
+}
+
+class ClassInfoTestObjectA : public QObject
+{
+ Q_OBJECT
+ Q_CLASSINFO("Author", "Christopher Pike")
+};
+
+class ClassInfoTestObjectB : public ClassInfoTestObjectA
+{
+ Q_OBJECT
+};
+
+void tst_QMetaObject::classInfo()
+{
+ ClassInfoTestObjectB b;
+ int index = b.metaObject()->indexOfClassInfo("Author");
+ QCOMPARE(index, 0);
+ QVERIFY(index <= b.metaObject()->classInfoOffset());
+ QCOMPARE(QLatin1String(b.metaObject()->classInfo(index).value()), QLatin1String("Christopher Pike"));
+}
+
+QTEST_MAIN(tst_QMetaObject)
+#include "tst_qmetaobject.moc"