--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.1, 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.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+#include <QtDeclarative/qdeclarativecomponent.h>
+#include <QtDeclarative/qdeclarativeengine.h>
+#include "../../shared/util.h"
+
+Q_DECLARE_METATYPE(QMetaMethod::MethodType)
+
+class MyQmlObject : public QObject
+{
+ Q_OBJECT
+};
+QML_DECLARE_TYPE(MyQmlObject)
+
+class tst_QDeclarativeMetaObject : public QDeclarativeDataTest
+{
+ Q_OBJECT
+private slots:
+ void initTestCase();
+
+ void property_data();
+ void property();
+ void method_data();
+ void method();
+
+private:
+ MyQmlObject myQmlObject;
+};
+
+void tst_QDeclarativeMetaObject::initTestCase()
+{
+ QDeclarativeDataTest::initTestCase();
+
+ qmlRegisterType<MyQmlObject>("Qt.test", 1,0, "MyQmlObject");
+}
+
+void tst_QDeclarativeMetaObject::property_data()
+{
+ QTest::addColumn<QString>("testFile");
+ QTest::addColumn<QByteArray>("cppTypeName");
+ QTest::addColumn<int>("cppType");
+ QTest::addColumn<bool>("isDefault");
+ QTest::addColumn<QVariant>("expectedValue");
+ QTest::addColumn<bool>("isWritable");
+ QTest::addColumn<QVariant>("newValue");
+
+ QTest::newRow("int") << "property.int.qml"
+ << QByteArray("int") << int(QMetaType::Int)
+ << false // default
+ << QVariant(19) << true << QVariant(42);
+ QTest::newRow("bool") << "property.bool.qml"
+ << QByteArray("bool") << int(QMetaType::Bool)
+ << true // default
+ << QVariant(true) << true << QVariant(false);
+ QTest::newRow("real") << "property.real.qml"
+ << QByteArray("double") << int(QMetaType::Double)
+ << false // default
+ << QVariant(double(21))
+ << true // writable
+ << QVariant(double(37));
+ QTest::newRow("string") << "property.string.qml"
+ << QByteArray("QString") << int(QMetaType::QString)
+ << true // default
+ << QVariant(QString::fromLatin1("dog"))
+ << true // writable
+ << QVariant(QString::fromLatin1("food"));
+ QTest::newRow("url") << "property.url.qml"
+ << QByteArray("QUrl") << int(QMetaType::QUrl)
+ << false // default
+ << QVariant(QUrl("http://foo.bar"))
+ << true //writable
+ << QVariant(QUrl("http://bar.baz"));
+ QTest::newRow("color") << "property.color.qml"
+ << QByteArray("QColor") << int(QMetaType::QColor)
+ << true // default
+ << QVariant(QColor("#ff0000"))
+ << true // writable
+ << QVariant(QColor("#00ff00"));
+ QTest::newRow("date") << "property.date.qml"
+ << QByteArray("QDateTime") << int(QMetaType::QDateTime)
+ << false // default
+ << QVariant(QDateTime(QDate(2012, 2, 7)))
+ << true // writable
+ << QVariant(QDateTime(QDate(2010, 7, 2)));
+ QTest::newRow("variant") << "property.variant.qml"
+ << QByteArray("QVariant") << int(QMetaType::QVariant)
+ << true // default
+ << QVariant(QPointF(12, 34))
+ << true // writable
+ << QVariant(QSizeF(45, 67));
+ QTest::newRow("var") << "property.var.qml"
+ << QByteArray("QVariant") << int(QMetaType::QVariant)
+ << false // default
+ << QVariant(QVariantList() << 5 << true << "ciao")
+ << true // writable
+ << QVariant(QVariantList() << 17.0);
+ QTest::newRow("QtObject") << "property.QtObject.qml"
+ << QByteArray("QObject*") << int(QMetaType::QObjectStar)
+ << false // default
+ << QVariant()
+ << true // writable
+ << QVariant::fromValue(static_cast<QObject*>(this));
+ QTest::newRow("list<QtObject>") << "property.list.QtObject.qml"
+ << QByteArray("QDeclarativeListProperty<QObject>")
+ << qMetaTypeId<QDeclarativeListProperty<QObject> >()
+ << false // default
+ << QVariant()
+ << false // writable
+ << QVariant();
+ QTest::newRow("MyQmlObject") << "property.MyQmlObject.qml"
+ << QByteArray("MyQmlObject*") << qMetaTypeId<MyQmlObject*>()
+ << false // default
+ << QVariant()
+ << true // writable
+ << QVariant::fromValue(&myQmlObject);
+ QTest::newRow("list<MyQmlObject>") << "property.list.MyQmlObject.qml"
+ << QByteArray("QDeclarativeListProperty<MyQmlObject>")
+ << qMetaTypeId<QDeclarativeListProperty<MyQmlObject> >()
+ << false // default
+ << QVariant()
+ << false // writable
+ << QVariant();
+ QTest::newRow("alias") << "property.alias.qml"
+ << QByteArray("QString") << int(QMetaType::QString)
+ << false // default
+ << QVariant(QString::fromLatin1("Joe"))
+ << true // writable
+ << QVariant(QString::fromLatin1("Bob"));
+ QTest::newRow("alias-2") << "property.alias.2.qml"
+ << QByteArray("QObject*") << int(QMetaType::QObjectStar)
+ << false // default
+ << QVariant()
+ << false // writable
+ << QVariant();
+ QTest::newRow("alias-3") << "property.alias.3.qml"
+ << QByteArray("QString") << int(QMetaType::QString)
+ << false // default
+ << QVariant(QString::fromLatin1("Arial"))
+ << true // writable
+ << QVariant(QString::fromLatin1("Helvetica"));
+}
+
+void tst_QDeclarativeMetaObject::property()
+{
+ QFETCH(QString, testFile);
+ QFETCH(QByteArray, cppTypeName);
+ QFETCH(int, cppType);
+ QFETCH(bool, isDefault);
+ QFETCH(QVariant, expectedValue);
+ QFETCH(bool, isWritable);
+ QFETCH(QVariant, newValue);
+
+ QDeclarativeEngine engine;
+ QDeclarativeComponent component(&engine, testFileUrl(testFile));
+ QObject *object = component.create();
+ QVERIFY(object != 0);
+
+ const QMetaObject *mo = object->metaObject();
+ QVERIFY(mo->superClass() != 0);
+ QVERIFY(QByteArray(mo->className()).contains("_QML_"));
+ QCOMPARE(mo->propertyOffset(), mo->superClass()->propertyCount());
+ QCOMPARE(mo->propertyCount(), mo->superClass()->propertyCount() + 1);
+
+ QMetaProperty prop = mo->property(mo->propertyOffset());
+ QCOMPARE(prop.name(), "test");
+
+ QCOMPARE(QByteArray(prop.typeName()), cppTypeName);
+ QEXPECT_FAIL("QtObject", "prop.type() returns UserType for QtObject properties", Continue);
+ QEXPECT_FAIL("alias-2", "prop.type() returns UserType for QtObject properties", Continue);
+ if (prop.userType() < QMetaType::User)
+ QCOMPARE(prop.type(), QVariant::Type(cppType));
+ QCOMPARE(prop.userType(), cppType);
+
+ QVERIFY(!prop.isConstant());
+ QVERIFY(!prop.isDesignable());
+ QVERIFY(!prop.isEnumType());
+ QVERIFY(!prop.isFinal());
+ QVERIFY(!prop.isFlagType());
+ QVERIFY(prop.isReadable());
+ QVERIFY(!prop.isResettable());
+ QVERIFY(prop.isScriptable());
+ QVERIFY(!prop.isStored());
+ QVERIFY(!prop.isUser());
+ QVERIFY(prop.isValid());
+ QCOMPARE(prop.isWritable(), isWritable);
+
+ QCOMPARE(mo->classInfoOffset(), mo->superClass()->classInfoCount());
+ QCOMPARE(mo->classInfoCount(), mo->superClass()->classInfoCount() + (isDefault ? 1 : 0));
+ if (isDefault) {
+ QMetaClassInfo info = mo->classInfo(mo->classInfoOffset());
+ QCOMPARE(info.name(), "DefaultProperty");
+ QCOMPARE(info.value(), "test");
+ }
+
+ QCOMPARE(mo->methodOffset(), mo->superClass()->methodCount());
+ QCOMPARE(mo->methodCount(), mo->superClass()->methodCount() + 1); // the signal
+
+ QVERIFY(prop.notifySignalIndex() != -1);
+ QMetaMethod signal = prop.notifySignal();
+ QCOMPARE(signal.methodType(), QMetaMethod::Signal);
+ QCOMPARE(signal.signature(), "testChanged()");
+ QCOMPARE(signal.access(), QMetaMethod::Protected);
+ QCOMPARE(signal.parameterTypes(), QList<QByteArray>());
+ QCOMPARE(signal.parameterNames(), QList<QByteArray>());
+ QCOMPARE(signal.tag(), "");
+ QCOMPARE(signal.typeName(), "");
+
+ QSignalSpy changedSpy(object, SIGNAL(testChanged()));
+ QObject::connect(object, SIGNAL(testChanged()), object, SLOT(deleteLater()));
+
+ if (expectedValue.isValid())
+ QCOMPARE(prop.read(object), expectedValue);
+ else
+ QVERIFY(prop.read(object).isValid());
+ QCOMPARE(changedSpy.count(), 0);
+
+ if (isWritable) {
+ QVERIFY(prop.write(object, newValue));
+ QCOMPARE(changedSpy.count(), 1);
+ QCOMPARE(prop.read(object), newValue);
+ } else {
+ QVERIFY(!prop.write(object, prop.read(object)));
+ QCOMPARE(changedSpy.count(), 0);
+ }
+
+ delete object;
+}
+
+void tst_QDeclarativeMetaObject::method_data()
+{
+ QTest::addColumn<QString>("testFile");
+ QTest::addColumn<QString>("signature");
+ QTest::addColumn<QMetaMethod::MethodType>("methodType");
+ QTest::addColumn<QString>("returnTypeName");
+ QTest::addColumn<QList<QByteArray> >("parameterTypeNames");
+ QTest::addColumn<QList<QByteArray> >("parameterNames");
+
+ QTest::newRow("testFunction()") << "method.1.qml"
+ << "testFunction()"
+ << QMetaMethod::Slot
+ << "QVariant"
+ << QList<QByteArray>()
+ << QList<QByteArray>();
+ QTest::newRow("testFunction(foo)") << "method.2.qml"
+ << "testFunction(QVariant)"
+ << QMetaMethod::Slot
+ << "QVariant"
+ << (QList<QByteArray>() << "QVariant")
+ << (QList<QByteArray>() << "foo");
+ QTest::newRow("testFunction(foo, bar, baz)") << "method.3.qml"
+ << "testFunction(QVariant,QVariant,QVariant)"
+ << QMetaMethod::Slot
+ << "QVariant"
+ << (QList<QByteArray>() << "QVariant" << "QVariant" << "QVariant")
+ << (QList<QByteArray>() << "foo" << "bar" << "baz");
+ QTest::newRow("testSignal") << "signal.1.qml"
+ << "testSignal()"
+ << QMetaMethod::Signal
+ << ""
+ << QList<QByteArray>()
+ << QList<QByteArray>();
+ QTest::newRow("testSignal(string foo)") << "signal.2.qml"
+ << "testSignal(QString)"
+ << QMetaMethod::Signal
+ << ""
+ << (QList<QByteArray>() << "QString")
+ << (QList<QByteArray>() << "foo");
+ QTest::newRow("testSignal(int foo, bool bar, real baz)") << "signal.3.qml"
+ << "testSignal(int,bool,qreal)"
+ << QMetaMethod::Signal
+ << ""
+ << (QList<QByteArray>() << "int" << "bool" << "qreal")
+ << (QList<QByteArray>() << "foo" << "bar" << "baz");
+ QTest::newRow("testSignal(variant foo, var bar)") << "signal.4.qml"
+ << "testSignal(QVariant,QVariant)"
+ << QMetaMethod::Signal
+ << ""
+ << (QList<QByteArray>() << "QVariant" << "QVariant")
+ << (QList<QByteArray>() << "foo" << "bar");
+ QTest::newRow("testSignal(color foo, date bar, url baz)") << "signal.5.qml"
+ << "testSignal(QColor,QDateTime,QUrl)"
+ << QMetaMethod::Signal
+ << ""
+ << (QList<QByteArray>() << "QColor" << "QDateTime" << "QUrl")
+ << (QList<QByteArray>() << "foo" << "bar" << "baz");
+}
+
+void tst_QDeclarativeMetaObject::method()
+{
+ QFETCH(QString, testFile);
+ QFETCH(QString, signature);
+ QFETCH(QMetaMethod::MethodType, methodType);
+ QFETCH(QString, returnTypeName);
+ QFETCH(QList<QByteArray>, parameterTypeNames);
+ QFETCH(QList<QByteArray>, parameterNames);
+
+ QCOMPARE(parameterTypeNames.size(), parameterNames.size());
+
+ QDeclarativeEngine engine;
+ QDeclarativeComponent component(&engine, testFileUrl(testFile));
+ QObject *object = component.create();
+ QVERIFY(object != 0);
+
+ const QMetaObject *mo = object->metaObject();
+ QVERIFY(mo->superClass() != 0);
+ QVERIFY(QByteArray(mo->className()).contains("_QML_"));
+ QCOMPARE(mo->methodOffset(), mo->superClass()->methodCount());
+ QCOMPARE(mo->methodCount(), mo->superClass()->methodCount() + 1);
+
+ QMetaMethod method = mo->method(mo->methodOffset());
+ QCOMPARE(method.methodType(), methodType);
+ QCOMPARE(QString::fromUtf8(method.signature()), signature);
+ QCOMPARE(method.access(), QMetaMethod::Protected);
+ QCOMPARE(method.parameterTypes(), parameterTypeNames);
+ QCOMPARE(method.parameterNames(), parameterNames);
+ QCOMPARE(method.tag(), "");
+ QCOMPARE(QString::fromUtf8(method.typeName()), returnTypeName);
+
+ delete object;
+}
+
+QTEST_MAIN(tst_QDeclarativeMetaObject)
+
+#include "tst_qdeclarativemetaobject.moc"
projects / profile / ivi / qtdeclarative.git / commitdiff