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

     2 **

     3 ** Copyright (C) 2009 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 <qscriptvalueiterator.h>

    48 #include <qgraphicsitem.h>

    49 #include <qstandarditemmodel.h>

    50 #include <QtCore/qnumeric.h>

    51 #include <stdlib.h>

    52 

    53 Q_DECLARE_METATYPE(QList<int>)

    54 Q_DECLARE_METATYPE(QObjectList)

    55 

    56 //TESTED_CLASS=

    57 //TESTED_FILES=

    58 

    59 #if defined(Q_OS_SYMBIAN)

    60 # define STRINGIFY(x) #x

    61 # define TOSTRING(x) STRINGIFY(x)

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

    63 #endif

    64 

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

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

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

    68 static void zapSomeStack()

    69 {

    70     char buf[4096];

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

    72 }

    73 

    74 static void collectGarbage_helper(QScriptEngine &eng)

    75 {

    76     zapSomeStack();

    77     eng.collectGarbage();

    78 }

    79 

    80 class tst_QScriptEngine : public QObject

    81 {

    82     Q_OBJECT

    83 

    84 public:

    85     tst_QScriptEngine();

    86     virtual ~tst_QScriptEngine();

    87 

    88 private slots:

    89     void constructWithParent();

    90     void currentContext();

    91     void pushPopContext();

    92     void getSetDefaultPrototype();

    93     void newFunction();

    94     void newObject();

    95     void newArray();

    96     void newVariant();

    97     void newRegExp();

    98     void newDate();

    99     void newQObject();

   100     void newQMetaObject();

   101     void newActivationObject();

   102     void getSetGlobalObject();

   103     void globalObjectProperties();

   104     void globalObjectGetterSetterProperty();

   105     void builtinFunctionNames_data();

   106     void builtinFunctionNames();

   107     void checkSyntax_data();

   108     void checkSyntax();

   109     void canEvaluate_data();

   110     void canEvaluate();

   111     void evaluate_data();

   112     void evaluate();

   113     void nestedEvaluate();

   114     void uncaughtException();

   115     void errorMessage_QT679();

   116     void valueConversion();

   117     void importExtension();

   118     void infiniteRecursion();

   119     void castWithPrototypeChain();

   120     void castWithMultipleInheritance();

   121     void collectGarbage();

   122     void gcWithNestedDataStructure();

   123     void processEventsWhileRunning();

   124     void throwErrorFromProcessEvents();

   125     void stacktrace();

   126     void numberParsing_data();

   127     void numberParsing();

   128     void automaticSemicolonInsertion();

   129     void abortEvaluation();

   130     void isEvaluating();

   131     void printFunctionWithCustomHandler();

   132     void printThrowsException();

   133     void errorConstructors();

   134     void argumentsProperty();

   135     void numberClass();

   136     void forInStatement();

   137     void functionExpression();

   138     void stringObjects();

   139     void getterSetterThisObject();

   140     void continueInSwitch();

   141     void readOnlyPrototypeProperty();

   142     void toObject();

   143     void reservedWords_data();

   144     void reservedWords();

   145     void futureReservedWords_data();

   146     void futureReservedWords();

   147     void throwInsideWithStatement();

   148     void getSetAgent();

   149     void reentrancy();

   150     void incDecNonObjectProperty();

   151     void installTranslatorFunctions();

   152     void functionScopes();

   153     void nativeFunctionScopes();

   154 

   155     void qRegExpInport_data();

   156     void qRegExpInport();

   157 };

   158 

   159 tst_QScriptEngine::tst_QScriptEngine()

   160 {

   161 }

   162 

   163 tst_QScriptEngine::~tst_QScriptEngine()

   164 {

   165 }

   166 

   167 void tst_QScriptEngine::constructWithParent()

   168 {

   169     QPointer<QScriptEngine> ptr;

   170     {

   171         QObject obj;

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

   173         ptr = engine;

   174     }

   175     QVERIFY(ptr == 0);

   176 }

   177 

   178 void tst_QScriptEngine::currentContext()

   179 {

   180     QScriptEngine eng;

   181     QScriptContext *globalCtx = eng.currentContext();

   182     QVERIFY(globalCtx != 0);

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

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

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

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

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

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

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

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

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

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

   193 }

   194 

   195 void tst_QScriptEngine::pushPopContext()

   196 {

   197     QScriptEngine eng;

   198     QScriptContext *globalCtx = eng.currentContext();

   199     QScriptContext *ctx = eng.pushContext();

   200     QVERIFY(ctx != 0);

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

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

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

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

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

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

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

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

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

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

   211 

   212     QScriptContext *ctx2 = eng.pushContext();

   213     QVERIFY(ctx2 != 0);

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

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

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

   217 

   218     eng.popContext();

   219     eng.popContext();

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

   221     eng.popContext(); // ignored

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

   223     eng.popContext(); // ignored

   224 }

   225 

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

   227 {

   228     return eng->nullValue();

   229 }

   230 

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

   232 {

   233     return eng->nullValue();

   234 }

   235 

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

   237 {

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

   239 }

   240 

   241 void tst_QScriptEngine::newFunction()

   242 {

   243     QScriptEngine eng;

   244     {

   245         QScriptValue fun = eng.newFunction(myFunction);

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

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

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

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

   250         // a prototype property is automatically constructed

   251         {

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

   253             QVERIFY(prot.isObject());

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

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

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

   257         }

   258         // prototype should be Function.prototype

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

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

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

   262 

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

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

   265     }

   266 

   267     // the overload that takes a void*

   268     {

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

   270         QVERIFY(fun.isFunction());

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

   272         // a prototype property is automatically constructed

   273         {

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

   275             QVERIFY(prot.isObject());

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

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

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

   279         }

   280         // prototype should be Function.prototype

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

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

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

   284 

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

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

   287     }

   288 

   289     // the overload that takes a prototype

   290     {

   291         QScriptValue proto = eng.newObject();

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

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

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

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

   296         // internal prototype should be Function.prototype

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

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

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

   300         // public prototype should be the one we passed

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

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

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

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

   305                  QScriptValue::Undeletable | QScriptValue::SkipInEnumeration);

   306 

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

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

   309     }

   310 }

   311 

   312 void tst_QScriptEngine::newObject()

   313 {

   314     QScriptEngine eng;

   315     QScriptValue object = eng.newObject();

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

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

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

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

   320     // prototype should be Object.prototype

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

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

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

   324 }

   325 

   326 void tst_QScriptEngine::newArray()

   327 {

   328     QScriptEngine eng;

   329     QScriptValue array = eng.newArray();

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

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

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

   333     QVERIFY(!array.isFunction());

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

   335     // prototype should be Array.prototype

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

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

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

   339 

   340     // task 218092

   341     {

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

   343         QVERIFY(ret.isArray());

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

   345     }

   346     {

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

   348         QVERIFY(ret.isArray());

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

   350     }

   351     {

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

   353         QVERIFY(ret.isArray());

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

   355     }

   356     {

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

   358         QVERIFY(ret.isArray());

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

   360     }

   361     {

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

   363         QVERIFY(ret.isArray());

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

   365     }

   366 

   367     // task 233836

   368     {

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

   370         QVERIFY(ret.isNumber());

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

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

   373     }

   374     {

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

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

   377         ret.setProperty(0xFFFFFFFF, 123);

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

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

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

   381         ret.setProperty(123, 456);

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

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

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

   385     }

   386 }

   387 

   388 void tst_QScriptEngine::newVariant()

   389 {

   390     QScriptEngine eng;

   391     {

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

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

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

   395         QVERIFY(!opaque.isFunction());

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

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

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

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

   400     }

   401     // default prototype should be set automatically

   402     {

   403         QScriptValue proto = eng.newObject();

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

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

   406         QVERIFY(ret.isVariant());

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

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

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

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

   411         QVERIFY(ret2.isVariant());

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

   413     }

   414     // "promote" plain object to variant

   415     {

   416         QScriptValue object = eng.newObject();

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

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

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

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

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

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

   423         QVERIFY(ret.isValid());

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

   425         QVERIFY(ret.isVariant());

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

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

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

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

   430     }

   431     // replace value of existing object

   432     {

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

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

   435         QVERIFY(ret.isValid());

   436         QVERIFY(ret.strictlyEquals(object));

   437         QVERIFY(ret.isVariant());

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

   439     }

   440 

   441     // valueOf() and toString()

   442     {

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

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

   445         QVERIFY(value.isNumber());

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

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

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

   449     }

   450     {

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

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

   453         QVERIFY(value.isString());

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

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

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

   457     }

   458     {

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

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

   461         QVERIFY(value.isBoolean());

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

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

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

   465     }

   466     {

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

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

   469         QVERIFY(value.isObject());

   470         QVERIFY(value.strictlyEquals(object));

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

   472     }

   473 }

   474 

   475 void tst_QScriptEngine::newRegExp()

   476 {

   477     QScriptEngine eng;

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

   479         QScriptValue rexp;

   480         if (x == 0)

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

   482         else

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

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

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

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

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

   488         // prototype should be RegExp.prototype

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

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

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

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

   493 

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

   495     }

   496     {

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

   498         QVERIFY(r.isRegExp());

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

   500 

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

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

   503         QVERIFY(r2.isRegExp());

   504         QVERIFY(r2.strictlyEquals(r));

   505 

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

   507         QVERIFY(r3.isError());

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

   509 

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

   511         QVERIFY(r4.isRegExp());

   512 

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

   514         QVERIFY(r5.isRegExp());

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

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

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

   518         QVERIFY(r5.strictlyEquals(r));

   519 

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

   521         QVERIFY(r6.isError());

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

   523 

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

   525         QVERIFY(r7.isError());

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

   527 

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

   529         QVERIFY(r8.isRegExp());

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

   531 

   532         QScriptValue r9 = rxCtor.construct();

   533         QVERIFY(r9.isRegExp());

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

   535 

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

   537         QVERIFY(r10.isRegExp());

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

   539 

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

   541         QVERIFY(r11.isRegExp());

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

   543     }

   544 }

   545 

   546 void tst_QScriptEngine::newDate()

   547 {

   548     QScriptEngine eng;

   549 

   550     {

   551         QScriptValue date = eng.newDate(0);

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

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

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

   555         QVERIFY(!date.isFunction());

   556         // prototype should be Date.prototype

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

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

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

   560     }

   561 

   562     {

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

   564         QScriptValue date = eng.newDate(dt);

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

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

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

   568         // prototype should be Date.prototype

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

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

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

   572 

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

   574     }

   575 

   576     {

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

   578         QScriptValue date = eng.newDate(dt);

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

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

   581     }

   582 

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

   584     {

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

   586         QVERIFY(ret.isNumber());

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

   588     }

   589 

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

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

   592     {

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

   594         QVERIFY(ret.isBoolean());

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

   596     }

   597 #endif

   598 }

   599 

   600 void tst_QScriptEngine::newQObject()

   601 {

   602     QScriptEngine eng;

   603 

   604     {

   605         QScriptValue qobject = eng.newQObject(0);

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

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

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

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

   610     }

   611     {

   612         QScriptValue qobject = eng.newQObject(this);

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

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

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

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

   617         QVERIFY(!qobject.isFunction());

   618         // prototype should be QObject.prototype

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

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

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

   622     }

   623 

   624     // test ownership

   625     {

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

   627         QVERIFY(ptr != 0);

   628         {

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

   630         }

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

   632         if (ptr)

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

   634         QVERIFY(ptr == 0);

   635     }

   636     {

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

   638         QVERIFY(ptr != 0);

   639         {

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

   641         }

   642         QObject *before = ptr;

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

   644         QVERIFY(ptr == before);

   645         delete ptr;

   646     }

   647     {

   648         QObject *parent = new QObject();

   649         QObject *child = new QObject(parent);

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

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

   652         delete parent;

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

   654     }

   655     {

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

   657         QVERIFY(ptr != 0);

   658         {

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

   660         }

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

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

   663         if (ptr)

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

   665         QVERIFY(ptr == 0);

   666     }

   667     {

   668         QObject *parent = new QObject();

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

   670         QVERIFY(child != 0);

   671         {

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

   673         }

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

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

   676         QVERIFY(child != 0);

   677         delete parent;

   678     }

   679 

   680     // "promote" plain object to QObject

   681     {

   682         QScriptValue obj = eng.newObject();

   683         QScriptValue originalProto = obj.prototype();

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

   685         QVERIFY(ret.isValid());

   686         QVERIFY(ret.isQObject());

   687         QVERIFY(ret.strictlyEquals(obj));

   688         QVERIFY(obj.isQObject());

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

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

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

   692         QVERIFY(val.isString());

   693     }

   694     // "promote" variant object to QObject

   695     {

   696         QScriptValue obj = eng.newVariant(123);

   697         QVERIFY(obj.isVariant());

   698         QScriptValue originalProto = obj.prototype();

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

   700         QVERIFY(ret.isQObject());

   701         QVERIFY(ret.strictlyEquals(obj));

   702         QVERIFY(obj.isQObject());

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

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

   705     }

   706     // replace QObject* of existing object

   707     {

   708         QScriptValue object = eng.newVariant(123);

   709         QScriptValue originalProto = object.prototype();

   710         QObject otherQObject;

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

   712         QVERIFY(ret.isValid());

   713         QVERIFY(ret.isQObject());

   714         QVERIFY(ret.strictlyEquals(object));

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

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

   717     }

   718 

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

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

   721         QObject qobj;

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

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

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

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

   726 

   727         QScriptEngine::QObjectWrapOptions opt = 0;

   728         bool preferExisting = (x != 0);

   729         if (preferExisting)

   730             opt |= QScriptEngine::PreferExistingWrapperObject;

   731 

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

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

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

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

   736 

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

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

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

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

   741 

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

   743                                            QScriptEngine::ExcludeSuperClassMethods | opt);

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

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

   746                                            QScriptEngine::ExcludeSuperClassMethods | opt);

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

   748     }

   749 

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

   751     {

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

   753 

   754         QScriptValue qobjectProto = eng.newObject();

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

   756         {

   757             QScriptValue ret = eng.newQObject(this);

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

   759         }

   760         QScriptValue tstProto = eng.newObject();

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

   762         eng.setDefaultPrototype(typeId, tstProto);

   763         {

   764             QScriptValue ret = eng.newQObject(this);

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

   766         }

   767 

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

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

   770     }

   771 }

   772 

   773 QT_BEGIN_NAMESPACE

   774 Q_SCRIPT_DECLARE_QMETAOBJECT(QObject, QObject*)

   775 Q_SCRIPT_DECLARE_QMETAOBJECT(QWidget, QWidget*)

   776 QT_END_NAMESPACE

   777 

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

   779 {

   780     QScriptValue obj;

   781     if (ctx->isCalledAsConstructor()) {

   782         obj = ctx->thisObject();

   783     } else {

   784         obj = eng->newObject();

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

   786     }

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

   788     return obj;

   789 }

   790 

   791 void tst_QScriptEngine::newQMetaObject()

   792 {

   793     QScriptEngine eng;

   794 #if 0

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

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

   797 #else

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

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

   800 #endif

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

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

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

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

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

   806 

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

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

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

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

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

   812 

   813     // prototype should be QMetaObject.prototype

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

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

   816 

   817     QScriptValue instance = qclass.construct();

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

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

   820     QVERIFY(instance.instanceOf(qclass));

   821 

   822     QScriptValue instance2 = qclass2.construct();

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

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

   825     QVERIFY(instance2.instanceOf(qclass2));

   826 

   827     QScriptValueList args;

   828     args << instance;

   829     QScriptValue instance3 = qclass.construct(args);

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

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

   832     QVERIFY(instance3.instanceOf(qclass));

   833     args.clear();

   834 

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

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

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

   838 

   839     QVERIFY(qpointer1);

   840     QVERIFY(qpointer2);

   841     QVERIFY(qpointer3);

   842 

   843     // verify that AutoOwnership is in effect

   844     instance = QScriptValue();

   845     collectGarbage_helper(eng);

   846 

   847     QVERIFY(!qpointer1);

   848     QVERIFY(qpointer2);

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

   850 

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

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

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

   854     instance2 = QScriptValue();

   855     collectGarbage_helper(eng);

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

   857 

   858     // with custom constructor

   859     QScriptValue ctor = eng.newFunction(myConstructor);

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

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

   862     {

   863         QScriptValue ret = qclass3.call();

   864         QVERIFY(ret.isObject());

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

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

   867         QVERIFY(ret.instanceOf(qclass3));

   868     }

   869     {

   870         QScriptValue ret = qclass3.construct();

   871         QVERIFY(ret.isObject());

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

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

   874         QVERIFY(ret.instanceOf(qclass3));

   875     }

   876 

   877     // subclassing

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

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

   880 

   881     // with meta-constructor

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

   883     {

   884         QScriptValue inst = qclass4.construct();

   885         QVERIFY(inst.isQObject());

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

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

   888         QVERIFY(inst.instanceOf(qclass4));

   889     }

   890     {

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

   892         QVERIFY(inst.isQObject());

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

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

   895         QVERIFY(inst.instanceOf(qclass4));

   896     }

   897 }

   898 

   899 void tst_QScriptEngine::newActivationObject()

   900 {

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

   902     QScriptEngine eng;

   903     QScriptValue act = eng.newActivationObject();

   904     QEXPECT_FAIL("", "", Continue);

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

   906     QEXPECT_FAIL("", "", Continue);

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

   908     QVERIFY(!act.isFunction());

   909     QScriptValue v(&eng, 123);

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

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

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

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

   914     QEXPECT_FAIL("", "", Continue);

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

   916 }

   917 

   918 void tst_QScriptEngine::getSetGlobalObject()

   919 {

   920     QScriptEngine eng;

   921     QScriptValue glob = eng.globalObject();

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

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

   924     QVERIFY(!glob.isFunction());

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

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

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

   928     // prototype should be Object.prototype

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

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

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

   932 

   933     QScriptValue obj = eng.newObject();

   934     eng.setGlobalObject(obj);

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

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

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

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

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

   940 

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

   942     collectGarbage_helper(eng);

   943     obj = eng.newObject();

   944     eng.setGlobalObject(obj);

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

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

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

   948 

   949     collectGarbage_helper(eng);

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

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

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

   953 

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

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

   956     {

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

   958         QVERIFY(ret.isNumber());

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

   960     }

   961 

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

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

   964     {

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

   966         QVERIFY(ret.isNumber());

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

   968     }

   969 

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

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

   972     {

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

   974         QVERIFY(ret.isNumber());

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

   976     }

   977 

   978     {

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

   980         QVERIFY(ret.strictlyEquals(obj));

   981     }

   982 }

   983 

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

   985 {

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

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

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

   989 }

   990 

   991 void tst_QScriptEngine::globalObjectProperties()

   992 {

   993     QScriptEngine eng;

   994     QScriptValue global = eng.globalObject();

   995 

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

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

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

   999 

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

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

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

  1003 

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

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

  1006 

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

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

  1009 

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

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

  1012 

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

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

  1015 

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

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

  1018 

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

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

  1021 

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

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

  1024 

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

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

  1027 

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

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

  1030 

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

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

  1033 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1068 

  1069     // enumeration

  1070     QSet<QString> expectedNames;

  1071     expectedNames

  1072         << "isNaN"

  1073         << "parseFloat"

  1074         << "String"

  1075         << "EvalError"

  1076         << "URIError"

  1077         << "Math"

  1078         << "encodeURIComponent"

  1079         << "RangeError"

  1080         << "eval"

  1081         << "isFinite"

  1082         << "ReferenceError"

  1083         << "Infinity"

  1084         << "Function"

  1085         << "RegExp"

  1086         << "Number"

  1087         << "parseInt"

  1088         << "Object"

  1089         << "decodeURI"

  1090         << "TypeError"

  1091         << "Boolean"

  1092         << "encodeURI"

  1093         << "NaN"

  1094         << "Error"

  1095         << "decodeURIComponent"

  1096         << "Date"

  1097         << "Array"

  1098         << "escape"

  1099         << "unescape"

  1100         << "SyntaxError"

  1101         << "undefined"

  1102         // non-standard

  1103         << "gc"

  1104         << "version"

  1105         << "print"

  1106         // JavaScriptCore

  1107         << "JSON"

  1108         ;

  1109     QSet<QString> actualNames;

  1110     {

  1111         QScriptValueIterator it(global);

  1112         while (it.hasNext()) {

  1113             it.next();

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

  1115         }

  1116     }

  1117 

  1118     QSet<QString> remainingNames = actualNames;

  1119     {

  1120         QSet<QString>::const_iterator it;

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

  1122             QString name = *it;

  1123             QVERIFY(actualNames.contains(name));

  1124             remainingNames.remove(name);

  1125         }

  1126     }

  1127     QVERIFY(remainingNames.isEmpty());

  1128 

  1129     // create property with no attributes

  1130     {

  1131         QString name = QString::fromLatin1("foo");

  1132         QVERIFY(!global.property(name).isValid());

  1133         QScriptValue val(123);

  1134         global.setProperty(name, val);