1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 #include <qtest.h>

    42 #include <QtDeclarative/qdeclarativecomponent.h>

    43 #include <QtDeclarative/qdeclarativeengine.h>

    44 #include <QtDeclarative/qdeclarativeexpression.h>

    45 #include <QtDeclarative/qdeclarativecontext.h>

    46 #include <QtCore/qfileinfo.h>

    47 #include <QtCore/qdebug.h>

    48 #include <QtDeclarative/private/qdeclarativeguard_p.h>

    49 #include <QtCore/qdir.h>

    50 #include <QtCore/qnumeric.h>

    51 #include <private/qdeclarativeengine_p.h>

    52 #include <private/qdeclarativeglobalscriptclass_p.h>

    53 #include "testtypes.h"

    54 #include "testhttpserver.h"

    55 

    56 /*

    57 This test covers evaluation of ECMAScript expressions and bindings from within

    58 QML.  This does not include static QML language issues.

    59 

    60 Static QML language issues are covered in qmllanguage

    61 */

    62 inline QUrl TEST_FILE(const QString &filename)

    63 {

    64     QFileInfo fileInfo(__FILE__);

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

    66 }

    67 

    68 inline QUrl TEST_FILE(const char *filename)

    69 {

    70     return TEST_FILE(QLatin1String(filename));

    71 }

    72 

    73 class tst_qdeclarativeecmascript : public QObject

    74 {

    75     Q_OBJECT

    76 public:

    77     tst_qdeclarativeecmascript() {}

    78 

    79 private slots:

    80     void initTestCase();

    81     void assignBasicTypes();

    82     void idShortcutInvalidates();

    83     void boolPropertiesEvaluateAsBool();

    84     void methods();

    85     void signalAssignment();

    86     void bindingLoop();

    87     void basicExpressions();

    88     void basicExpressions_data();

    89     void arrayExpressions();

    90     void contextPropertiesTriggerReeval();

    91     void objectPropertiesTriggerReeval();

    92     void deferredProperties();

    93     void deferredPropertiesErrors();

    94     void extensionObjects();

    95     void overrideExtensionProperties();

    96     void attachedProperties();

    97     void enums();

    98     void valueTypeFunctions();

    99     void constantsOverrideBindings();

   100     void outerBindingOverridesInnerBinding();

   101     void aliasPropertyAndBinding();

   102     void nonExistantAttachedObject();

   103     void scope();

   104     void signalParameterTypes();

   105     void objectsCompareAsEqual();

   106     void dynamicCreation_data();

   107     void dynamicCreation();

   108     void dynamicDestruction();

   109     void objectToString();

   110     void selfDeletingBinding();

   111     void extendedObjectPropertyLookup();

   112     void scriptErrors();

   113     void functionErrors();

   114     void propertyAssignmentErrors();

   115     void signalTriggeredBindings();

   116     void listProperties();

   117     void exceptionClearsOnReeval();

   118     void exceptionSlotProducesWarning();

   119     void exceptionBindingProducesWarning();

   120     void transientErrors();

   121     void shutdownErrors();

   122     void compositePropertyType();

   123     void jsObject();

   124     void undefinedResetsProperty();

   125     void listToVariant();

   126     void multiEngineObject();

   127     void deletedObject();

   128     void attachedPropertyScope();

   129     void scriptConnect();

   130     void scriptDisconnect();

   131     void ownership();

   132     void qlistqobjectMethods();

   133     void strictlyEquals();

   134     void compiled();

   135     void numberAssignment();

   136 

   137     void bug1();

   138     void bug2();

   139     void dynamicCreationCrash();

   140     void regExpBug();

   141     void nullObjectBinding();

   142     void deletedEngine();

   143     void libraryScriptAssert();

   144     void variantsAssignedUndefined();

   145     void qtbug_9792();

   146     void qtcreatorbug_1289();

   147     void noSpuriousWarningsAtShutdown();

   148     void canAssignNullToQObject();

   149     void functionAssignment();

   150     void eval();

   151     void function();

   152     void qtbug_10696();

   153 

   154     void include();

   155 

   156     void callQtInvokables();

   157 private:

   158     QDeclarativeEngine engine;

   159 };

   160 

   161 void tst_qdeclarativeecmascript::initTestCase() { registerTypes(); }

   162 

   163 void tst_qdeclarativeecmascript::assignBasicTypes()

   164 {

   165     {

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

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

   168     QVERIFY(object != 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   191     delete object;

   192     }

   193     {

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

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

   196     QVERIFY(object != 0);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   219     delete object;

   220     }

   221 }

   222 

   223 void tst_qdeclarativeecmascript::idShortcutInvalidates()

   224 {

   225     {

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

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

   228         QVERIFY(object != 0);

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

   230         delete object->objectProperty();

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

   232     }

   233 

   234     {

   235         QDeclarativeComponent component(&engine, TEST_FILE("idShortcutInvalidates.1.qml"));

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

   237         QVERIFY(object != 0);

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

   239         delete object->objectProperty();

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

   241     }

   242 }

   243 

   244 void tst_qdeclarativeecmascript::boolPropertiesEvaluateAsBool()

   245 {

   246     {

   247         QDeclarativeComponent component(&engine, TEST_FILE("boolPropertiesEvaluateAsBool.1.qml"));

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

   249         QVERIFY(object != 0);

   250         QCOMPARE(object->stringProperty(), QLatin1String("pass"));

   251     }

   252     {

   253         QDeclarativeComponent component(&engine, TEST_FILE("boolPropertiesEvaluateAsBool.2.qml"));

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

   255         QVERIFY(object != 0);

   256         QCOMPARE(object->stringProperty(), QLatin1String("pass"));

   257     }

   258 }

   259 

   260 void tst_qdeclarativeecmascript::signalAssignment()

   261 {

   262     {

   263         QDeclarativeComponent component(&engine, TEST_FILE("signalAssignment.1.qml"));

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

   265         QVERIFY(object != 0);

   266         QCOMPARE(object->string(), QString());

   267         emit object->basicSignal();

   268         QCOMPARE(object->string(), QString("pass"));

   269     }

   270 

   271     {

   272         QDeclarativeComponent component(&engine, TEST_FILE("signalAssignment.2.qml"));

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

   274         QVERIFY(object != 0);

   275         QCOMPARE(object->string(), QString());

   276         emit object->argumentSignal(19, "Hello world!", 10.3);

   277         QCOMPARE(object->string(), QString("pass 19 Hello world! 10.3"));

   278     }

   279 }

   280 

   281 void tst_qdeclarativeecmascript::methods()

   282 {

   283     {

   284         QDeclarativeComponent component(&engine, TEST_FILE("methods.1.qml"));

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

   286         QVERIFY(object != 0);

   287         QCOMPARE(object->methodCalled(), false);

   288         QCOMPARE(object->methodIntCalled(), false);

   289         emit object->basicSignal();

   290         QCOMPARE(object->methodCalled(), true);

   291         QCOMPARE(object->methodIntCalled(), false);

   292     }

   293 

   294     {

   295         QDeclarativeComponent component(&engine, TEST_FILE("methods.2.qml"));

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

   297         QVERIFY(object != 0);

   298         QCOMPARE(object->methodCalled(), false);

   299         QCOMPARE(object->methodIntCalled(), false);

   300         emit object->basicSignal();

   301         QCOMPARE(object->methodCalled(), false);

   302         QCOMPARE(object->methodIntCalled(), true);

   303     }

   304 

   305     {

   306         QDeclarativeComponent component(&engine, TEST_FILE("methods.3.qml"));

   307         QObject *object = component.create();

   308         QVERIFY(object != 0);

   309         QCOMPARE(object->property("test").toInt(), 19);

   310     }

   311 

   312     {

   313         QDeclarativeComponent component(&engine, TEST_FILE("methods.4.qml"));

   314         QObject *object = component.create();

   315         QVERIFY(object != 0);

   316         QCOMPARE(object->property("test").toInt(), 19);

   317         QCOMPARE(object->property("test2").toInt(), 17);

   318         QCOMPARE(object->property("test3").toInt(), 16);

   319     }

   320 

   321     {

   322         QDeclarativeComponent component(&engine, TEST_FILE("methods.5.qml"));

   323         QObject *object = component.create();

   324         QVERIFY(object != 0);

   325         QCOMPARE(object->property("test").toInt(), 9);

   326     }

   327 }

   328 

   329 void tst_qdeclarativeecmascript::bindingLoop()

   330 {

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

   332     QString warning = component.url().toString() + ":9:9: QML MyQmlObject: Binding loop detected for property \"stringProperty\"";

   333     QTest::ignoreMessage(QtWarningMsg, warning.toLatin1().constData());

   334     QObject *object = component.create();

   335     QVERIFY(object != 0);

   336 }

   337 

   338 void tst_qdeclarativeecmascript::basicExpressions_data()

   339 {

   340     QTest::addColumn<QString>("expression");

   341     QTest::addColumn<QVariant>("result");

   342     QTest::addColumn<bool>("nest");

   343 

   344     QTest::newRow("Syntax error (self test)") << "{console.log({'a':1'}.a)}" << QVariant() << false;

   345     QTest::newRow("Context property") << "a" << QVariant(1944) << false;

   346     QTest::newRow("Context property") << "a" << QVariant(1944) << true;

   347     QTest::newRow("Context property expression") << "a * 2" << QVariant(3888) << false;

   348     QTest::newRow("Context property expression") << "a * 2" << QVariant(3888) << true;

   349     QTest::newRow("Overridden context property") << "b" << QVariant("Milk") << false;

   350     QTest::newRow("Overridden context property") << "b" << QVariant("Cow") << true;

   351     QTest::newRow("Object property") << "object.stringProperty" << QVariant("Object1") << false;

   352     QTest::newRow("Object property") << "object.stringProperty" << QVariant("Object1") << true;

   353     QTest::newRow("Overridden object property") << "objectOverride.stringProperty" << QVariant("Object2") << false;

   354     QTest::newRow("Overridden object property") << "objectOverride.stringProperty" << QVariant("Object3") << true;

   355     QTest::newRow("Default object property") << "horseLegs" << QVariant(4) << false;

   356     QTest::newRow("Default object property") << "antLegs" << QVariant(6) << false;

   357     QTest::newRow("Default object property") << "emuLegs" << QVariant(2) << false;

   358     QTest::newRow("Nested default object property") << "horseLegs" << QVariant(4) << true;

   359     QTest::newRow("Nested default object property") << "antLegs" << QVariant(7) << true;

   360     QTest::newRow("Nested default object property") << "emuLegs" << QVariant(2) << true;

   361     QTest::newRow("Nested default object property") << "humanLegs" << QVariant(2) << true;

   362     QTest::newRow("Context property override default object property") << "millipedeLegs" << QVariant(100) << true;

   363 }

   364 

   365 void tst_qdeclarativeecmascript::basicExpressions()

   366 {

   367     QFETCH(QString, expression);

   368     QFETCH(QVariant, result);

   369     QFETCH(bool, nest);

   370 

   371     MyQmlObject object1;

   372     MyQmlObject object2;

   373     MyQmlObject object3;

   374     MyDefaultObject1 default1;

   375     MyDefaultObject3 default3;

   376     object1.setStringProperty("Object1");

   377     object2.setStringProperty("Object2");

   378     object3.setStringProperty("Object3");

   379 

   380     QDeclarativeContext context(engine.rootContext());

   381     QDeclarativeContext nestedContext(&context);

   382 

   383     context.setContextObject(&default1);

   384     context.setContextProperty("a", QVariant(1944));

   385     context.setContextProperty("b", QVariant("Milk"));

   386     context.setContextProperty("object", &object1);

   387     context.setContextProperty("objectOverride", &object2);

   388     nestedContext.setContextObject(&default3);

   389     nestedContext.setContextProperty("b", QVariant("Cow"));

   390     nestedContext.setContextProperty("objectOverride", &object3);

   391     nestedContext.setContextProperty("millipedeLegs", QVariant(100));

   392 

   393     MyExpression expr(nest?&nestedContext:&context, expression);

   394     QCOMPARE(expr.evaluate(), result);

   395 }

   396 

   397 void tst_qdeclarativeecmascript::arrayExpressions()

   398 {

   399     QObject obj1;

   400     QObject obj2;

   401     QObject obj3;

   402 

   403     QDeclarativeContext context(engine.rootContext());

   404     context.setContextProperty("a", &obj1);

   405     context.setContextProperty("b", &obj2);

   406     context.setContextProperty("c", &obj3);

   407 

   408     MyExpression expr(&context, "[a, b, c, 10]");

   409     QVariant result = expr.evaluate();

   410     QCOMPARE(result.userType(), qMetaTypeId<QList<QObject *> >());

   411     QList<QObject *> list = qvariant_cast<QList<QObject *> >(result);

   412     QCOMPARE(list.count(), 4);

   413     QCOMPARE(list.at(0), &obj1);

   414     QCOMPARE(list.at(1), &obj2);

   415     QCOMPARE(list.at(2), &obj3);

   416     QCOMPARE(list.at(3), (QObject *)0);

   417 }

   418 

   419 // Tests that modifying a context property will reevaluate expressions

   420 void tst_qdeclarativeecmascript::contextPropertiesTriggerReeval()

   421 {

   422     QDeclarativeContext context(engine.rootContext());

   423     MyQmlObject object1;

   424     MyQmlObject object2;

   425     MyQmlObject *object3 = new MyQmlObject;

   426 

   427     object1.setStringProperty("Hello");

   428     object2.setStringProperty("World");

   429 

   430     context.setContextProperty("testProp", QVariant(1));

   431     context.setContextProperty("testObj", &object1);

   432     context.setContextProperty("testObj2", object3);

   433 

   434     { 

   435         MyExpression expr(&context, "testProp + 1");

   436         QCOMPARE(expr.changed, false);

   437         QCOMPARE(expr.evaluate(), QVariant(2));

   438 

   439         context.setContextProperty("testProp", QVariant(2));

   440         QCOMPARE(expr.changed, true);

   441         QCOMPARE(expr.evaluate(), QVariant(3));

   442     }

   443 

   444     { 

   445         MyExpression expr(&context, "testProp + testProp + testProp");

   446         QCOMPARE(expr.changed, false);

   447         QCOMPARE(expr.evaluate(), QVariant(6));

   448 

   449         context.setContextProperty("testProp", QVariant(4));

   450         QCOMPARE(expr.changed, true);

   451         QCOMPARE(expr.evaluate(), QVariant(12));

   452     }

   453 

   454     { 

   455         MyExpression expr(&context, "testObj.stringProperty");

   456         QCOMPARE(expr.changed, false);

   457         QCOMPARE(expr.evaluate(), QVariant("Hello"));

   458 

   459         context.setContextProperty("testObj", &object2);

   460         QCOMPARE(expr.changed, true);

   461         QCOMPARE(expr.evaluate(), QVariant("World"));

   462     }

   463 

   464     { 

   465         MyExpression expr(&context, "testObj.stringProperty /**/");

   466         QCOMPARE(expr.changed, false);

   467         QCOMPARE(expr.evaluate(), QVariant("World"));

   468 

   469         context.setContextProperty("testObj", &object1);

   470         QCOMPARE(expr.changed, true);

   471         QCOMPARE(expr.evaluate(), QVariant("Hello"));

   472     }

   473 

   474     { 

   475         MyExpression expr(&context, "testObj2");

   476         QCOMPARE(expr.changed, false);

   477         QCOMPARE(expr.evaluate(), QVariant::fromValue((QObject *)object3));

   478     }

   479 

   480 }

   481 

   482 void tst_qdeclarativeecmascript::objectPropertiesTriggerReeval()

   483 {

   484     QDeclarativeContext context(engine.rootContext());

   485     MyQmlObject object1;

   486     MyQmlObject object2;

   487     MyQmlObject object3;

   488     context.setContextProperty("testObj", &object1);

   489 

   490     object1.setStringProperty(QLatin1String("Hello"));

   491     object2.setStringProperty(QLatin1String("Dog"));

   492     object3.setStringProperty(QLatin1String("Cat"));

   493 

   494     { 

   495         MyExpression expr(&context, "testObj.stringProperty");

   496         QCOMPARE(expr.changed, false);

   497         QCOMPARE(expr.evaluate(), QVariant("Hello"));

   498 

   499         object1.setStringProperty(QLatin1String("World"));

   500         QCOMPARE(expr.changed, true);

   501         QCOMPARE(expr.evaluate(), QVariant("World"));

   502     }

   503 

   504     { 

   505         MyExpression expr(&context, "testObj.objectProperty.stringProperty");

   506         QCOMPARE(expr.changed, false);

   507         QCOMPARE(expr.evaluate(), QVariant());

   508 

   509         object1.setObjectProperty(&object2);

   510         QCOMPARE(expr.changed, true);

   511         expr.changed = false;

   512         QCOMPARE(expr.evaluate(), QVariant("Dog"));

   513 

   514         object1.setObjectProperty(&object3);

   515         QCOMPARE(expr.changed, true);

   516         expr.changed = false;

   517         QCOMPARE(expr.evaluate(), QVariant("Cat"));

   518 

   519         object1.setObjectProperty(0);

   520         QCOMPARE(expr.changed, true);

   521         expr.changed = false;

   522         QCOMPARE(expr.evaluate(), QVariant());

   523 

   524         object1.setObjectProperty(&object3);

   525         QCOMPARE(expr.changed, true);

   526         expr.changed = false;

   527         QCOMPARE(expr.evaluate(), QVariant("Cat"));

   528 

   529         object3.setStringProperty("Donkey");

   530         QCOMPARE(expr.changed, true);

   531         expr.changed = false;

   532         QCOMPARE(expr.evaluate(), QVariant("Donkey"));

   533     }

   534 }

   535 

   536 void tst_qdeclarativeecmascript::deferredProperties()

   537 {

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

   539     MyDeferredObject *object = 

   540         qobject_cast<MyDeferredObject *>(component.create());

   541     QVERIFY(object != 0);

   542     QCOMPARE(object->value(), 0);

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

   544     QVERIFY(object->objectProperty2() != 0);

   545     qmlExecuteDeferred(object);

   546     QCOMPARE(object->value(), 10);

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

   548     MyQmlObject *qmlObject = 

   549         qobject_cast<MyQmlObject *>(object->objectProperty());

   550     QVERIFY(qmlObject != 0);

   551     QCOMPARE(qmlObject->value(), 10);

   552     object->setValue(19);

   553     QCOMPARE(qmlObject->value(), 19);

   554 }

   555 

   556 // Check errors on deferred properties are correctly emitted

   557 void tst_qdeclarativeecmascript::deferredPropertiesErrors()

   558 {

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

   560     MyDeferredObject *object = 

   561         qobject_cast<MyDeferredObject *>(component.create());

   562     QVERIFY(object != 0);

   563     QCOMPARE(object->value(), 0);

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

   565     QVERIFY(object->objectProperty2() == 0);

   566 

   567     QString warning = component.url().toString() + ":6: Unable to assign [undefined] to QObject* objectProperty";

   568     QTest::ignoreMessage(QtWarningMsg, qPrintable(warning));

   569 

   570     qmlExecuteDeferred(object);

   571 

   572     delete object;

   573 }

   574 

   575 void tst_qdeclarativeecmascript::extensionObjects()

   576 {

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

   578     MyExtendedObject *object = 

   579         qobject_cast<MyExtendedObject *>(component.create());

   580     QVERIFY(object != 0);

   581     QCOMPARE(object->baseProperty(), 13);

   582     QCOMPARE(object->coreProperty(), 9);

   583     object->setProperty("extendedProperty", QVariant(11));

   584     object->setProperty("baseExtendedProperty", QVariant(92));

   585     QCOMPARE(object->coreProperty(), 11);

   586     QCOMPARE(object->baseProperty(), 92);

   587 

   588     MyExtendedObject *nested = qobject_cast<MyExtendedObject*>(qvariant_cast<QObject *>(object->property("nested")));

   589     QVERIFY(nested);

   590     QCOMPARE(nested->baseProperty(), 13);

   591     QCOMPARE(nested->coreProperty(), 9);

   592     nested->setProperty("extendedProperty", QVariant(11));

   593     nested->setProperty("baseExtendedProperty", QVariant(92));

   594     QCOMPARE(nested->coreProperty(), 11);

   595     QCOMPARE(nested->baseProperty(), 92);

   596 

   597 }

   598 

   599 void tst_qdeclarativeecmascript::overrideExtensionProperties()

   600 {

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

   602     OverrideDefaultPropertyObject *object =

   603         qobject_cast<OverrideDefaultPropertyObject *>(component.create());

   604     QVERIFY(object != 0);

   605     QVERIFY(object->secondProperty() != 0);

   606     QVERIFY(object->firstProperty() == 0);

   607 }

   608 

   609 void tst_qdeclarativeecmascript::attachedProperties()

   610 {

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

   612     QObject *object = component.create();

   613     QVERIFY(object != 0);

   614     QCOMPARE(object->property("a").toInt(), 19);

   615     QCOMPARE(object->property("b").toInt(), 19);

   616     QCOMPARE(object->property("c").toInt(), 19);

   617     QCOMPARE(object->property("d").toInt(), 19);

   618 

   619     // ### Need to test attached property assignment

   620 }

   621 

   622 void tst_qdeclarativeecmascript::enums()

   623 {

   624     // Existant enums

   625     {

   626     QDeclarativeComponent component(&engine, TEST_FILE("enums.1.qml"));

   627     QObject *object = component.create();

   628     QVERIFY(object != 0);

   629 

   630     QCOMPARE(object->property("a").toInt(), 0);

   631     QCOMPARE(object->property("b").toInt(), 1);

   632     QCOMPARE(object->property("c").toInt(), 2);

   633     QCOMPARE(object->property("d").toInt(), 3);

   634     QCOMPARE(object->property("e").toInt(), 0);

   635     QCOMPARE(object->property("f").toInt(), 1);

   636     QCOMPARE(object->property("g").toInt(), 2);

   637     QCOMPARE(object->property("h").toInt(), 3);

   638     QCOMPARE(object->property("i").toInt(), 19);

   639     QCOMPARE(object->property("j").toInt(), 19);

   640     }

   641     // Non-existent enums

   642     {

   643     QDeclarativeComponent component(&engine, TEST_FILE("enums.2.qml"));

   644 

   645     QString warning1 = component.url().toString() + ":5: Unable to assign [undefined] to int a";

   646     QString warning2 = component.url().toString() + ":6: Unable to assign [undefined] to int b";

   647     QTest::ignoreMessage(QtWarningMsg, qPrintable(warning1));

   648     QTest::ignoreMessage(QtWarningMsg, qPrintable(warning2));

   649 

   650     QObject *object = component.create();

   651     QVERIFY(object != 0);

   652     QCOMPARE(object->property("a").toInt(), 0);

   653     QCOMPARE(object->property("b").toInt(), 0);

   654     }

   655 }

   656 

   657 void tst_qdeclarativeecmascript::valueTypeFunctions()

   658 {

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

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

   661     QVERIFY(obj != 0);

   662     QCOMPARE(obj->rectProperty(), QRect(0,0,100,100));

   663     QCOMPARE(obj->rectFProperty(), QRectF(0,0.5,100,99.5));

   664 }

   665 

   666 /* 

   667 Tests that writing a constant to a property with a binding on it disables the

   668 binding.

   669 */

   670 void tst_qdeclarativeecmascript::constantsOverrideBindings()

   671 {

   672     // From ECMAScript

   673     {

   674         QDeclarativeComponent component(&engine, TEST_FILE("constantsOverrideBindings.1.qml"));

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

   676         QVERIFY(object != 0);

   677 

   678         QCOMPARE(object->property("c2").toInt(), 0);

   679         object->setProperty("c1", QVariant(9));

   680         QCOMPARE(object->property("c2").toInt(), 9);

   681 

   682         emit object->basicSignal();

   683 

   684         QCOMPARE(object->property("c2").toInt(), 13);

   685         object->setProperty("c1", QVariant(8));

   686         QCOMPARE(object->property("c2").toInt(), 13);

   687     }

   688 

   689     // During construction

   690     {

   691         QDeclarativeComponent component(&engine, TEST_FILE("constantsOverrideBindings.2.qml"));

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

   693         QVERIFY(object != 0);

   694 

   695         QCOMPARE(object->property("c1").toInt(), 0);

   696         QCOMPARE(object->property("c2").toInt(), 10);

   697         object->setProperty("c1", QVariant(9));

   698         QCOMPARE(object->property("c1").toInt(), 9);

   699         QCOMPARE(object->property("c2").toInt(), 10);

   700     }

   701 

   702 #if 0

   703     // From C++

   704     {

   705         QDeclarativeComponent component(&engine, TEST_FILE("constantsOverrideBindings.3.qml"));

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

   707         QVERIFY(object != 0);

   708 

   709         QCOMPARE(object->property("c2").toInt(), 0);

   710         object->setProperty("c1", QVariant(9));

   711         QCOMPARE(object->property("c2").toInt(), 9);

   712 

   713         object->setProperty("c2", QVariant(13));

   714         QCOMPARE(object->property("c2").toInt(), 13);

   715         object->setProperty("c1", QVariant(7));

   716         QCOMPARE(object->property("c1").toInt(), 7);

   717         QCOMPARE(object->property("c2").toInt(), 13);

   718     }

   719 #endif

   720 }

   721 

   722 /*

   723 Tests that assigning a binding to a property that already has a binding causes

   724 the original binding to be disabled.

   725 */

   726 void tst_qdeclarativeecmascript::outerBindingOverridesInnerBinding()

   727 {

   728     QDeclarativeComponent component(&engine, 

   729                            TEST_FILE("outerBindingOverridesInnerBinding.qml"));

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

   731     QVERIFY(object != 0);

   732 

   733     QCOMPARE(object->property("c1").toInt(), 0);

   734     QCOMPARE(object->property("c2").toInt(), 0);

   735     QCOMPARE(object->property("c3").toInt(), 0);

   736 

   737     object->setProperty("c1", QVariant(9));

   738     QCOMPARE(object->property("c1").toInt(), 9);

   739     QCOMPARE(object->property("c2").toInt(), 0);

   740     QCOMPARE(object->property("c3").toInt(), 0);

   741 

   742     object->setProperty("c3", QVariant(8));

   743     QCOMPARE(object->property("c1").toInt(), 9);

   744     QCOMPARE(object->property("c2").toInt(), 8);

   745     QCOMPARE(object->property("c3").toInt(), 8);

   746 }

   747 

   748 /*

   749 Access a non-existent attached object.  

   750 

   751 Tests for a regression where this used to crash.

   752 */

   753 void tst_qdeclarativeecmascript::nonExistantAttachedObject()

   754 {

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

   756 

   757     QString warning = component.url().toString() + ":4: Unable to assign [undefined] to QString stringProperty";

   758     QTest::ignoreMessage(QtWarningMsg, qPrintable(warning));

   759 

   760     QObject *object = component.create();

   761     QVERIFY(object != 0);

   762 }

   763 

   764 void tst_qdeclarativeecmascript::scope()

   765 {

   766     {

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

   768         QObject *object = component.create();

   769         QVERIFY(object != 0);

   770 

   771         QCOMPARE(object->property("test1").toInt(), 1);

   772         QCOMPARE(object->property("test2").toInt(), 2);

   773         QCOMPARE(object->property("test3").toString(), QString("1Test"));

   774         QCOMPARE(object->property("test4").toString(), QString("2Test"));

   775         QCOMPARE(object->property("test5").toInt(), 1);

   776         QCOMPARE(object->property("test6").toInt(), 1);

   777         QCOMPARE(object->property("test7").toInt(), 2);

   778         QCOMPARE(object->property("test8").toInt(), 2);

   779         QCOMPARE(object->property("test9").toInt(), 1);

   780         QCOMPARE(object->property("test10").toInt(), 3);

   781     }

   782 

   783     {

   784         QDeclarativeComponent component(&engine, TEST_FILE("scope.2.qml"));

   785         QObject *object = component.create();

   786         QVERIFY(object != 0);

   787 

   788         QCOMPARE(object->property("test1").toInt(), 19);

   789         QCOMPARE(object->property("test2").toInt(), 19);

   790         QCOMPARE(object->property("test3").toInt(), 11);

   791         QCOMPARE(object->property("test4").toInt(), 11);

   792         QCOMPARE(object->property("test5").toInt(), 24);

   793         QCOMPARE(object->property("test6").toInt(), 24);

   794     }

   795 

   796     {

   797         QDeclarativeComponent component(&engine, TEST_FILE("scope.3.qml"));

   798         QObject *object = component.create();

   799         QVERIFY(object != 0);

   800 

   801         QCOMPARE(object->property("test1").toBool(), true);

   802         QCOMPARE(object->property("test2").toBool(), true);

   803         QCOMPARE(object->property("test3").toBool(), true);

   804     }

   805 

   806     // Signal argument scope

   807     {

   808         QDeclarativeComponent component(&engine, TEST_FILE("scope.4.qml"));

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

   810         QVERIFY(object != 0);

   811 

   812         QCOMPARE(object->property("test").toInt(), 0);

   813         QCOMPARE(object->property("test2").toString(), QString());

   814 

   815         emit object->argumentSignal(13, "Argument Scope", 9);

   816 

   817         QCOMPARE(object->property("test").toInt(), 13);

   818         QCOMPARE(object->property("test2").toString(), QString("Argument Scope"));

   819 

   820         delete object;

   821     }

   822 }

   823 

   824 /*

   825 Tests that "any" type passes through a synthesized signal parameter.  This

   826 is essentially a test of QDeclarativeMetaType::copy()

   827 */

   828 void tst_qdeclarativeecmascript::signalParameterTypes()

   829 {

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

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

   832     QVERIFY(object != 0);

   833 

   834     emit object->basicSignal();

   835 

   836     QCOMPARE(object->property("intProperty").toInt(), 10);

   837     QCOMPARE(object->property("realProperty").toReal(), 19.2);

   838     QVERIFY(object->property("colorProperty").value<QColor>() == QColor(255, 255, 0, 255));

   839     QVERIFY(object->property("variantProperty") == QVariant::fromValue(QColor(255, 0, 255, 255)));

   840 }

   841 

   842 /*

   843 Test that two JS objects for the same QObject compare as equal.

   844 */

   845 void tst_qdeclarativeecmascript::objectsCompareAsEqual()

   846 {

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

   848     QObject *object = component.create();

   849     QVERIFY(object != 0);

   850 

   851     QCOMPARE(object->property("test1").toBool(), true);

   852     QCOMPARE(object->property("test2").toBool(), true);

   853     QCOMPARE(object->property("test3").toBool(), true);

   854     QCOMPARE(object->property("test4").toBool(), true);

   855     QCOMPARE(object->property("test5").toBool(), true);

   856 }

   857 

   858 /*

   859 Confirm bindings and alias properties can coexist.

   860 

   861 Tests for a regression where the binding would not reevaluate.

   862 */

   863 void tst_qdeclarativeecmascript::aliasPropertyAndBinding()

   864 {

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

   866     QObject *object = component.create();

   867     QVERIFY(object != 0);

   868 

   869     QCOMPARE(object->property("c2").toInt(), 3);

   870     QCOMPARE(object->property("c3").toInt(), 3);

   871 

   872     object->setProperty("c2", QVariant(19));

   873 

   874     QCOMPARE(object->property("c2").toInt(), 19);

   875     QCOMPARE(object->property("c3").toInt(), 19);

   876 }

   877 

   878 void tst_qdeclarativeecmascript::dynamicCreation_data()

   879 {

   880     QTest::addColumn<QString>("method");

   881     QTest::addColumn<QString>("createdName");

   882 

   883     QTest::newRow("One") << "createOne" << "objectOne";

   884     QTest::newRow("Two") << "createTwo" << "objectTwo";

   885     QTest::newRow("Three") << "createThree" << "objectThree";

   886 }

   887 

   888 /*

   889 Test using createQmlObject to dynamically generate an item

   890 Also using createComponent is tested.

   891 */

   892 void tst_qdeclarativeecmascript::dynamicCreation()

   893 {

   894     QFETCH(QString, method);

   895     QFETCH(QString, createdName);

   896 

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

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

   899     QVERIFY(object != 0);

   900 

   901     QMetaObject::invokeMethod(object, method.toUtf8());

   902     QObject *created = object->objectProperty();

   903     QVERIFY(created);

   904     QCOMPARE(created->objectName(), createdName);

   905 }

   906 

   907 /*

   908    Tests the destroy function

   909 */

   910 void tst_qdeclarativeecmascript::dynamicDestruction()

   911 {

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

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

   914     QVERIFY(object != 0);

   915     QDeclarativeGuard<QObject> createdQmlObject = 0;

   916 

   917     QMetaObject::invokeMethod(object, "create");

   918     createdQmlObject = object->objectProperty();

   919     QVERIFY(createdQmlObject);

   920     QCOMPARE(createdQmlObject->objectName(), QString("emptyObject"));

   921 

   922     QMetaObject::invokeMethod(object, "killOther");

   923     QVERIFY(createdQmlObject);

   924     QCoreApplication::instance()->processEvents(QEventLoop::DeferredDeletion);

   925     QVERIFY(createdQmlObject);

   926     for (int ii = 0; createdQmlObject && ii < 50; ++ii) { // After 5 seconds we should give up

   927         if (createdQmlObject) {

   928             QTest::qWait(100);

   929             QCoreApplication::instance()->processEvents(QEventLoop::DeferredDeletion);

   930         }

   931     }

   932     QVERIFY(!createdQmlObject);

   933 

   934     QDeclarativeEngine::setObjectOwnership(object, QDeclarativeEngine::JavaScriptOwnership);

   935     QMetaObject::invokeMethod(object, "killMe");

   936     QVERIFY(object);

   937     QTest::qWait(0);

   938     QCoreApplication::instance()->processEvents(QEventLoop::DeferredDeletion);

   939     QVERIFY(!object);

   940 }

   941 

   942 /*

   943    tests that id.toString() works

   944 */

   945 void tst_qdeclarativeecmascript::objectToString()

   946 {

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

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

   949     QVERIFY(object != 0);

   950     QMetaObject::invokeMethod(object, "testToString");

   951     QVERIFY(object->stringProperty().startsWith("MyQmlObject_QML_"));

   952     QVERIFY(object->stringProperty().endsWith(", \"objName\")"));

   953 }

   954 

   955 /*

   956 Tests bindings that indirectly cause their own deletion work.

   957 

   958 This test is best run under valgrind to ensure no invalid memory access occur.

   959 */

   960 void tst_qdeclarativeecmascript::selfDeletingBinding()

   961 {

   962     {

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

   964         QObject *object = component.create();

   965         QVERIFY(object != 0);

   966         object->setProperty("triggerDelete", true);

   967     }

   968 

   969     {

   970         QDeclarativeComponent component(&engine, TEST_FILE("selfDeletingBinding.2.qml"));

   971         QObject *object = component.create();

   972         QVERIFY(object != 0);

   973         object->setProperty("triggerDelete", true);

   974     }

   975 }

   976 

   977 /*

   978 Test that extended object properties can be accessed.

   979 

   980 This test a regression where this used to crash.  The issue was specificially

   981 for extended objects that did not include a synthesized meta object (so non-root

   982 and no synthesiszed properties).

   983 */

   984 void tst_qdeclarativeecmascript::extendedObjectPropertyLookup()

   985 {

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

   987     QObject *object = component.create();

   988     QVERIFY(object != 0);

   989 }

   990 

   991 /*

   992 Test file/lineNumbers for binding/Script errors.

   993 */

   994 void tst_qdeclarativeecmascript::scriptErrors()

   995 {

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

   997     QString url = component.url().toString();

   998 

   999     QString warning1 = url.left(url.length() - 3) + "js:2: Error: Invalid write to global property \"a\"";

  1000     QString warning2 = url + ":5: TypeError: Result of expression 'a' [undefined] is not an object.";

  1001     QString warning3 = url.left(url.length() - 3) + "js:4: Error: Invalid write to global property \"a\"";

  1002     QString warning4 = url + ":10: TypeError: Result of expression 'a' [undefined] is not an object.";

  1003     QString warning5 = url + ":8: TypeError: Result of expression 'a' [undefined] is not an object.";

  1004     QString warning6 = url + ":7: Unable to assign [undefined] to int x";

  1005     QString warning7 = url + ":12: Error: Cannot assign to read-only property \"trueProperty\"";

  1006     QString warning8 = url + ":13: Error: Cannot assign to non-existent property \"fakeProperty\"";

  1007 

  1008     QTest::ignoreMessage(QtWarningMsg, warning1.toLatin1().constData());

  1009     QTest::ignoreMessage(QtWarningMsg, warning2.toLatin1().constData());

  1010     QTest::ignoreMessage(QtWarningMsg, warning3.toLatin1().constData());

  1011     QTest::ignoreMessage(QtWarningMsg, warning5.toLatin1().constData());

  1012     QTest::ignoreMessage(QtWarningMsg, warning6.toLatin1().constData());

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

  1014     QVERIFY(object != 0);

  1015 

  1016     QTest::ignoreMessage(QtWarningMsg, warning4.toLatin1().constData());

  1017     emit object->basicSignal();

  1018 

  1019     QTest::ignoreMessage(QtWarningMsg, warning7.toLatin1().constData());

  1020     emit object->anotherBasicSignal();

  1021 

  1022     QTest::ignoreMessage(QtWarningMsg, warning8.toLatin1().constData());

  1023     emit object->thirdBasicSignal();

  1024 }

  1025 

  1026 /*

  1027 Test file/lineNumbers for inline functions.

  1028 */

  1029 void tst_qdeclarativeecmascript::functionErrors()

  1030 {

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

  1032     QString url = component.url().toString();

  1033 

  1034     QString warning = url + ":5: Error: Invalid write to global property \"a\"";

  1035 

  1036     QTest::ignoreMessage(QtWarningMsg, warning.toLatin1().constData());

  1037 

  1038     QObject *object = component.create();

  1039     QVERIFY(object != 0);

  1040     delete object;

  1041 }

  1042 

  1043 /*

  1044 Test various errors that can occur when assigning a property from script

  1045 */

  1046 void tst_qdeclarativeecmascript::propertyAssignmentErrors()

  1047 {

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

  1049 

  1050     QString url = component.url().toString();

  1051 

  1052     QString warning1 = url + ":11:Error: Cannot assign [undefined] to int";

  1053     QString warning2 = url + ":17:Error: Cannot assign QString to int";

  1054 

  1055     QTest::ignoreMessage(QtDebugMsg, warning1.toLatin1().constData());

  1056     QTest::ignoreMessage(QtDebugMsg, warning2.toLatin1().constData());

  1057 

  1058     QObject *object = component.create();

  1059     QVERIFY(object != 0);

  1060 

  1061     delete object;

  1062 }

  1063     

  1064 /*

  1065 Test bindings still work when the reeval is triggered from within

  1066 a signal script.

  1067 */

  1068 void tst_qdeclarativeecmascript::signalTriggeredBindings()

  1069 {

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

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

  1072     QVERIFY(object != 0);

  1073 

  1074     QCOMPARE(object->property("base").toReal(), 50.);

  1075     QCOMPARE(object->property("test1").toReal(), 50.);

  1076     QCOMPARE(object->property("test2").toReal(), 50.);

  1077 

  1078     object->basicSignal();

  1079 

  1080     QCOMPARE(object->property("base").toReal(), 200.);

  1081     QCOMPARE(object->property("test1").toReal(), 200.);

  1082     QCOMPARE(object->property("test2").toReal(), 200.);

  1083 

  1084     object->argumentSignal(10, QString(), 10);

  1085 

  1086     QCOMPARE(object->property("base").toReal(), 400.);

  1087     QCOMPARE(object->property("test1").toReal(), 400.);

  1088     QCOMPARE(object->property("test2").toReal(), 400.);

  1089 }

  1090 

  1091 /*

  1092 Test that list properties can be iterated from ECMAScript

  1093 */

  1094 void tst_qdeclarativeecmascript::listProperties()

  1095 {

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

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

  1098     QVERIFY(object != 0);

  1099 

  1100     QCOMPARE(object->property("test1").toInt(), 21);

  1101     QCOMPARE(object->property("test2").toInt(), 2);

  1102     QCOMPARE(object->property("test3").toBool(), true);

  1103     QCOMPARE(object->property("test4").toBool(), true);

  1104 }

  1105 

  1106 void tst_qdeclarativeecmascript::exceptionClearsOnReeval()

  1107 {

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

  1109     QString url = component.url().toString();

  1110 

  1111     QString warning = url + ":4: TypeError: Result of expression 'objectProperty' [null] is not an object.";

  1112 

  1113     QTest::ignoreMessage(QtWarningMsg, warning.toLatin1().constData());

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

  1115     QVERIFY(object != 0);

  1116 

  1117     QCOMPARE(object->property("test").toBool(), false);

  1118 

  1119     MyQmlObject object2;

  1120     MyQmlObject object3;

  1121     object2.setObjectProperty(&object3);

  1122     object->setObjectProperty(&object2);

  1123 

  1124     QCOMPARE(object->property("test").toBool(), true);

  1125 }

  1126 

  1127 void tst_qdeclarativeecmascript::exceptionSlotProducesWarning()

  1128 {

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

  1130     QString url = component.url().toString();

  1131 

  1132     QString warning = component.url().toString() + ":6: Error: JS exception";

  1133 

  1134     QTest::ignoreMessage(QtWarningMsg, warning.toLatin1().constData());