/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (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 Technology Preview License Agreement accompanying

** this package.

**

** 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.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <qtest.h>

#include <QtDeclarative/qdeclarativeengine.h>

#include <QtDeclarative/qdeclarativecomponent.h>

#include <QtCore/qfile.h>

#include <QtCore/qdebug.h>

#include <QtCore/qfileinfo.h>

#include <QtCore/qdir.h>

#include <private/qdeclarativeproperty_p.h>

#include <private/qdeclarativemetatype_p.h>

#include <private/qdeclarativeglobal_p.h>

#include "testtypes.h"

#include "../../../shared/util.h"

#include "testhttpserver.h"

DEFINE_BOOL_CONFIG_OPTION(qmlCheckTypes, QML_CHECK_TYPES)

/*

This test case covers QML language issues.  This covers everything that does not

involve evaluating ECMAScript expressions and bindings.

Evaluation of expressions and bindings is covered in qmlecmascript

*/

class tst_qdeclarativelanguage : public QObject

{

    Q_OBJECT

public:

    tst_qdeclarativelanguage() {

        QDeclarativeMetaType::registerCustomStringConverter(qMetaTypeId<MyCustomVariantType>(), myCustomVariantTypeConverter);

        QFileInfo fileInfo(__FILE__);

        engine.addImportPath(fileInfo.absoluteDir().filePath(QLatin1String("data/lib")));

    }

private slots:

    void initTestCase();

    void cleanupTestCase();

    void errors_data();

    void errors();

    void simpleObject();

    void simpleContainer();

    void interfaceProperty();

    void interfaceQList();

    void assignObjectToSignal();

    void assignObjectToVariant();

    void assignLiteralSignalProperty();

    void assignQmlComponent();

    void assignBasicTypes();

    void assignTypeExtremes();

    void assignCompositeToType();

    void assignLiteralToVariant();

    void customParserTypes();

    void rootAsQmlComponent();

    void inlineQmlComponents();

    void idProperty();

    void autoNotifyConnection();

    void assignSignal();

    void dynamicProperties();

    void dynamicPropertiesNested();

    void listProperties();

    void dynamicObjectProperties();

    void dynamicSignalsAndSlots();

    void simpleBindings();

    void autoComponentCreation();

    void propertyValueSource();

    void attachedProperties();

    void dynamicObjects();

    void customVariantTypes();

    void valueTypes();

    void cppnamespace();

    void aliasProperties();

    void componentCompositeType();

    void i18n();

    void i18n_data();

    void onCompleted();

    void onDestruction();

    void scriptString();

    void defaultPropertyListOrder();

    void declaredPropertyValues();

    void basicRemote_data();

    void basicRemote();

    void importsBuiltin_data();

    void importsBuiltin();

    void importsLocal_data();

    void importsLocal();

    void importsRemote_data();

    void importsRemote();

    void importsInstalled_data();

    void importsInstalled();

    void importsOrder_data();

    void importsOrder();

    void qmlAttachedPropertiesObjectMethod();

    void customOnProperty();

    // regression tests for crashes

    void crash1();

    void crash2();

private:

    QDeclarativeEngine engine;

    void testType(const QString& qml, const QString& type, const QString& error);

};

#define VERIFY_ERRORS(errorfile) \

    if (!errorfile) { \

        if (qgetenv("DEBUG") != "" && !component.errors().isEmpty()) \

            qWarning() << "Unexpected Errors:" << component.errors(); \

        QVERIFY(!component.isError()); \

        QVERIFY(component.errors().isEmpty()); \

    } else { \

        QFile file(QLatin1String(SRCDIR) + QLatin1String("/data/") + QLatin1String(errorfile)); \

        QVERIFY(file.open(QIODevice::ReadOnly)); \

        QByteArray data = file.readAll(); \

        file.close(); \

        QList<QByteArray> expected = data.split('\n'); \

        expected.removeAll(QByteArray("")); \

        QList<QDeclarativeError> errors = component.errors(); \

        QList<QByteArray> actual; \

        for (int ii = 0; ii < errors.count(); ++ii) { \

            const QDeclarativeError &error = errors.at(ii); \

            QByteArray errorStr = QByteArray::number(error.line()) + ":" +  \

                                  QByteArray::number(error.column()) + ":" + \

                                  error.description().toUtf8(); \

            actual << errorStr; \

        } \

        if (qgetenv("DEBUG") != "" && expected != actual) \

            qWarning() << "Expected:" << expected << "Actual:" << actual;  \

        if (qgetenv("QDECLARATIVELANGUAGE_UPDATEERRORS") != "" && expected != actual) {\

            QFile file(QLatin1String("data/") + QLatin1String(errorfile)); \

            QVERIFY(file.open(QIODevice::WriteOnly)); \

            for (int ii = 0; ii < actual.count(); ++ii) { \

                file.write(actual.at(ii)); file.write("\n"); \

            } \

            file.close(); \

        } else { \

            QCOMPARE(expected, actual); \

        } \

    }

inline QUrl TEST_FILE(const QString &filename)

{

    QFileInfo fileInfo(__FILE__);

    return QUrl::fromLocalFile(fileInfo.absoluteDir().filePath(QLatin1String("data/") + filename));

}

inline QUrl TEST_FILE(const char *filename)

{

    return TEST_FILE(QLatin1String(filename));

}

void tst_qdeclarativelanguage::cleanupTestCase()

{

    QVERIFY(QFile::remove(TEST_FILE(QString::fromUtf8("I18nType\303\201\303\242\303\243\303\244\303\245.qml")).toLocalFile()));

}

void tst_qdeclarativelanguage::errors_data()

{

    QTest::addColumn<QString>("file");

    QTest::addColumn<QString>("errorFile");

    QTest::addColumn<bool>("create");

    QTest::newRow("nonexistantProperty.1") << "nonexistantProperty.1.qml" << "nonexistantProperty.1.errors.txt" << false;

    QTest::newRow("nonexistantProperty.2") << "nonexistantProperty.2.qml" << "nonexistantProperty.2.errors.txt" << false;

    QTest::newRow("nonexistantProperty.3") << "nonexistantProperty.3.qml" << "nonexistantProperty.3.errors.txt" << false;

    QTest::newRow("nonexistantProperty.4") << "nonexistantProperty.4.qml" << "nonexistantProperty.4.errors.txt" << false;

    QTest::newRow("nonexistantProperty.5") << "nonexistantProperty.5.qml" << "nonexistantProperty.5.errors.txt" << false;

    QTest::newRow("nonexistantProperty.6") << "nonexistantProperty.6.qml" << "nonexistantProperty.6.errors.txt" << false;

    QTest::newRow("wrongType (string for int)") << "wrongType.1.qml" << "wrongType.1.errors.txt" << false;

    QTest::newRow("wrongType (int for bool)") << "wrongType.2.qml" << "wrongType.2.errors.txt" << false;

    QTest::newRow("wrongType (bad rect)") << "wrongType.3.qml" << "wrongType.3.errors.txt" << false;

    QTest::newRow("wrongType (invalid enum)") << "wrongType.4.qml" << "wrongType.4.errors.txt" << false;

    QTest::newRow("wrongType (int for uint)") << "wrongType.5.qml" << "wrongType.5.errors.txt" << false;

    QTest::newRow("wrongType (string for real)") << "wrongType.6.qml" << "wrongType.6.errors.txt" << false;

    QTest::newRow("wrongType (int for color)") << "wrongType.7.qml" << "wrongType.7.errors.txt" << false;

    QTest::newRow("wrongType (int for date)") << "wrongType.8.qml" << "wrongType.8.errors.txt" << false;

    QTest::newRow("wrongType (int for time)") << "wrongType.9.qml" << "wrongType.9.errors.txt" << false;

    QTest::newRow("wrongType (int for datetime)") << "wrongType.10.qml" << "wrongType.10.errors.txt" << false;

    QTest::newRow("wrongType (string for point)") << "wrongType.11.qml" << "wrongType.11.errors.txt" << false;

    QTest::newRow("wrongType (color for size)") << "wrongType.12.qml" << "wrongType.12.errors.txt" << false;

    QTest::newRow("wrongType (number string for int)") << "wrongType.13.qml" << "wrongType.13.errors.txt" << false;

    QTest::newRow("wrongType (int for string)") << "wrongType.14.qml" << "wrongType.14.errors.txt" << false;

    QTest::newRow("wrongType (int for url)") << "wrongType.15.qml" << "wrongType.15.errors.txt" << false;

    QTest::newRow("wrongType (invalid object)") << "wrongType.16.qml" << "wrongType.16.errors.txt" << false;

    QTest::newRow("readOnly.1") << "readOnly.1.qml" << "readOnly.1.errors.txt" << false;

    QTest::newRow("readOnly.2") << "readOnly.2.qml" << "readOnly.2.errors.txt" << false;

    QTest::newRow("readOnly.3") << "readOnly.3.qml" << "readOnly.3.errors.txt" << false;

    QTest::newRow("readOnly.4") << "readOnly.4.qml" << "readOnly.4.errors.txt" << false;

    QTest::newRow("readOnly.5") << "readOnly.5.qml" << "readOnly.5.errors.txt" << false;

    QTest::newRow("listAssignment.1") << "listAssignment.1.qml" << "listAssignment.1.errors.txt" << false;

    QTest::newRow("listAssignment.2") << "listAssignment.2.qml" << "listAssignment.2.errors.txt" << false;

    QTest::newRow("listAssignment.3") << "listAssignment.3.qml" << "listAssignment.3.errors.txt" << false;

    QTest::newRow("invalidID.1") << "invalidID.qml" << "invalidID.errors.txt" << false;

    QTest::newRow("invalidID.2") << "invalidID.2.qml" << "invalidID.2.errors.txt" << false;

    QTest::newRow("invalidID.3") << "invalidID.3.qml" << "invalidID.3.errors.txt" << false;

    QTest::newRow("invalidID.4") << "invalidID.4.qml" << "invalidID.4.errors.txt" << false;

    QTest::newRow("invalidID.5") << "invalidID.5.qml" << "invalidID.5.errors.txt" << false;

    QTest::newRow("invalidID.6") << "invalidID.6.qml" << "invalidID.6.errors.txt" << false;

    QTest::newRow("invalidID.7") << "invalidID.7.qml" << "invalidID.7.errors.txt" << false;

    QTest::newRow("invalidID.8") << "invalidID.8.qml" << "invalidID.8.errors.txt" << false;

    QTest::newRow("invalidID.9") << "invalidID.9.qml" << "invalidID.9.errors.txt" << false;

    QTest::newRow("scriptString.1") << "scriptString.1.qml" << "scriptString.1.errors.txt" << false;

    QTest::newRow("scriptString.2") << "scriptString.2.qml" << "scriptString.2.errors.txt" << false;

    QTest::newRow("unsupportedProperty") << "unsupportedProperty.qml" << "unsupportedProperty.errors.txt" << false;

    QTest::newRow("nullDotProperty") << "nullDotProperty.qml" << "nullDotProperty.errors.txt" << true;

    QTest::newRow("fakeDotProperty") << "fakeDotProperty.qml" << "fakeDotProperty.errors.txt" << false;

    QTest::newRow("duplicateIDs") << "duplicateIDs.qml" << "duplicateIDs.errors.txt" << false;

    QTest::newRow("unregisteredObject") << "unregisteredObject.qml" << "unregisteredObject.errors.txt" << false;

    QTest::newRow("empty") << "empty.qml" << "empty.errors.txt" << false;

    QTest::newRow("missingObject") << "missingObject.qml" << "missingObject.errors.txt" << false;

    QTest::newRow("failingComponent") << "failingComponentTest.qml" << "failingComponent.errors.txt" << false;

    QTest::newRow("missingSignal") << "missingSignal.qml" << "missingSignal.errors.txt" << false;

    QTest::newRow("finalOverride") << "finalOverride.qml" << "finalOverride.errors.txt" << false;

    QTest::newRow("customParserIdNotAllowed") << "customParserIdNotAllowed.qml" << "customParserIdNotAllowed.errors.txt" << false;

    QTest::newRow("invalidGroupedProperty.1") << "invalidGroupedProperty.1.qml" << "invalidGroupedProperty.1.errors.txt" << false;

    QTest::newRow("invalidGroupedProperty.2") << "invalidGroupedProperty.2.qml" << "invalidGroupedProperty.2.errors.txt" << false;

    QTest::newRow("invalidGroupedProperty.3") << "invalidGroupedProperty.3.qml" << "invalidGroupedProperty.3.errors.txt" << false;

    QTest::newRow("invalidGroupedProperty.4") << "invalidGroupedProperty.4.qml" << "invalidGroupedProperty.4.errors.txt" << false;

    QTest::newRow("invalidGroupedProperty.5") << "invalidGroupedProperty.5.qml" << "invalidGroupedProperty.5.errors.txt" << false;

    QTest::newRow("invalidGroupedProperty.6") << "invalidGroupedProperty.6.qml" << "invalidGroupedProperty.6.errors.txt" << false;

    QTest::newRow("invalidGroupedProperty.7") << "invalidGroupedProperty.7.qml" << "invalidGroupedProperty.7.errors.txt" << true;

    QTest::newRow("invalidGroupedProperty.8") << "invalidGroupedProperty.8.qml" << "invalidGroupedProperty.8.errors.txt" << false;

    QTest::newRow("invalidGroupedProperty.9") << "invalidGroupedProperty.9.qml" << "invalidGroupedProperty.9.errors.txt" << false;

    QTest::newRow("invalidGroupedProperty.10") << "invalidGroupedProperty.10.qml" << "invalidGroupedProperty.10.errors.txt" << false;

    QTest::newRow("importNamespaceConflict") << "importNamespaceConflict.qml" << "importNamespaceConflict.errors.txt" << false;

    QTest::newRow("importVersionMissing (builtin)") << "importVersionMissingBuiltIn.qml" << "importVersionMissingBuiltIn.errors.txt" << false;

    QTest::newRow("importVersionMissing (installed)") << "importVersionMissingInstalled.qml" << "importVersionMissingInstalled.errors.txt" << false;

    QTest::newRow("importNonExist (installed)") << "importNonExist.qml" << "importNonExist.errors.txt" << false;

    QTest::newRow("importNonExistOlder (installed)") << "importNonExistOlder.qml" << "importNonExistOlder.errors.txt" << false;

    QTest::newRow("importNewerVersion (installed)") << "importNewerVersion.qml" << "importNewerVersion.errors.txt" << false;

    QTest::newRow("invalidImportID") << "invalidImportID.qml" << "invalidImportID.errors.txt" << false;

    QTest::newRow("signal.1") << "signal.1.qml" << "signal.1.errors.txt" << false;

    QTest::newRow("signal.2") << "signal.2.qml" << "signal.2.errors.txt" << false;

    QTest::newRow("signal.3") << "signal.3.qml" << "signal.3.errors.txt" << false;

    QTest::newRow("signal.4") << "signal.4.qml" << "signal.4.errors.txt" << false;

    QTest::newRow("method.1") << "method.1.qml" << "method.1.errors.txt" << false;

    QTest::newRow("property.1") << "property.1.qml" << "property.1.errors.txt" << false;

    QTest::newRow("property.2") << "property.2.qml" << "property.2.errors.txt" << false;

    QTest::newRow("property.3") << "property.3.qml" << "property.3.errors.txt" << false;

    QTest::newRow("property.4") << "property.4.qml" << "property.4.errors.txt" << false;

    QTest::newRow("property.5") << "property.5.qml" << "property.5.errors.txt" << false;

    QTest::newRow("property.6") << "property.6.qml" << "property.6.errors.txt" << false;

    QTest::newRow("property.7") << "property.7.qml" << "property.7.errors.txt" << false;

    QTest::newRow("importScript.1") << "importscript.1.qml" << "importscript.1.errors.txt" << false;

    QTest::newRow("Component.1") << "component.1.qml" << "component.1.errors.txt" << false;

    QTest::newRow("Component.2") << "component.2.qml" << "component.2.errors.txt" << false;

    QTest::newRow("Component.3") << "component.3.qml" << "component.3.errors.txt" << false;

    QTest::newRow("Component.4") << "component.4.qml" << "component.4.errors.txt" << false;

    QTest::newRow("Component.5") << "component.5.qml" << "component.5.errors.txt" << false;

    QTest::newRow("Component.6") << "component.6.qml" << "component.6.errors.txt" << false;

    QTest::newRow("Component.7") << "component.7.qml" << "component.7.errors.txt" << false;

    QTest::newRow("Component.8") << "component.8.qml" << "component.8.errors.txt" << false;

    QTest::newRow("Component.9") << "component.9.qml" << "component.9.errors.txt" << false;

    QTest::newRow("MultiSet.1") << "multiSet.1.qml" << "multiSet.1.errors.txt" << false;

    QTest::newRow("MultiSet.2") << "multiSet.2.qml" << "multiSet.2.errors.txt" << false;

    QTest::newRow("MultiSet.3") << "multiSet.3.qml" << "multiSet.3.errors.txt" << false;

    QTest::newRow("MultiSet.4") << "multiSet.4.qml" << "multiSet.4.errors.txt" << false;

    QTest::newRow("MultiSet.5") << "multiSet.5.qml" << "multiSet.5.errors.txt" << false;

    QTest::newRow("MultiSet.6") << "multiSet.6.qml" << "multiSet.6.errors.txt" << false;

    QTest::newRow("MultiSet.7") << "multiSet.7.qml" << "multiSet.7.errors.txt" << false;

    QTest::newRow("MultiSet.8") << "multiSet.8.qml" << "multiSet.8.errors.txt" << false;

    QTest::newRow("MultiSet.9") << "multiSet.9.qml" << "multiSet.9.errors.txt" << false;

    QTest::newRow("MultiSet.10") << "multiSet.10.qml" << "multiSet.10.errors.txt" << false;

    QTest::newRow("MultiSet.11") << "multiSet.11.qml" << "multiSet.11.errors.txt" << false;

    QTest::newRow("dynamicMeta.1") << "dynamicMeta.1.qml" << "dynamicMeta.1.errors.txt" << false;

    QTest::newRow("dynamicMeta.2") << "dynamicMeta.2.qml" << "dynamicMeta.2.errors.txt" << false;

    QTest::newRow("dynamicMeta.3") << "dynamicMeta.3.qml" << "dynamicMeta.3.errors.txt" << false;

    QTest::newRow("dynamicMeta.4") << "dynamicMeta.4.qml" << "dynamicMeta.4.errors.txt" << false;

    QTest::newRow("dynamicMeta.5") << "dynamicMeta.5.qml" << "dynamicMeta.5.errors.txt" << false;

    QTest::newRow("invalidAlias.1") << "invalidAlias.1.qml" << "invalidAlias.1.errors.txt" << false;

    QTest::newRow("invalidAlias.2") << "invalidAlias.2.qml" << "invalidAlias.2.errors.txt" << false;

    QTest::newRow("invalidAlias.3") << "invalidAlias.3.qml" << "invalidAlias.3.errors.txt" << false;

    QTest::newRow("invalidAlias.4") << "invalidAlias.4.qml" << "invalidAlias.4.errors.txt" << false;

    QTest::newRow("invalidAlias.5") << "invalidAlias.5.qml" << "invalidAlias.5.errors.txt" << false;

    QTest::newRow("invalidAlias.6") << "invalidAlias.6.qml" << "invalidAlias.6.errors.txt" << false;

    QTest::newRow("invalidAttachedProperty.1") << "invalidAttachedProperty.1.qml" << "invalidAttachedProperty.1.errors.txt" << false;

    QTest::newRow("invalidAttachedProperty.2") << "invalidAttachedProperty.2.qml" << "invalidAttachedProperty.2.errors.txt" << false;

    QTest::newRow("invalidAttachedProperty.3") << "invalidAttachedProperty.3.qml" << "invalidAttachedProperty.3.errors.txt" << false;

    QTest::newRow("invalidAttachedProperty.4") << "invalidAttachedProperty.4.qml" << "invalidAttachedProperty.4.errors.txt" << false;

    QTest::newRow("invalidAttachedProperty.5") << "invalidAttachedProperty.5.qml" << "invalidAttachedProperty.5.errors.txt" << false;

    QTest::newRow("invalidAttachedProperty.6") << "invalidAttachedProperty.6.qml" << "invalidAttachedProperty.6.errors.txt" << false;

    QTest::newRow("invalidAttachedProperty.7") << "invalidAttachedProperty.7.qml" << "invalidAttachedProperty.7.errors.txt" << false;

    QTest::newRow("invalidAttachedProperty.8") << "invalidAttachedProperty.8.qml" << "invalidAttachedProperty.8.errors.txt" << false;

    QTest::newRow("invalidAttachedProperty.9") << "invalidAttachedProperty.9.qml" << "invalidAttachedProperty.9.errors.txt" << false;

    QTest::newRow("invalidAttachedProperty.10") << "invalidAttachedProperty.10.qml" << "invalidAttachedProperty.10.errors.txt" << false;

    QTest::newRow("invalidAttachedProperty.11") << "invalidAttachedProperty.11.qml" << "invalidAttachedProperty.11.errors.txt" << false;

    QTest::newRow("invalidAttachedProperty.12") << "invalidAttachedProperty.12.qml" << "invalidAttachedProperty.12.errors.txt" << false;

    QTest::newRow("invalidAttachedProperty.13") << "invalidAttachedProperty.13.qml" << "invalidAttachedProperty.13.errors.txt" << false;

    QTest::newRow("assignValueToSignal") << "assignValueToSignal.qml" << "assignValueToSignal.errors.txt" << false;

    QTest::newRow("emptySignal") << "emptySignal.qml" << "emptySignal.errors.txt" << false;

    QTest::newRow("nestedErrors") << "nestedErrors.qml" << "nestedErrors.errors.txt" << false;

    QTest::newRow("defaultGrouped") << "defaultGrouped.qml" << "defaultGrouped.errors.txt" << false;

    QTest::newRow("doubleSignal") << "doubleSignal.qml" << "doubleSignal.errors.txt" << false;

    QTest::newRow("invalidRoot") << "invalidRoot.qml" << "invalidRoot.errors.txt" << false;

    QTest::newRow("missingValueTypeProperty") << "missingValueTypeProperty.qml" << "missingValueTypeProperty.errors.txt" << false;

    QTest::newRow("objectValueTypeProperty") << "objectValueTypeProperty.qml" << "objectValueTypeProperty.errors.txt" << false;

    QTest::newRow("enumTypes") << "enumTypes.qml" << "enumTypes.errors.txt" << false;

    QTest::newRow("noCreation") << "noCreation.qml" << "noCreation.errors.txt" << false;

    QTest::newRow("destroyedSignal") << "destroyedSignal.qml" << "destroyedSignal.errors.txt" << false;

    QTest::newRow("assignToNamespace") << "assignToNamespace.qml" << "assignToNamespace.errors.txt" << false;

    QTest::newRow("invalidOn") << "invalidOn.qml" << "invalidOn.errors.txt" << false;

}

void tst_qdeclarativelanguage::errors()

{

    QFETCH(QString, file);

    QFETCH(QString, errorFile);

    QFETCH(bool, create);

    QDeclarativeComponent component(&engine, TEST_FILE(file));

    if(create) {

        QObject *object = component.create();

        QVERIFY(object == 0);

    }

    VERIFY_ERRORS(errorFile.toLatin1().constData());

}

void tst_qdeclarativelanguage::simpleObject()

{

    QDeclarativeComponent component(&engine, TEST_FILE("simpleObject.qml"));

    VERIFY_ERRORS(0);

    QObject *object = component.create();

    QVERIFY(object != 0);

}

void tst_qdeclarativelanguage::simpleContainer()

{

    QDeclarativeComponent component(&engine, TEST_FILE("simpleContainer.qml"));

    VERIFY_ERRORS(0);

    MyContainer *container= qobject_cast<MyContainer*>(component.create());

    QVERIFY(container != 0);

    QCOMPARE(container->getChildren()->count(),2);

}

void tst_qdeclarativelanguage::interfaceProperty()

{

    QDeclarativeComponent component(&engine, TEST_FILE("interfaceProperty.qml"));

    VERIFY_ERRORS(0);

    MyQmlObject *object = qobject_cast<MyQmlObject*>(component.create());

    QVERIFY(object != 0);

    QVERIFY(object->interface());

    QVERIFY(object->interface()->id == 913);

}

void tst_qdeclarativelanguage::interfaceQList()

{

    QDeclarativeComponent component(&engine, TEST_FILE("interfaceQList.qml"));

    VERIFY_ERRORS(0);

    MyContainer *container= qobject_cast<MyContainer*>(component.create());

    QVERIFY(container != 0);

    QVERIFY(container->getQListInterfaces()->count() == 2);

    for(int ii = 0; ii < 2; ++ii)

        QVERIFY(container->getQListInterfaces()->at(ii)->id == 913);

}

void tst_qdeclarativelanguage::assignObjectToSignal()

{

    QDeclarativeComponent component(&engine, TEST_FILE("assignObjectToSignal.qml"));

    VERIFY_ERRORS(0);

    MyQmlObject *object = qobject_cast<MyQmlObject *>(component.create());

    QVERIFY(object != 0);

    QTest::ignoreMessage(QtWarningMsg, "MyQmlObject::basicSlot");

    emit object->basicSignal();

}

void tst_qdeclarativelanguage::assignObjectToVariant()

{

    QDeclarativeComponent component(&engine, TEST_FILE("assignObjectToVariant.qml"));

    VERIFY_ERRORS(0);

    QObject *object = component.create();

    QVERIFY(object != 0);

    QVariant v = object->property("a");

    QVERIFY(v.userType() == qMetaTypeId<QObject *>());

}

void tst_qdeclarativelanguage::assignLiteralSignalProperty()

{

    QDeclarativeComponent component(&engine, TEST_FILE("assignLiteralSignalProperty.qml"));

    VERIFY_ERRORS(0);

    MyQmlObject *object = qobject_cast<MyQmlObject *>(component.create());

    QVERIFY(object != 0);

    QCOMPARE(object->onLiteralSignal(), 10);

}

// Test is an external component can be loaded and assigned (to a qlist)

void tst_qdeclarativelanguage::assignQmlComponent()

{

    QDeclarativeComponent component(&engine, TEST_FILE("assignQmlComponent.qml"));

    VERIFY_ERRORS(0);

    MyContainer *object = qobject_cast<MyContainer *>(component.create());

    QVERIFY(object != 0);

    QVERIFY(object->getChildren()->count() == 1);

    QObject *child = object->getChildren()->at(0);

    QCOMPARE(child->property("x"), QVariant(10));

    QCOMPARE(child->property("y"), QVariant(11));

}

// Test literal assignment to all the basic types 

void tst_qdeclarativelanguage::assignBasicTypes()

{

    QDeclarativeComponent component(&engine, TEST_FILE("assignBasicTypes.qml"));

    VERIFY_ERRORS(0);

    MyTypeObject *object = qobject_cast<MyTypeObject *>(component.create());

    QVERIFY(object != 0);

    QCOMPARE(object->flagProperty(), MyTypeObject::FlagVal1 | MyTypeObject::FlagVal3);

    QCOMPARE(object->enumProperty(), MyTypeObject::EnumVal2);

    QCOMPARE(object->stringProperty(), QString("Hello World!"));

    QCOMPARE(object->uintProperty(), uint(10));

    QCOMPARE(object->intProperty(), -19);

    QCOMPARE((float)object->realProperty(), float(23.2));

    QCOMPARE((float)object->doubleProperty(), float(-19.7));

    QCOMPARE((float)object->floatProperty(), float(8.5));

    QCOMPARE(object->colorProperty(), QColor("red"));

    QCOMPARE(object->dateProperty(), QDate(1982, 11, 25));

    QCOMPARE(object->timeProperty(), QTime(11, 11, 32));

    QCOMPARE(object->dateTimeProperty(), QDateTime(QDate(2009, 5, 12), QTime(13, 22, 1)));

    QCOMPARE(object->pointProperty(), QPoint(99,13));

    QCOMPARE(object->pointFProperty(), QPointF((float)-10.1, (float)12.3));

    QCOMPARE(object->sizeProperty(), QSize(99, 13));

    QCOMPARE(object->sizeFProperty(), QSizeF((float)0.1, (float)0.2));

    QCOMPARE(object->rectProperty(), QRect(9, 7, 100, 200));

    QCOMPARE(object->rectFProperty(), QRectF((float)1000.1, (float)-10.9, (float)400, (float)90.99));

    QCOMPARE(object->boolProperty(), true);

    QCOMPARE(object->variantProperty(), QVariant("Hello World!"));

    QCOMPARE(object->vectorProperty(), QVector3D(10, 1, 2.2));

    QCOMPARE(object->urlProperty(), component.url().resolved(QUrl("main.qml")));

    QVERIFY(object->objectProperty() != 0);

    MyTypeObject *child = qobject_cast<MyTypeObject *>(object->objectProperty());

    QVERIFY(child != 0);

    QCOMPARE(child->intProperty(), 8);

}

// Test edge case type assignments

void tst_qdeclarativelanguage::assignTypeExtremes()

{

    QDeclarativeComponent component(&engine, TEST_FILE("assignTypeExtremes.qml"));

    VERIFY_ERRORS(0);

    MyTypeObject *object = qobject_cast<MyTypeObject *>(component.create());

    QVERIFY(object != 0);

    QCOMPARE(object->uintProperty(), 0xEE6B2800);

    QCOMPARE(object->intProperty(), -0x77359400);

}

// Test that a composite type can assign to a property of its base type

void tst_qdeclarativelanguage::assignCompositeToType()

{

    QDeclarativeComponent component(&engine, TEST_FILE("assignCompositeToType.qml"));

    VERIFY_ERRORS(0);

    QObject *object = component.create();

    QVERIFY(object != 0);

}

// Test that literals are stored correctly in variant properties

void tst_qdeclarativelanguage::assignLiteralToVariant()

{

    QDeclarativeComponent component(&engine, TEST_FILE("assignLiteralToVariant.qml"));

    VERIFY_ERRORS(0);

    QObject *object = component.create();

    QVERIFY(object != 0);