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 

    42 

    43 #include <QtTest/QtTest>

    44 

    45 #include <qscriptengine.h>

    46 #include <qscriptengineagent.h>

    47 #include <qscriptprogram.h>

    48 #include <qscriptvalueiterator.h>

    49 #include <qgraphicsitem.h>

    50 #include <qstandarditemmodel.h>

    51 #include <QtCore/qnumeric.h>

    52 #include <stdlib.h>

    53 

    54 Q_DECLARE_METATYPE(QList<int>)

    55 Q_DECLARE_METATYPE(QObjectList)

    56 Q_DECLARE_METATYPE(QScriptProgram)

    57 

    58 //TESTED_CLASS=

    59 //TESTED_FILES=

    60 

    61 #if defined(Q_OS_SYMBIAN)

    62 # define STRINGIFY(x) #x

    63 # define TOSTRING(x) STRINGIFY(x)

    64 # define SRCDIR "C:/Private/" TOSTRING(SYMBIAN_SRCDIR_UID)

    65 #endif

    66 

    67 // The JavaScriptCore GC marks the C stack. To try to ensure that there is

    68 // no JSObject* left in stack memory by the compiler, we call this function

    69 // to zap some bytes of memory before calling collectGarbage().

    70 static void zapSomeStack()

    71 {

    72     char buf[4096];

    73     memset(buf, 0, sizeof(buf));

    74 }

    75 

    76 static void collectGarbage_helper(QScriptEngine &eng)

    77 {

    78     zapSomeStack();

    79     eng.collectGarbage();

    80 }

    81 

    82 class tst_QScriptEngine : public QObject

    83 {

    84     Q_OBJECT

    85 

    86 public:

    87     tst_QScriptEngine();

    88     virtual ~tst_QScriptEngine();

    89 

    90 private slots:

    91     void constructWithParent();

    92     void currentContext();

    93     void pushPopContext();

    94     void getSetDefaultPrototype();

    95     void newFunction();

    96     void newObject();

    97     void newArray();

    98     void newVariant();

    99     void newRegExp();

   100     void newDate();

   101     void newQObject();

   102     void newQMetaObject();

   103     void newActivationObject();

   104     void getSetGlobalObject();

   105     void globalObjectProperties();

   106     void globalObjectGetterSetterProperty();

   107     void builtinFunctionNames_data();

   108     void builtinFunctionNames();

   109     void checkSyntax_data();

   110     void checkSyntax();

   111     void canEvaluate_data();

   112     void canEvaluate();

   113     void evaluate_data();

   114     void evaluate();

   115     void nestedEvaluate();

   116     void uncaughtException();

   117     void errorMessage_QT679();

   118     void valueConversion();

   119     void importExtension();

   120     void infiniteRecursion();

   121     void castWithPrototypeChain();

   122     void castWithMultipleInheritance();

   123     void collectGarbage();

   124     void gcWithNestedDataStructure();

   125     void processEventsWhileRunning();

   126     void throwErrorFromProcessEvents();

   127     void stacktrace();

   128     void numberParsing_data();

   129     void numberParsing();

   130     void automaticSemicolonInsertion();

   131     void abortEvaluation();

   132     void isEvaluating();

   133     void printFunctionWithCustomHandler();

   134     void printThrowsException();

   135     void errorConstructors();

   136     void argumentsProperty();

   137     void numberClass();

   138     void forInStatement();

   139     void functionExpression();

   140     void stringObjects();

   141     void getterSetterThisObject();

   142     void continueInSwitch();

   143     void readOnlyPrototypeProperty();

   144     void toObject();

   145     void reservedWords_data();

   146     void reservedWords();

   147     void futureReservedWords_data();

   148     void futureReservedWords();

   149     void throwInsideWithStatement();

   150     void getSetAgent();

   151     void reentrancy();

   152     void incDecNonObjectProperty();

   153     void installTranslatorFunctions_data();

   154     void installTranslatorFunctions();

   155     void functionScopes();

   156     void nativeFunctionScopes();

   157     void evaluateProgram();

   158     void collectGarbageAfterConnect();

   159 

   160     void qRegExpInport_data();

   161     void qRegExpInport();

   162 };

   163 

   164 tst_QScriptEngine::tst_QScriptEngine()

   165 {

   166 }

   167 

   168 tst_QScriptEngine::~tst_QScriptEngine()

   169 {

   170 }

   171 

   172 void tst_QScriptEngine::constructWithParent()

   173 {

   174     QPointer<QScriptEngine> ptr;

   175     {

   176         QObject obj;

   177         QScriptEngine *engine = new QScriptEngine(&obj);

   178         ptr = engine;

   179     }

   180     QVERIFY(ptr == 0);

   181 }

   182 

   183 void tst_QScriptEngine::currentContext()

   184 {

   185     QScriptEngine eng;

   186     QScriptContext *globalCtx = eng.currentContext();

   187     QVERIFY(globalCtx != 0);

   188     QVERIFY(globalCtx->parentContext() == 0);

   189     QCOMPARE(globalCtx->engine(), &eng);

   190     QCOMPARE(globalCtx->argumentCount(), 0);

   191     QCOMPARE(globalCtx->backtrace().size(), 1);

   192     QVERIFY(!globalCtx->isCalledAsConstructor());

   193     QVERIFY(!globalCtx->callee().isValid());

   194     QCOMPARE(globalCtx->state(), QScriptContext::NormalState);

   195     QVERIFY(globalCtx->thisObject().strictlyEquals(eng.globalObject()));

   196     QVERIFY(globalCtx->activationObject().strictlyEquals(eng.globalObject()));

   197     QVERIFY(globalCtx->argumentsObject().isObject());

   198 }

   199 

   200 void tst_QScriptEngine::pushPopContext()

   201 {

   202     QScriptEngine eng;

   203     QScriptContext *globalCtx = eng.currentContext();

   204     QScriptContext *ctx = eng.pushContext();

   205     QVERIFY(ctx != 0);

   206     QCOMPARE(ctx->parentContext(), globalCtx);

   207     QVERIFY(!ctx->isCalledAsConstructor());

   208     QVERIFY(!ctx->callee().isValid());

   209     QVERIFY(ctx->thisObject().strictlyEquals(eng.globalObject()));

   210     QCOMPARE(ctx->argumentCount(), 0);

   211     QCOMPARE(ctx->backtrace().size(), 2);

   212     QCOMPARE(ctx->engine(), &eng);

   213     QCOMPARE(ctx->state(), QScriptContext::NormalState);

   214     QVERIFY(ctx->activationObject().isObject());

   215     QVERIFY(ctx->argumentsObject().isObject());

   216 

   217     QScriptContext *ctx2 = eng.pushContext();

   218     QVERIFY(ctx2 != 0);

   219     QCOMPARE(ctx2->parentContext(), ctx);

   220     QVERIFY(!ctx2->activationObject().strictlyEquals(ctx->activationObject()));

   221     QVERIFY(!ctx2->argumentsObject().strictlyEquals(ctx->argumentsObject()));

   222 

   223     eng.popContext();

   224     eng.popContext();

   225     QTest::ignoreMessage(QtWarningMsg, "QScriptEngine::popContext() doesn't match with pushContext()");

   226     eng.popContext(); // ignored

   227     QTest::ignoreMessage(QtWarningMsg, "QScriptEngine::popContext() doesn't match with pushContext()");

   228     eng.popContext(); // ignored

   229 }

   230 

   231 static QScriptValue myFunction(QScriptContext *, QScriptEngine *eng)

   232 {

   233     return eng->nullValue();

   234 }

   235 

   236 static QScriptValue myFunctionWithVoidArg(QScriptContext *, QScriptEngine *eng, void *)

   237 {

   238     return eng->nullValue();

   239 }

   240 

   241 static QScriptValue myThrowingFunction(QScriptContext *ctx, QScriptEngine *)

   242 {

   243     return ctx->throwError("foo");

   244 }

   245 

   246 void tst_QScriptEngine::newFunction()

   247 {

   248     QScriptEngine eng;

   249     {

   250         QScriptValue fun = eng.newFunction(myFunction);

   251         QCOMPARE(fun.isValid(), true);

   252         QCOMPARE(fun.isFunction(), true);

   253         QCOMPARE(fun.isObject(), true);

   254         QCOMPARE(fun.scriptClass(), (QScriptClass*)0);

   255         // a prototype property is automatically constructed

   256         {

   257             QScriptValue prot = fun.property("prototype", QScriptValue::ResolveLocal);

   258             QVERIFY(prot.isObject());

   259             QVERIFY(prot.property("constructor").strictlyEquals(fun));

   260             QCOMPARE(fun.propertyFlags("prototype"), QScriptValue::Undeletable);

   261             QCOMPARE(prot.propertyFlags("constructor"), QScriptValue::Undeletable | QScriptValue::SkipInEnumeration);

   262         }

   263         // prototype should be Function.prototype

   264         QCOMPARE(fun.prototype().isValid(), true);

   265         QCOMPARE(fun.prototype().isFunction(), true);

   266         QCOMPARE(fun.prototype().strictlyEquals(eng.evaluate("Function.prototype")), true);

   267 

   268         QCOMPARE(fun.call().isNull(), true);

   269         QCOMPARE(fun.construct().isObject(), true);

   270     }

   271 

   272     // the overload that takes a void*

   273     {

   274         QScriptValue fun = eng.newFunction(myFunctionWithVoidArg, (void*)this);

   275         QVERIFY(fun.isFunction());

   276         QCOMPARE(fun.scriptClass(), (QScriptClass*)0);

   277         // a prototype property is automatically constructed

   278         {

   279             QScriptValue prot = fun.property("prototype", QScriptValue::ResolveLocal);

   280             QVERIFY(prot.isObject());

   281             QVERIFY(prot.property("constructor").strictlyEquals(fun));

   282             QCOMPARE(fun.propertyFlags("prototype"), QScriptValue::Undeletable);

   283             QCOMPARE(prot.propertyFlags("constructor"), QScriptValue::Undeletable | QScriptValue::SkipInEnumeration);

   284         }

   285         // prototype should be Function.prototype

   286         QCOMPARE(fun.prototype().isValid(), true);

   287         QCOMPARE(fun.prototype().isFunction(), true);

   288         QCOMPARE(fun.prototype().strictlyEquals(eng.evaluate("Function.prototype")), true);

   289 

   290         QCOMPARE(fun.call().isNull(), true);

   291         QCOMPARE(fun.construct().isObject(), true);

   292     }

   293 

   294     // the overload that takes a prototype

   295     {

   296         QScriptValue proto = eng.newObject();

   297         QScriptValue fun = eng.newFunction(myFunction, proto);

   298         QCOMPARE(fun.isValid(), true);

   299         QCOMPARE(fun.isFunction(), true);

   300         QCOMPARE(fun.isObject(), true);

   301         // internal prototype should be Function.prototype

   302         QCOMPARE(fun.prototype().isValid(), true);

   303         QCOMPARE(fun.prototype().isFunction(), true);

   304         QCOMPARE(fun.prototype().strictlyEquals(eng.evaluate("Function.prototype")), true);

   305         // public prototype should be the one we passed

   306         QCOMPARE(fun.property("prototype").strictlyEquals(proto), true);

   307         QCOMPARE(fun.propertyFlags("prototype"), QScriptValue::Undeletable);

   308         QCOMPARE(proto.property("constructor").strictlyEquals(fun), true);

   309         QCOMPARE(proto.propertyFlags("constructor"),

   310                  QScriptValue::Undeletable | QScriptValue::SkipInEnumeration);

   311 

   312         QCOMPARE(fun.call().isNull(), true);

   313         QCOMPARE(fun.construct().isObject(), true);

   314     }

   315 }

   316 

   317 void tst_QScriptEngine::newObject()

   318 {

   319     QScriptEngine eng;

   320     QScriptValue object = eng.newObject();

   321     QCOMPARE(object.isValid(), true);

   322     QCOMPARE(object.isObject(), true);

   323     QCOMPARE(object.isFunction(), false);

   324     QCOMPARE(object.scriptClass(), (QScriptClass*)0);

   325     // prototype should be Object.prototype

   326     QCOMPARE(object.prototype().isValid(), true);

   327     QCOMPARE(object.prototype().isObject(), true);

   328     QCOMPARE(object.prototype().strictlyEquals(eng.evaluate("Object.prototype")), true);

   329 }

   330 

   331 void tst_QScriptEngine::newArray()

   332 {

   333     QScriptEngine eng;

   334     QScriptValue array = eng.newArray();

   335     QCOMPARE(array.isValid(), true);

   336     QCOMPARE(array.isArray(), true);

   337     QCOMPARE(array.isObject(), true);

   338     QVERIFY(!array.isFunction());

   339     QCOMPARE(array.scriptClass(), (QScriptClass*)0);

   340     // prototype should be Array.prototype

   341     QCOMPARE(array.prototype().isValid(), true);

   342     QCOMPARE(array.prototype().isArray(), true);

   343     QCOMPARE(array.prototype().strictlyEquals(eng.evaluate("Array.prototype")), true);

   344 

   345     // task 218092

   346     {

   347         QScriptValue ret = eng.evaluate("[].splice(0, 0, 'a')");

   348         QVERIFY(ret.isArray());

   349         QCOMPARE(ret.property("length").toInt32(), 0);

   350     }

   351     {

   352         QScriptValue ret = eng.evaluate("['a'].splice(0, 1, 'b')");

   353         QVERIFY(ret.isArray());

   354         QCOMPARE(ret.property("length").toInt32(), 1);

   355     }

   356     {

   357         QScriptValue ret = eng.evaluate("['a', 'b'].splice(0, 1, 'c')");

   358         QVERIFY(ret.isArray());

   359         QCOMPARE(ret.property("length").toInt32(), 1);

   360     }

   361     {

   362         QScriptValue ret = eng.evaluate("['a', 'b', 'c'].splice(0, 2, 'd')");

   363         QVERIFY(ret.isArray());

   364         QCOMPARE(ret.property("length").toInt32(), 2);

   365     }

   366     {

   367         QScriptValue ret = eng.evaluate("['a', 'b', 'c'].splice(1, 2, 'd', 'e', 'f')");

   368         QVERIFY(ret.isArray());

   369         QCOMPARE(ret.property("length").toInt32(), 2);

   370     }

   371 

   372     // task 233836

   373     {

   374         QScriptValue ret = eng.evaluate("a = new Array(4294967295); a.push('foo')");

   375         QVERIFY(ret.isNumber());

   376         QCOMPARE(ret.toInt32(), 0);

   377         QCOMPARE(eng.evaluate("a[4294967295]").toString(), QString::fromLatin1("foo"));

   378     }

   379     {

   380         QScriptValue ret = eng.newArray(0xFFFFFFFF);

   381         QCOMPARE(ret.property("length").toUInt32(), uint(0xFFFFFFFF));

   382         ret.setProperty(0xFFFFFFFF, 123);

   383         QCOMPARE(ret.property("length").toUInt32(), uint(0xFFFFFFFF));

   384         QVERIFY(ret.property(0xFFFFFFFF).isNumber());

   385         QCOMPARE(ret.property(0xFFFFFFFF).toInt32(), 123);

   386         ret.setProperty(123, 456);

   387         QCOMPARE(ret.property("length").toUInt32(), uint(0xFFFFFFFF));

   388         QVERIFY(ret.property(123).isNumber());

   389         QCOMPARE(ret.property(123).toInt32(), 456);

   390     }

   391 }

   392 

   393 void tst_QScriptEngine::newVariant()

   394 {

   395     QScriptEngine eng;

   396     {

   397         QScriptValue opaque = eng.newVariant(QVariant());

   398         QCOMPARE(opaque.isValid(), true);

   399         QCOMPARE(opaque.isVariant(), true);

   400         QVERIFY(!opaque.isFunction());

   401         QCOMPARE(opaque.isObject(), true);

   402         QCOMPARE(opaque.prototype().isValid(), true);

   403         QCOMPARE(opaque.prototype().isVariant(), true);

   404         QVERIFY(opaque.property("valueOf").call(opaque).isUndefined());

   405     }

   406     // default prototype should be set automatically

   407     {

   408         QScriptValue proto = eng.newObject();

   409         eng.setDefaultPrototype(qMetaTypeId<QString>(), proto);

   410         QScriptValue ret = eng.newVariant(QVariant(QString::fromLatin1("hello")));

   411         QVERIFY(ret.isVariant());

   412         QCOMPARE(ret.scriptClass(), (QScriptClass*)0);

   413         QVERIFY(ret.prototype().strictlyEquals(proto));

   414         eng.setDefaultPrototype(qMetaTypeId<QString>(), QScriptValue());

   415         QScriptValue ret2 = eng.newVariant(QVariant(QString::fromLatin1("hello")));

   416         QVERIFY(ret2.isVariant());

   417         QVERIFY(!ret2.prototype().strictlyEquals(proto));

   418     }

   419     // "promote" plain object to variant

   420     {

   421         QScriptValue object = eng.newObject();

   422         object.setProperty("foo", eng.newObject());

   423         object.setProperty("bar", object.property("foo"));

   424         QVERIFY(object.property("foo").isObject());

   425         QVERIFY(!object.property("foo").isVariant());

   426         QScriptValue originalProto = object.property("foo").prototype();

   427         QScriptValue ret = eng.newVariant(object.property("foo"), QVariant(123));

   428         QVERIFY(ret.isValid());

   429         QVERIFY(ret.strictlyEquals(object.property("foo")));

   430         QVERIFY(ret.isVariant());

   431         QVERIFY(object.property("foo").isVariant());

   432         QVERIFY(object.property("bar").isVariant());

   433         QCOMPARE(ret.toVariant(), QVariant(123));

   434         QVERIFY(ret.prototype().strictlyEquals(originalProto));

   435     }

   436     // replace value of existing object

   437     {

   438         QScriptValue object = eng.newVariant(QVariant(123));

   439         QScriptValue ret = eng.newVariant(object, QVariant(456));

   440         QVERIFY(ret.isValid());

   441         QVERIFY(ret.strictlyEquals(object));

   442         QVERIFY(ret.isVariant());

   443         QCOMPARE(ret.toVariant(), QVariant(456));

   444     }

   445 

   446     // valueOf() and toString()

   447     {

   448         QScriptValue object = eng.newVariant(QVariant(123));

   449         QScriptValue value = object.property("valueOf").call(object);

   450         QVERIFY(value.isNumber());

   451         QCOMPARE(value.toInt32(), 123);

   452         QCOMPARE(object.toString(), QString::fromLatin1("123"));

   453         QCOMPARE(object.toVariant().toString(), object.toString());

   454     }

   455     {

   456         QScriptValue object = eng.newVariant(QVariant(QString::fromLatin1("hello")));

   457         QScriptValue value = object.property("valueOf").call(object);

   458         QVERIFY(value.isString());

   459         QCOMPARE(value.toString(), QString::fromLatin1("hello"));

   460         QCOMPARE(object.toString(), QString::fromLatin1("hello"));

   461         QCOMPARE(object.toVariant().toString(), object.toString());

   462     }

   463     {

   464         QScriptValue object = eng.newVariant(QVariant(false));

   465         QScriptValue value = object.property("valueOf").call(object);

   466         QVERIFY(value.isBoolean());

   467         QCOMPARE(value.toBoolean(), false);

   468         QCOMPARE(object.toString(), QString::fromLatin1("false"));

   469         QCOMPARE(object.toVariant().toString(), object.toString());

   470     }

   471     {

   472         QScriptValue object = eng.newVariant(QVariant(QPoint(10, 20)));

   473         QScriptValue value = object.property("valueOf").call(object);

   474         QVERIFY(value.isObject());

   475         QVERIFY(value.strictlyEquals(object));

   476         QCOMPARE(object.toString(), QString::fromLatin1("QVariant(QPoint)"));

   477     }

   478 }

   479 

   480 void tst_QScriptEngine::newRegExp()

   481 {

   482     QScriptEngine eng;

   483     for (int x = 0; x < 2; ++x) {

   484         QScriptValue rexp;

   485         if (x == 0)

   486             rexp = eng.newRegExp("foo", "bar");

   487         else

   488             rexp = eng.newRegExp(QRegExp("foo"));

   489         QCOMPARE(rexp.isValid(), true);

   490         QCOMPARE(rexp.isRegExp(), true);

   491         QCOMPARE(rexp.isObject(), true);

   492         QVERIFY(rexp.isFunction()); // in JSC, RegExp objects are callable

   493         // prototype should be RegExp.prototype

   494         QCOMPARE(rexp.prototype().isValid(), true);

   495         QCOMPARE(rexp.prototype().isObject(), true);

   496         QCOMPARE(rexp.prototype().isRegExp(), false);

   497         QCOMPARE(rexp.prototype().strictlyEquals(eng.evaluate("RegExp.prototype")), true);

   498 

   499         QCOMPARE(rexp.toRegExp().pattern(), QRegExp("foo").pattern());

   500     }

   501     {

   502         QScriptValue r = eng.evaluate("/foo/gim");

   503         QVERIFY(r.isRegExp());

   504         QCOMPARE(r.toString(), QString::fromLatin1("/foo/gim"));

   505 

   506         QScriptValue rxCtor = eng.globalObject().property("RegExp");

   507         QScriptValue r2 = rxCtor.call(QScriptValue(), QScriptValueList() << r);

   508         QVERIFY(r2.isRegExp());

   509         QVERIFY(r2.strictlyEquals(r));

   510 

   511         QScriptValue r3 = rxCtor.call(QScriptValue(), QScriptValueList() << r << "gim");

   512         QVERIFY(r3.isError());

   513         QCOMPARE(r3.toString(), QString::fromLatin1("TypeError: Cannot supply flags when constructing one RegExp from another."));

   514 

   515         QScriptValue r4 = rxCtor.call(QScriptValue(), QScriptValueList() << "foo" << "gim");

   516         QVERIFY(r4.isRegExp());

   517 

   518         QScriptValue r5 = rxCtor.construct(QScriptValueList() << r);

   519         QVERIFY(r5.isRegExp());

   520         QCOMPARE(r5.toString(), QString::fromLatin1("/foo/gim"));

   521         // In JSC, constructing a RegExp from another produces the same identical object.

   522         // This is different from SpiderMonkey and old back-end.

   523         QVERIFY(r5.strictlyEquals(r));

   524 

   525         QScriptValue r6 = rxCtor.construct(QScriptValueList() << "foo" << "bar");

   526         QVERIFY(r6.isError());

   527         QCOMPARE(r6.toString(), QString::fromLatin1("SyntaxError: Invalid regular expression: invalid regular expression flag"));

   528 

   529         QScriptValue r7 = eng.evaluate("/foo/gimp");

   530         QVERIFY(r7.isError());

   531         QCOMPARE(r7.toString(), QString::fromLatin1("SyntaxError: Invalid regular expression: invalid regular expression flag"));

   532 

   533         QScriptValue r8 = eng.evaluate("/foo/migmigmig");

   534         QVERIFY(r8.isRegExp());

   535         QCOMPARE(r8.toString(), QString::fromLatin1("/foo/gim"));

   536 

   537         QScriptValue r9 = rxCtor.construct();

   538         QVERIFY(r9.isRegExp());

   539         QCOMPARE(r9.toString(), QString::fromLatin1("/(?:)/"));

   540 

   541         QScriptValue r10 = rxCtor.construct(QScriptValueList() << "" << "gim");

   542         QVERIFY(r10.isRegExp());

   543         QCOMPARE(r10.toString(), QString::fromLatin1("/(?:)/gim"));

   544 

   545         QScriptValue r11 = rxCtor.construct(QScriptValueList() << "{1.*}" << "g");

   546         QVERIFY(r11.isRegExp());

   547         QCOMPARE(r11.toString(), QString::fromLatin1("/{1.*}/g"));

   548     }

   549 }

   550 

   551 void tst_QScriptEngine::newDate()

   552 {

   553     QScriptEngine eng;

   554 

   555     {

   556         QScriptValue date = eng.newDate(0);

   557         QCOMPARE(date.isValid(), true);

   558         QCOMPARE(date.isDate(), true);

   559         QCOMPARE(date.isObject(), true);

   560         QVERIFY(!date.isFunction());

   561         // prototype should be Date.prototype

   562         QCOMPARE(date.prototype().isValid(), true);

   563         QCOMPARE(date.prototype().isDate(), true);

   564         QCOMPARE(date.prototype().strictlyEquals(eng.evaluate("Date.prototype")), true);

   565     }

   566 

   567     {

   568         QDateTime dt = QDateTime(QDate(1, 2, 3), QTime(4, 5, 6, 7), Qt::LocalTime);

   569         QScriptValue date = eng.newDate(dt);

   570         QCOMPARE(date.isValid(), true);

   571         QCOMPARE(date.isDate(), true);

   572         QCOMPARE(date.isObject(), true);

   573         // prototype should be Date.prototype

   574         QCOMPARE(date.prototype().isValid(), true);

   575         QCOMPARE(date.prototype().isDate(), true);

   576         QCOMPARE(date.prototype().strictlyEquals(eng.evaluate("Date.prototype")), true);

   577 

   578         QCOMPARE(date.toDateTime(), dt);

   579     }

   580 

   581     {

   582         QDateTime dt = QDateTime(QDate(1, 2, 3), QTime(4, 5, 6, 7), Qt::UTC);

   583         QScriptValue date = eng.newDate(dt);

   584         // toDateTime() result should be in local time

   585         QCOMPARE(date.toDateTime(), dt.toLocalTime());

   586     }

   587 

   588     // Date.parse() should return NaN when it fails

   589     {

   590         QScriptValue ret = eng.evaluate("Date.parse()");

   591         QVERIFY(ret.isNumber());

   592         QVERIFY(qIsNaN(ret.toNumber()));

   593     }

   594 

   595     // Date.parse() should be able to parse the output of Date().toString()

   596 #ifndef Q_WS_WIN // TODO: Test and remove this since 169701 has been fixed

   597     {

   598         QScriptValue ret = eng.evaluate("var x = new Date(); var s = x.toString(); s == new Date(Date.parse(s)).toString()");

   599         QVERIFY(ret.isBoolean());

   600         QCOMPARE(ret.toBoolean(), true);

   601     }

   602 #endif

   603 }

   604 

   605 void tst_QScriptEngine::newQObject()

   606 {

   607     QScriptEngine eng;

   608 

   609     {

   610         QScriptValue qobject = eng.newQObject(0);

   611         QCOMPARE(qobject.isValid(), true);

   612         QCOMPARE(qobject.isNull(), true);

   613         QCOMPARE(qobject.isObject(), false);

   614         QCOMPARE(qobject.toQObject(), (QObject *)0);

   615     }

   616     {

   617         QScriptValue qobject = eng.newQObject(this);

   618         QCOMPARE(qobject.isValid(), true);

   619         QCOMPARE(qobject.isQObject(), true);

   620         QCOMPARE(qobject.isObject(), true);

   621         QCOMPARE(qobject.toQObject(), (QObject *)this);

   622         QVERIFY(!qobject.isFunction());

   623         // prototype should be QObject.prototype

   624         QCOMPARE(qobject.prototype().isValid(), true);

   625         QCOMPARE(qobject.prototype().isQObject(), true);

   626         QCOMPARE(qobject.scriptClass(), (QScriptClass*)0);

   627     }

   628 

   629     // test ownership

   630     {

   631         QPointer<QObject> ptr = new QObject();

   632         QVERIFY(ptr != 0);

   633         {

   634             QScriptValue v = eng.newQObject(ptr, QScriptEngine::ScriptOwnership);

   635         }

   636         eng.evaluate("gc()");

   637         if (ptr)

   638             QEXPECT_FAIL("", "In the JSC-based back-end, script-owned QObjects are not always deleted immediately during GC", Continue);

   639         QVERIFY(ptr == 0);

   640     }

   641     {

   642         QPointer<QObject> ptr = new QObject();

   643         QVERIFY(ptr != 0);

   644         {

   645             QScriptValue v = eng.newQObject(ptr, QScriptEngine::QtOwnership);

   646         }

   647         QObject *before = ptr;

   648         eng.evaluate("gc()");

   649         QVERIFY(ptr == before);

   650         delete ptr;

   651     }

   652     {

   653         QObject *parent = new QObject();

   654         QObject *child = new QObject(parent);

   655         QScriptValue v = eng.newQObject(child, QScriptEngine::QtOwnership);

   656         QCOMPARE(v.toQObject(), child);

   657         delete parent;

   658         QCOMPARE(v.toQObject(), (QObject *)0);

   659     }

   660     {

   661         QPointer<QObject> ptr = new QObject();

   662         QVERIFY(ptr != 0);

   663         {

   664             QScriptValue v = eng.newQObject(ptr, QScriptEngine::AutoOwnership);

   665         }

   666         eng.evaluate("gc()");

   667         // no parent, so it should be like ScriptOwnership

   668         if (ptr)

   669             QEXPECT_FAIL("", "In the JSC-based back-end, script-owned QObjects are not always deleted immediately during GC", Continue);

   670         QVERIFY(ptr == 0);

   671     }

   672     {

   673         QObject *parent = new QObject();

   674         QPointer<QObject> child = new QObject(parent);

   675         QVERIFY(child != 0);

   676         {

   677             QScriptValue v = eng.newQObject(child, QScriptEngine::AutoOwnership);

   678         }

   679         eng.evaluate("gc()");

   680         // has parent, so it should be like QtOwnership

   681         QVERIFY(child != 0);

   682         delete parent;

   683     }

   684 

   685     // "promote" plain object to QObject

   686     {

   687         QScriptValue obj = eng.newObject();

   688         QScriptValue originalProto = obj.prototype();

   689         QScriptValue ret = eng.newQObject(obj, this);

   690         QVERIFY(ret.isValid());

   691         QVERIFY(ret.isQObject());

   692         QVERIFY(ret.strictlyEquals(obj));

   693         QVERIFY(obj.isQObject());

   694         QCOMPARE(ret.toQObject(), (QObject *)this);

   695         QVERIFY(ret.prototype().strictlyEquals(originalProto));

   696         QScriptValue val = ret.property("objectName");

   697         QVERIFY(val.isString());

   698     }

   699     // "promote" variant object to QObject

   700     {

   701         QScriptValue obj = eng.newVariant(123);

   702         QVERIFY(obj.isVariant());

   703         QScriptValue originalProto = obj.prototype();

   704         QScriptValue ret = eng.newQObject(obj, this);

   705         QVERIFY(ret.isQObject());

   706         QVERIFY(ret.strictlyEquals(obj));

   707         QVERIFY(obj.isQObject());

   708         QCOMPARE(ret.toQObject(), (QObject *)this);

   709         QVERIFY(ret.prototype().strictlyEquals(originalProto));

   710     }

   711     // replace QObject* of existing object

   712     {

   713         QScriptValue object = eng.newVariant(123);

   714         QScriptValue originalProto = object.prototype();

   715         QObject otherQObject;

   716         QScriptValue ret = eng.newQObject(object, &otherQObject);

   717         QVERIFY(ret.isValid());

   718         QVERIFY(ret.isQObject());

   719         QVERIFY(ret.strictlyEquals(object));

   720         QCOMPARE(ret.toQObject(), (QObject *)&otherQObject);

   721         QVERIFY(ret.prototype().strictlyEquals(originalProto));

   722     }

   723 

   724     // calling newQObject() several times with same object

   725     for (int x = 0; x < 2; ++x) {

   726         QObject qobj;

   727         // the default is to create a new wrapper object

   728         QScriptValue obj1 = eng.newQObject(&qobj);

   729         QScriptValue obj2 = eng.newQObject(&qobj);

   730         QVERIFY(!obj2.strictlyEquals(obj1));

   731 

   732         QScriptEngine::QObjectWrapOptions opt = 0;

   733         bool preferExisting = (x != 0);

   734         if (preferExisting)

   735             opt |= QScriptEngine::PreferExistingWrapperObject;

   736 

   737         QScriptValue obj3 = eng.newQObject(&qobj, QScriptEngine::AutoOwnership, opt);

   738         QVERIFY(!obj3.strictlyEquals(obj2));

   739         QScriptValue obj4 = eng.newQObject(&qobj, QScriptEngine::AutoOwnership, opt);

   740         QCOMPARE(obj4.strictlyEquals(obj3), preferExisting);

   741 

   742         QScriptValue obj5 = eng.newQObject(&qobj, QScriptEngine::ScriptOwnership, opt);

   743         QVERIFY(!obj5.strictlyEquals(obj4));

   744         QScriptValue obj6 = eng.newQObject(&qobj, QScriptEngine::ScriptOwnership, opt);

   745         QCOMPARE(obj6.strictlyEquals(obj5), preferExisting);

   746 

   747         QScriptValue obj7 = eng.newQObject(&qobj, QScriptEngine::ScriptOwnership,

   748                                            QScriptEngine::ExcludeSuperClassMethods | opt);

   749         QVERIFY(!obj7.strictlyEquals(obj6));

   750         QScriptValue obj8 = eng.newQObject(&qobj, QScriptEngine::ScriptOwnership,

   751                                            QScriptEngine::ExcludeSuperClassMethods | opt);

   752         QCOMPARE(obj8.strictlyEquals(obj7), preferExisting);

   753     }

   754 

   755     // newQObject() should set the default prototype, if one has been registered

   756     {

   757         QScriptValue oldQObjectProto = eng.defaultPrototype(qMetaTypeId<QObject*>());

   758 

   759         QScriptValue qobjectProto = eng.newObject();

   760         eng.setDefaultPrototype(qMetaTypeId<QObject*>(), qobjectProto);

   761         {

   762             QScriptValue ret = eng.newQObject(this);

   763             QVERIFY(ret.prototype().equals(qobjectProto));

   764         }

   765         QScriptValue tstProto = eng.newObject();

   766         int typeId = qRegisterMetaType<tst_QScriptEngine*>("tst_QScriptEngine*");

   767         eng.setDefaultPrototype(typeId, tstProto);

   768         {

   769             QScriptValue ret = eng.newQObject(this);

   770             QVERIFY(ret.prototype().equals(tstProto));

   771         }

   772 

   773         eng.setDefaultPrototype(qMetaTypeId<QObject*>(), oldQObjectProto);

   774         eng.setDefaultPrototype(typeId, QScriptValue());

   775     }

   776 }

   777 

   778 QT_BEGIN_NAMESPACE

   779 Q_SCRIPT_DECLARE_QMETAOBJECT(QObject, QObject*)

   780 Q_SCRIPT_DECLARE_QMETAOBJECT(QWidget, QWidget*)

   781 QT_END_NAMESPACE

   782 

   783 static QScriptValue myConstructor(QScriptContext *ctx, QScriptEngine *eng)

   784 {

   785     QScriptValue obj;

   786     if (ctx->isCalledAsConstructor()) {

   787         obj = ctx->thisObject();

   788     } else {

   789         obj = eng->newObject();

   790         obj.setPrototype(ctx->callee().property("prototype"));

   791     }

   792     obj.setProperty("isCalledAsConstructor", QScriptValue(eng, ctx->isCalledAsConstructor()));

   793     return obj;

   794 }

   795 

   796 void tst_QScriptEngine::newQMetaObject()

   797 {

   798     QScriptEngine eng;

   799 #if 0

   800     QScriptValue qclass = eng.newQMetaObject<QObject>();

   801     QScriptValue qclass2 = eng.newQMetaObject<QWidget>();

   802 #else

   803     QScriptValue qclass = qScriptValueFromQMetaObject<QObject>(&eng);

   804     QScriptValue qclass2 = qScriptValueFromQMetaObject<QWidget>(&eng);

   805 #endif

   806     QCOMPARE(qclass.isValid(), true);

   807     QCOMPARE(qclass.isQMetaObject(), true);

   808     QCOMPARE(qclass.toQMetaObject(), &QObject::staticMetaObject);

   809     QCOMPARE(qclass.isFunction(), true);

   810     QVERIFY(qclass.property("prototype").isObject());

   811 

   812     QCOMPARE(qclass2.isValid(), true);

   813     QCOMPARE(qclass2.isQMetaObject(), true);

   814     QCOMPARE(qclass2.toQMetaObject(), &QWidget::staticMetaObject);

   815     QCOMPARE(qclass2.isFunction(), true);

   816     QVERIFY(qclass2.property("prototype").isObject());

   817 

   818     // prototype should be QMetaObject.prototype

   819     QCOMPARE(qclass.prototype().isObject(), true);

   820     QCOMPARE(qclass2.prototype().isObject(), true);

   821 

   822     QScriptValue instance = qclass.construct();

   823     QCOMPARE(instance.isQObject(), true);

   824     QCOMPARE(instance.toQObject()->metaObject(), qclass.toQMetaObject());

   825     QVERIFY(instance.instanceOf(qclass));

   826 

   827     QScriptValue instance2 = qclass2.construct();

   828     QCOMPARE(instance2.isQObject(), true);

   829     QCOMPARE(instance2.toQObject()->metaObject(), qclass2.toQMetaObject());

   830     QVERIFY(instance2.instanceOf(qclass2));

   831 

   832     QScriptValueList args;

   833     args << instance;

   834     QScriptValue instance3 = qclass.construct(args);

   835     QCOMPARE(instance3.isQObject(), true);

   836     QCOMPARE(instance3.toQObject()->parent(), instance.toQObject());

   837     QVERIFY(instance3.instanceOf(qclass));

   838     args.clear();

   839 

   840     QPointer<QObject> qpointer1 = instance.toQObject();

   841     QPointer<QObject> qpointer2 = instance2.toQObject();

   842     QPointer<QObject> qpointer3 = instance3.toQObject();

   843 

   844     QVERIFY(qpointer1);

   845     QVERIFY(qpointer2);

   846     QVERIFY(qpointer3);

   847 

   848     // verify that AutoOwnership is in effect

   849     instance = QScriptValue();

   850     collectGarbage_helper(eng);

   851 

   852     QVERIFY(!qpointer1);

   853     QVERIFY(qpointer2);

   854     QVERIFY(!qpointer3); // was child of instance

   855 

   856     QVERIFY(instance.toQObject() == 0);

   857     QVERIFY(instance3.toQObject() == 0); // was child of instance

   858     QVERIFY(instance2.toQObject() != 0);

   859     instance2 = QScriptValue();

   860     collectGarbage_helper(eng);

   861     QVERIFY(instance2.toQObject() == 0);

   862 

   863     // with custom constructor

   864     QScriptValue ctor = eng.newFunction(myConstructor);

   865     QScriptValue qclass3 = eng.newQMetaObject(&QObject::staticMetaObject, ctor);

   866     QVERIFY(qclass3.property("prototype").equals(ctor.property("prototype")));

   867     {

   868         QScriptValue ret = qclass3.call();

   869         QVERIFY(ret.isObject());

   870         QVERIFY(ret.property("isCalledAsConstructor").isBoolean());

   871         QVERIFY(!ret.property("isCalledAsConstructor").toBoolean());

   872         QVERIFY(ret.instanceOf(qclass3));

   873     }

   874     {

   875         QScriptValue ret = qclass3.construct();

   876         QVERIFY(ret.isObject());

   877         QVERIFY(ret.property("isCalledAsConstructor").isBoolean());

   878         QVERIFY(ret.property("isCalledAsConstructor").toBoolean());

   879         QVERIFY(ret.instanceOf(qclass3));

   880     }

   881 

   882     // subclassing

   883     qclass2.setProperty("prototype", qclass.construct());

   884     QVERIFY(qclass2.construct().instanceOf(qclass));

   885 

   886     // with meta-constructor

   887     QScriptValue qclass4 = eng.newQMetaObject(&QObject::staticMetaObject);

   888     {

   889         QScriptValue inst = qclass4.construct();

   890         QVERIFY(inst.isQObject());

   891         QVERIFY(inst.toQObject() != 0);

   892         QCOMPARE(inst.toQObject()->parent(), (QObject*)0);

   893         QVERIFY(inst.instanceOf(qclass4));

   894     }

   895     {

   896         QScriptValue inst = qclass4.construct(QScriptValueList() << eng.newQObject(this));

   897         QVERIFY(inst.isQObject());

   898         QVERIFY(inst.toQObject() != 0);

   899         QCOMPARE(inst.toQObject()->parent(), (QObject*)this);

   900         QVERIFY(inst.instanceOf(qclass4));

   901     }

   902 }

   903 

   904 void tst_QScriptEngine::newActivationObject()

   905 {

   906     QSKIP("internal function not implemented in JSC-based back-end", SkipAll);

   907     QScriptEngine eng;

   908     QScriptValue act = eng.newActivationObject();

   909     QEXPECT_FAIL("", "", Continue);

   910     QCOMPARE(act.isValid(), true);

   911     QEXPECT_FAIL("", "", Continue);

   912     QCOMPARE(act.isObject(), true);

   913     QVERIFY(!act.isFunction());

   914     QScriptValue v(&eng, 123);

   915     act.setProperty("prop", v);

   916     QEXPECT_FAIL("", "", Continue);

   917     QCOMPARE(act.property("prop").strictlyEquals(v), true);

   918     QCOMPARE(act.scope().isValid(), false);

   919     QEXPECT_FAIL("", "", Continue);

   920     QVERIFY(act.prototype().isNull());

   921 }

   922 

   923 void tst_QScriptEngine::getSetGlobalObject()

   924 {

   925     QScriptEngine eng;

   926     QScriptValue glob = eng.globalObject();

   927     QCOMPARE(glob.isValid(), true);

   928     QCOMPARE(glob.isObject(), true);

   929     QVERIFY(!glob.isFunction());

   930     QVERIFY(eng.currentContext()->thisObject().strictlyEquals(glob));

   931     QVERIFY(eng.currentContext()->activationObject().strictlyEquals(glob));

   932     QCOMPARE(glob.toString(), QString::fromLatin1("[object global]"));

   933     // prototype should be Object.prototype

   934     QCOMPARE(glob.prototype().isValid(), true);

   935     QCOMPARE(glob.prototype().isObject(), true);

   936     QCOMPARE(glob.prototype().strictlyEquals(eng.evaluate("Object.prototype")), true);

   937 

   938     QScriptValue obj = eng.newObject();

   939     eng.setGlobalObject(obj);

   940     QVERIFY(eng.globalObject().strictlyEquals(obj));

   941     QVERIFY(eng.currentContext()->thisObject().strictlyEquals(obj));

   942     QVERIFY(eng.currentContext()->activationObject().strictlyEquals(obj));

   943     QVERIFY(eng.evaluate("this").strictlyEquals(obj));

   944     QCOMPARE(eng.globalObject().toString(), QString::fromLatin1("[object Object]"));

   945 

   946     glob = QScriptValue(); // kill reference to old global object

   947     collectGarbage_helper(eng);

   948     obj = eng.newObject();

   949     eng.setGlobalObject(obj);

   950     QVERIFY(eng.globalObject().strictlyEquals(obj));

   951     QVERIFY(eng.currentContext()->thisObject().strictlyEquals(obj));

   952     QVERIFY(eng.currentContext()->activationObject().strictlyEquals(obj));

   953 

   954     collectGarbage_helper(eng);

   955     QVERIFY(eng.globalObject().strictlyEquals(obj));

   956     QVERIFY(eng.currentContext()->thisObject().strictlyEquals(obj));

   957     QVERIFY(eng.currentContext()->activationObject().strictlyEquals(obj));

   958 

   959     QVERIFY(!obj.property("foo").isValid());

   960     eng.evaluate("var foo = 123");

   961     {

   962         QScriptValue ret = obj.property("foo");

   963         QVERIFY(ret.isNumber());

   964         QCOMPARE(ret.toInt32(), 123);

   965     }

   966 

   967     QVERIFY(!obj.property("bar").isValid());

   968     eng.evaluate("bar = 456");

   969     {

   970         QScriptValue ret = obj.property("bar");

   971         QVERIFY(ret.isNumber());

   972         QCOMPARE(ret.toInt32(), 456);

   973     }

   974 

   975     QVERIFY(!obj.property("baz").isValid());

   976     eng.evaluate("this['baz'] = 789");

   977     {

   978         QScriptValue ret = obj.property("baz");

   979         QVERIFY(ret.isNumber());

   980         QCOMPARE(ret.toInt32(), 789);

   981     }

   982 

   983     {

   984         QScriptValue ret = eng.evaluate("(function() { return this; })()");

   985         QVERIFY(ret.strictlyEquals(obj));

   986     }

   987 }

   988 

   989 static QScriptValue getSetFoo(QScriptContext *ctx, QScriptEngine *)

   990 {

   991     if (ctx->argumentCount() > 0)

   992         ctx->thisObject().setProperty("foo", ctx->argument(0));

   993     return ctx->thisObject().property("foo");

   994 }

   995 

   996 void tst_QScriptEngine::globalObjectProperties()

   997 {

   998     QScriptEngine eng;

   999     QScriptValue global = eng.globalObject();

  1000 

  1001     QVERIFY(global.property("NaN").isNumber());

  1002     QVERIFY(qIsNaN(global.property("NaN").toNumber()));

  1003     QCOMPARE(global.propertyFlags("NaN"), QScriptValue::SkipInEnumeration | QScriptValue::Undeletable);

  1004 

  1005     QVERIFY(global.property("Infinity").isNumber());

  1006     QVERIFY(qIsInf(global.property("Infinity").toNumber()));

  1007     QCOMPARE(global.propertyFlags("NaN"), QScriptValue::SkipInEnumeration | QScriptValue::Undeletable);

  1008 

  1009     QVERIFY(global.property("undefined").isUndefined());

  1010     QCOMPARE(global.propertyFlags("undefined"), QScriptValue::SkipInEnumeration | QScriptValue::Undeletable);

  1011 

  1012     QVERIFY(global.property("eval").isFunction());

  1013     QCOMPARE(global.propertyFlags("eval"), QScriptValue::SkipInEnumeration);

  1014 

  1015     QVERIFY(global.property("parseInt").isFunction());

  1016     QCOMPARE(global.propertyFlags("parseInt"), QScriptValue::SkipInEnumeration);

  1017 

  1018     QVERIFY(global.property("parseFloat").isFunction());

  1019     QCOMPARE(global.propertyFlags("parseFloat"), QScriptValue::SkipInEnumeration);

  1020 

  1021     QVERIFY(global.property("isNaN").isFunction());

  1022     QCOMPARE(global.propertyFlags("isNaN"), QScriptValue::SkipInEnumeration);

  1023 

  1024     QVERIFY(global.property("isFinite").isFunction());

  1025     QCOMPARE(global.propertyFlags("isFinite"), QScriptValue::SkipInEnumeration);

  1026 

  1027     QVERIFY(global.property("decodeURI").isFunction());

  1028     QCOMPARE(global.propertyFlags("decodeURI"), QScriptValue::SkipInEnumeration);

  1029 

  1030     QVERIFY(global.property("decodeURIComponent").isFunction());

  1031     QCOMPARE(global.propertyFlags("decodeURIComponent"), QScriptValue::SkipInEnumeration);

  1032 

  1033     QVERIFY(global.property("encodeURI").isFunction());

  1034     QCOMPARE(global.propertyFlags("encodeURI"), QScriptValue::SkipInEnumeration);

  1035 

  1036     QVERIFY(global.property("encodeURIComponent").isFunction());

  1037     QCOMPARE(global.propertyFlags("encodeURIComponent"), QScriptValue::SkipInEnumeration);

  1038 

  1039     QVERIFY(global.property("Object").isFunction());

  1040     QCOMPARE(global.propertyFlags("Object"), QScriptValue::SkipInEnumeration);

  1041     QVERIFY(global.property("Function").isFunction());

  1042     QCOMPARE(global.propertyFlags("Function"), QScriptValue::SkipInEnumeration);

  1043     QVERIFY(global.property("Array").isFunction());

  1044     QCOMPARE(global.propertyFlags("Array"), QScriptValue::SkipInEnumeration);

  1045     QVERIFY(global.property("String").isFunction());

  1046     QCOMPARE(global.propertyFlags("String"), QScriptValue::SkipInEnumeration);

  1047     QVERIFY(global.property("Boolean").isFunction());

  1048     QCOMPARE(global.propertyFlags("Boolean"), QScriptValue::SkipInEnumeration);

  1049     QVERIFY(global.property("Number").isFunction());

  1050     QCOMPARE(global.propertyFlags("Number"), QScriptValue::SkipInEnumeration);

  1051     QVERIFY(global.property("Date").isFunction());

  1052     QCOMPARE(global.propertyFlags("Date"), QScriptValue::SkipInEnumeration);

  1053     QVERIFY(global.property("RegExp").isFunction());

  1054     QCOMPARE(global.propertyFlags("RegExp"), QScriptValue::SkipInEnumeration);

  1055     QVERIFY(global.property("Error").isFunction());

  1056     QCOMPARE(global.propertyFlags("Error"), QScriptValue::SkipInEnumeration);

  1057     QVERIFY(global.property("EvalError").isFunction());

  1058     QCOMPARE(global.propertyFlags("EvalError"), QScriptValue::SkipInEnumeration);

  1059     QVERIFY(global.property("RangeError").isFunction());

  1060     QCOMPARE(global.propertyFlags("RangeError"), QScriptValue::SkipInEnumeration);

  1061     QVERIFY(global.property("ReferenceError").isFunction());

  1062     QCOMPARE(global.propertyFlags("ReferenceError"), QScriptValue::SkipInEnumeration);

  1063     QVERIFY(global.property("SyntaxError").isFunction());

  1064     QCOMPARE(global.propertyFlags("SyntaxError"), QScriptValue::SkipInEnumeration);

  1065     QVERIFY(global.property("TypeError").isFunction());

  1066     QCOMPARE(global.propertyFlags("TypeError"), QScriptValue::SkipInEnumeration);

  1067     QVERIFY(global.property("URIError").isFunction());

  1068     QCOMPARE(global.propertyFlags("URIError"), QScriptValue::SkipInEnumeration);

  1069     QVERIFY(global.property("Math").isObject());

  1070     QVERIFY(!global.property("Math").isFunction());

  1071     QEXPECT_FAIL("", "[ECMA compliance] JSC sets DontDelete flag for Math object", Continue);

  1072     QCOMPARE(global.propertyFlags("Math"), QScriptValue::SkipInEnumeration);

  1073 

  1074     // enumeration

  1075     QSet<QString> expectedNames;

  1076     expectedNames

  1077         << "isNaN"

  1078         << "parseFloat"

  1079         << "String"

  1080         << "EvalError"

  1081         << "URIError"

  1082         << "Math"

  1083         << "encodeURIComponent"

  1084         << "RangeError"

  1085         << "eval"

  1086         << "isFinite"

  1087         << "ReferenceError"

  1088         << "Infinity"

  1089         << "Function"

  1090         << "RegExp"

  1091         << "Number"

  1092         << "parseInt"

  1093         << "Object"

  1094         << "decodeURI"

  1095         << "TypeError"

  1096         << "Boolean"

  1097         << "encodeURI"

  1098         << "NaN"

  1099         << "Error"

  1100         << "decodeURIComponent"

  1101         << "Date"

  1102         << "Array"

  1103         << "escape"

  1104         << "unescape"

  1105         << "SyntaxError"

  1106         << "undefined"

  1107         // non-standard

  1108         << "gc"

  1109         << "version"

  1110         << "print"

  1111         // JavaScriptCore

  1112         << "JSON"

  1113         ;

  1114     QSet<QString> actualNames;

  1115     {

  1116         QScriptValueIterator it(global);

  1117         while (it.hasNext()) {

  1118             it.next();

  1119             actualNames.insert(it.name());

  1120         }

  1121     }

  1122 

  1123     QSet<QString> remainingNames = actualNames;

  1124     {

  1125         QSet<QString>::const_iterator it;

  1126         for (it = expectedNames.constBegin(); it != expectedNames.constEnd(); ++it) {

  1127             QString name = *it;

  1128             QVERIFY(actualNames.contains(name));

  1129             remainingNames.remove(name);

  1130         }

  1131     }

  1132     QVERIFY(remainingNames.isEmpty());

  1133 

  1134     // create property with no attributes

  1135     {