/**************************************************************************** ** ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). ** All rights reserved. ** Contact: Nokia Corporation (qt-info@nokia.com) ** ** This file is part of the test suite of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** No Commercial Usage ** This file contains pre-release code and may not be distributed. ** You may use this file in accordance with the terms and conditions ** contained in the Technology Preview License Agreement accompanying ** this package. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 2.1 as published by the Free Software ** Foundation and appearing in the file LICENSE.LGPL included in the ** packaging of this file. Please review the following information to ** ensure the GNU Lesser General Public License version 2.1 requirements ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, Nokia gives you certain additional ** rights. These rights are described in the Nokia Qt LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ** If you have questions regarding the use of this file, please contact ** Nokia at qt-info@nokia.com. ** ** ** ** ** ** ** ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #include #include #include #include #include #include #include #include #include #include Q_DECLARE_METATYPE(QList) Q_DECLARE_METATYPE(QObjectList) Q_DECLARE_METATYPE(QScriptProgram) //TESTED_CLASS= //TESTED_FILES= #if defined(Q_OS_SYMBIAN) # define STRINGIFY(x) #x # define TOSTRING(x) STRINGIFY(x) # define SRCDIR "C:/Private/" TOSTRING(SYMBIAN_SRCDIR_UID) #endif // The JavaScriptCore GC marks the C stack. To try to ensure that there is // no JSObject* left in stack memory by the compiler, we call this function // to zap some bytes of memory before calling collectGarbage(). static void zapSomeStack() { char buf[4096]; memset(buf, 0, sizeof(buf)); } static void collectGarbage_helper(QScriptEngine &eng) { zapSomeStack(); eng.collectGarbage(); } class tst_QScriptEngine : public QObject { Q_OBJECT public: tst_QScriptEngine(); virtual ~tst_QScriptEngine(); private slots: void constructWithParent(); void currentContext(); void pushPopContext(); void getSetDefaultPrototype_int(); void getSetDefaultPrototype_customType(); void newFunction(); void newFunctionWithArg(); void newFunctionWithProto(); void newObject(); void newArray(); void newArray_HooliganTask218092(); void newArray_HooliganTask233836(); void newVariant(); void newVariant_defaultPrototype(); void newVariant_promoteObject(); void newVariant_replaceValue(); void newVariant_valueOfToString(); void newVariant_promoteNonObject(); void newVariant_promoteNonQScriptObject(); void newRegExp(); void jsRegExp(); void newDate(); void jsParseDate(); void newQObject(); void newQObject_ownership(); void newQObject_promoteObject(); void newQObject_sameQObject(); void newQObject_defaultPrototype(); void newQObject_promoteNonObject(); void newQObject_promoteNonQScriptObject(); void newQMetaObject(); void newActivationObject(); void getSetGlobalObject(); void globalObjectProperties(); void globalObjectProperties_enumerate(); void createGlobalObjectProperty(); void globalObjectGetterSetterProperty(); void customGlobalObjectWithPrototype(); void globalObjectWithCustomPrototype(); void builtinFunctionNames_data(); void builtinFunctionNames(); void checkSyntax_data(); void checkSyntax(); void canEvaluate_data(); void canEvaluate(); void evaluate_data(); void evaluate(); void nestedEvaluate(); void uncaughtException(); void errorMessage_QT679(); void valueConversion_basic(); void valueConversion_customType(); void valueConversion_sequence(); void valueConversion_QVariant(); void valueConversion_hooliganTask248802(); void valueConversion_basic2(); void valueConversion_dateTime(); void valueConversion_regExp(); void qScriptValueFromValue_noEngine(); void importExtension(); void infiniteRecursion(); void castWithPrototypeChain(); void castWithMultipleInheritance(); void collectGarbage(); void reportAdditionalMemoryCost(); void gcWithNestedDataStructure(); void processEventsWhileRunning(); void throwErrorFromProcessEvents_data(); void throwErrorFromProcessEvents(); void disableProcessEventsInterval(); void stacktrace(); void numberParsing_data(); void numberParsing(); void automaticSemicolonInsertion(); void abortEvaluation_notEvaluating(); void abortEvaluation_data(); void abortEvaluation(); void abortEvaluation_tryCatch(); void abortEvaluation_fromNative(); void abortEvaluation_QTBUG9433(); void isEvaluating_notEvaluating(); void isEvaluating_fromNative(); void isEvaluating_fromEvent(); void printFunctionWithCustomHandler(); void printThrowsException(); void errorConstructors(); void argumentsProperty_globalContext(); void argumentsProperty_JS(); void argumentsProperty_evaluateInNativeFunction(); void jsNumberClass(); void jsForInStatement_simple(); void jsForInStatement_prototypeProperties(); void jsForInStatement_mutateWhileIterating(); void jsForInStatement_arrays(); void jsForInStatement_nullAndUndefined(); void jsFunctionDeclarationAsStatement(); void stringObjects(); void jsStringPrototypeReplaceBugs(); void getterSetterThisObject_global(); void getterSetterThisObject_plain(); void getterSetterThisObject_prototypeChain(); void getterSetterThisObject_activation(); void jsContinueInSwitch(); void jsShadowReadOnlyPrototypeProperty(); void toObject(); void jsReservedWords_data(); void jsReservedWords(); void jsFutureReservedWords_data(); void jsFutureReservedWords(); void jsThrowInsideWithStatement(); void getSetAgent_ownership(); void getSetAgent_deleteAgent(); void getSetAgent_differentEngine(); void reentrancy_stringHandles(); void reentrancy_processEventsInterval(); void reentrancy_typeConversion(); void reentrancy_globalObjectProperties(); void reentrancy_Array(); void reentrancy_objectCreation(); void jsIncDecNonObjectProperty(); void installTranslatorFunctions_data(); void installTranslatorFunctions(); void translateScript_data(); void translateScript(); void translateScript_crossScript(); void translateScript_callQsTrFromNative(); void translateScript_trNoOp(); void translateScript_callQsTrFromCpp(); void translateWithInvalidArgs_data(); void translateWithInvalidArgs(); void translationContext_data(); void translationContext(); void translateScriptIdBased(); void translateScriptUnicode_data(); void translateScriptUnicode(); void translateScriptUnicodeIdBased_data(); void translateScriptUnicodeIdBased(); void translateFromBuiltinCallback(); void functionScopes(); void nativeFunctionScopes(); void evaluateProgram(); void evaluateProgram_customScope(); void evaluateProgram_closure(); void evaluateProgram_executeLater(); void evaluateProgram_multipleEngines(); void evaluateProgram_empty(); void collectGarbageAfterConnect(); void collectGarbageAfterNativeArguments(); void promoteThisObjectToQObjectInConstructor(); void scriptValueFromQMetaObject(); void qRegExpInport_data(); void qRegExpInport(); void reentrency(); void newFixedStaticScopeObject(); void newGrowingStaticScopeObject(); void dateRoundtripJSQtJS(); void dateRoundtripQtJSQt(); void dateConversionJSQt(); void dateConversionQtJS(); }; tst_QScriptEngine::tst_QScriptEngine() { } tst_QScriptEngine::~tst_QScriptEngine() { } void tst_QScriptEngine::constructWithParent() { QPointer ptr; { QObject obj; QScriptEngine *engine = new QScriptEngine(&obj); ptr = engine; } QVERIFY(ptr == 0); } void tst_QScriptEngine::currentContext() { QScriptEngine eng; QScriptContext *globalCtx = eng.currentContext(); QVERIFY(globalCtx != 0); QVERIFY(globalCtx->parentContext() == 0); QCOMPARE(globalCtx->engine(), &eng); QCOMPARE(globalCtx->argumentCount(), 0); QCOMPARE(globalCtx->backtrace().size(), 1); QVERIFY(!globalCtx->isCalledAsConstructor()); QVERIFY(!globalCtx->callee().isValid()); QCOMPARE(globalCtx->state(), QScriptContext::NormalState); QVERIFY(globalCtx->thisObject().strictlyEquals(eng.globalObject())); QVERIFY(globalCtx->activationObject().strictlyEquals(eng.globalObject())); QVERIFY(globalCtx->argumentsObject().isObject()); } void tst_QScriptEngine::pushPopContext() { QScriptEngine eng; QScriptContext *globalCtx = eng.currentContext(); QScriptContext *ctx = eng.pushContext(); QVERIFY(ctx != 0); QCOMPARE(ctx->parentContext(), globalCtx); QVERIFY(!ctx->isCalledAsConstructor()); QVERIFY(!ctx->callee().isValid()); QVERIFY(ctx->thisObject().strictlyEquals(eng.globalObject())); QCOMPARE(ctx->argumentCount(), 0); QCOMPARE(ctx->backtrace().size(), 2); QCOMPARE(ctx->engine(), &eng); QCOMPARE(ctx->state(), QScriptContext::NormalState); QVERIFY(ctx->activationObject().isObject()); QVERIFY(ctx->argumentsObject().isObject()); QScriptContext *ctx2 = eng.pushContext(); QVERIFY(ctx2 != 0); QCOMPARE(ctx2->parentContext(), ctx); QVERIFY(!ctx2->activationObject().strictlyEquals(ctx->activationObject())); QVERIFY(!ctx2->argumentsObject().strictlyEquals(ctx->argumentsObject())); eng.popContext(); eng.popContext(); QTest::ignoreMessage(QtWarningMsg, "QScriptEngine::popContext() doesn't match with pushContext()"); eng.popContext(); // ignored QTest::ignoreMessage(QtWarningMsg, "QScriptEngine::popContext() doesn't match with pushContext()"); eng.popContext(); // ignored } static QScriptValue myFunction(QScriptContext *, QScriptEngine *eng) { return eng->nullValue(); } static QScriptValue myFunctionWithVoidArg(QScriptContext *, QScriptEngine *eng, void *) { return eng->nullValue(); } static QScriptValue myThrowingFunction(QScriptContext *ctx, QScriptEngine *) { return ctx->throwError("foo"); } void tst_QScriptEngine::newFunction() { QScriptEngine eng; { QScriptValue fun = eng.newFunction(myFunction); QCOMPARE(fun.isValid(), true); QCOMPARE(fun.isFunction(), true); QCOMPARE(fun.isObject(), true); QCOMPARE(fun.scriptClass(), (QScriptClass*)0); // a prototype property is automatically constructed { QScriptValue prot = fun.property("prototype", QScriptValue::ResolveLocal); QVERIFY(prot.isObject()); QVERIFY(prot.property("constructor").strictlyEquals(fun)); QCOMPARE(fun.propertyFlags("prototype"), QScriptValue::Undeletable | QScriptValue::SkipInEnumeration); QCOMPARE(prot.propertyFlags("constructor"), QScriptValue::SkipInEnumeration); } // prototype should be Function.prototype QCOMPARE(fun.prototype().isValid(), true); QCOMPARE(fun.prototype().isFunction(), true); QCOMPARE(fun.prototype().strictlyEquals(eng.evaluate("Function.prototype")), true); QCOMPARE(fun.call().isNull(), true); QCOMPARE(fun.construct().isObject(), true); } } void tst_QScriptEngine::newFunctionWithArg() { QScriptEngine eng; { QScriptValue fun = eng.newFunction(myFunctionWithVoidArg, (void*)this); QVERIFY(fun.isFunction()); QCOMPARE(fun.scriptClass(), (QScriptClass*)0); // a prototype property is automatically constructed { QScriptValue prot = fun.property("prototype", QScriptValue::ResolveLocal); QVERIFY(prot.isObject()); QVERIFY(prot.property("constructor").strictlyEquals(fun)); QCOMPARE(fun.propertyFlags("prototype"), QScriptValue::Undeletable | QScriptValue::SkipInEnumeration); QCOMPARE(prot.propertyFlags("constructor"), QScriptValue::SkipInEnumeration); } // prototype should be Function.prototype QCOMPARE(fun.prototype().isValid(), true); QCOMPARE(fun.prototype().isFunction(), true); QCOMPARE(fun.prototype().strictlyEquals(eng.evaluate("Function.prototype")), true); QCOMPARE(fun.call().isNull(), true); QCOMPARE(fun.construct().isObject(), true); } } void tst_QScriptEngine::newFunctionWithProto() { QScriptEngine eng; { QScriptValue proto = eng.newObject(); QScriptValue fun = eng.newFunction(myFunction, proto); QCOMPARE(fun.isValid(), true); QCOMPARE(fun.isFunction(), true); QCOMPARE(fun.isObject(), true); // internal prototype should be Function.prototype QCOMPARE(fun.prototype().isValid(), true); QCOMPARE(fun.prototype().isFunction(), true); QCOMPARE(fun.prototype().strictlyEquals(eng.evaluate("Function.prototype")), true); // public prototype should be the one we passed QCOMPARE(fun.property("prototype").strictlyEquals(proto), true); QCOMPARE(fun.propertyFlags("prototype"), QScriptValue::Undeletable | QScriptValue::SkipInEnumeration); QCOMPARE(proto.property("constructor").strictlyEquals(fun), true); QCOMPARE(proto.propertyFlags("constructor"), QScriptValue::SkipInEnumeration); QCOMPARE(fun.call().isNull(), true); QCOMPARE(fun.construct().isObject(), true); } } void tst_QScriptEngine::newObject() { QScriptEngine eng; QScriptValue object = eng.newObject(); QCOMPARE(object.isValid(), true); QCOMPARE(object.isObject(), true); QCOMPARE(object.isFunction(), false); QCOMPARE(object.scriptClass(), (QScriptClass*)0); // prototype should be Object.prototype QCOMPARE(object.prototype().isValid(), true); QCOMPARE(object.prototype().isObject(), true); QCOMPARE(object.prototype().strictlyEquals(eng.evaluate("Object.prototype")), true); } void tst_QScriptEngine::newArray() { QScriptEngine eng; QScriptValue array = eng.newArray(); QCOMPARE(array.isValid(), true); QCOMPARE(array.isArray(), true); QCOMPARE(array.isObject(), true); QVERIFY(!array.isFunction()); QCOMPARE(array.scriptClass(), (QScriptClass*)0); // prototype should be Array.prototype QCOMPARE(array.prototype().isValid(), true); QCOMPARE(array.prototype().isArray(), true); QCOMPARE(array.prototype().strictlyEquals(eng.evaluate("Array.prototype")), true); } void tst_QScriptEngine::newArray_HooliganTask218092() { QScriptEngine eng; { QScriptValue ret = eng.evaluate("[].splice(0, 0, 'a')"); QVERIFY(ret.isArray()); QCOMPARE(ret.property("length").toInt32(), 0); } { QScriptValue ret = eng.evaluate("['a'].splice(0, 1, 'b')"); QVERIFY(ret.isArray()); QCOMPARE(ret.property("length").toInt32(), 1); } { QScriptValue ret = eng.evaluate("['a', 'b'].splice(0, 1, 'c')"); QVERIFY(ret.isArray()); QCOMPARE(ret.property("length").toInt32(), 1); } { QScriptValue ret = eng.evaluate("['a', 'b', 'c'].splice(0, 2, 'd')"); QVERIFY(ret.isArray()); QCOMPARE(ret.property("length").toInt32(), 2); } { QScriptValue ret = eng.evaluate("['a', 'b', 'c'].splice(1, 2, 'd', 'e', 'f')"); QVERIFY(ret.isArray()); QCOMPARE(ret.property("length").toInt32(), 2); } } void tst_QScriptEngine::newArray_HooliganTask233836() { QScriptEngine eng; { // According to ECMA-262, this should cause a RangeError. QScriptValue ret = eng.evaluate("a = new Array(4294967295); a.push('foo')"); QEXPECT_FAIL("", "ECMA compliance bug in Array.prototype.push: https://bugs.webkit.org/show_bug.cgi?id=55033", Continue); QVERIFY(ret.isError() && ret.toString().contains(QLatin1String("RangeError"))); } { QScriptValue ret = eng.newArray(0xFFFFFFFF); QCOMPARE(ret.property("length").toUInt32(), uint(0xFFFFFFFF)); ret.setProperty(0xFFFFFFFF, 123); QCOMPARE(ret.property("length").toUInt32(), uint(0xFFFFFFFF)); QVERIFY(ret.property(0xFFFFFFFF).isNumber()); QCOMPARE(ret.property(0xFFFFFFFF).toInt32(), 123); ret.setProperty(123, 456); QCOMPARE(ret.property("length").toUInt32(), uint(0xFFFFFFFF)); QVERIFY(ret.property(123).isNumber()); QCOMPARE(ret.property(123).toInt32(), 456); } } void tst_QScriptEngine::newVariant() { QScriptEngine eng; { QScriptValue opaque = eng.newVariant(QVariant()); QCOMPARE(opaque.isValid(), true); QCOMPARE(opaque.isVariant(), true); QVERIFY(!opaque.isFunction()); QCOMPARE(opaque.isObject(), true); QCOMPARE(opaque.prototype().isValid(), true); QCOMPARE(opaque.prototype().isVariant(), true); QVERIFY(opaque.property("valueOf").call(opaque).isUndefined()); } } void tst_QScriptEngine::newVariant_defaultPrototype() { // default prototype should be set automatically QScriptEngine eng; { QScriptValue proto = eng.newObject(); eng.setDefaultPrototype(qMetaTypeId(), proto); QScriptValue ret = eng.newVariant(QVariant(QString::fromLatin1("hello"))); QVERIFY(ret.isVariant()); QCOMPARE(ret.scriptClass(), (QScriptClass*)0); QVERIFY(ret.prototype().strictlyEquals(proto)); eng.setDefaultPrototype(qMetaTypeId(), QScriptValue()); QScriptValue ret2 = eng.newVariant(QVariant(QString::fromLatin1("hello"))); QVERIFY(ret2.isVariant()); QVERIFY(!ret2.prototype().strictlyEquals(proto)); } } void tst_QScriptEngine::newVariant_promoteObject() { // "promote" plain object to variant QScriptEngine eng; { QScriptValue object = eng.newObject(); object.setProperty("foo", eng.newObject()); object.setProperty("bar", object.property("foo")); QVERIFY(object.property("foo").isObject()); QVERIFY(!object.property("foo").isVariant()); QScriptValue originalProto = object.property("foo").prototype(); QScriptValue ret = eng.newVariant(object.property("foo"), QVariant(123)); QVERIFY(ret.isValid()); QVERIFY(ret.strictlyEquals(object.property("foo"))); QVERIFY(ret.isVariant()); QVERIFY(object.property("foo").isVariant()); QVERIFY(object.property("bar").isVariant()); QCOMPARE(ret.toVariant(), QVariant(123)); QVERIFY(ret.prototype().strictlyEquals(originalProto)); } } void tst_QScriptEngine::newVariant_replaceValue() { // replace value of existing object QScriptEngine eng; { QScriptValue object = eng.newVariant(QVariant(123)); for (int x = 0; x < 2; ++x) { QScriptValue ret = eng.newVariant(object, QVariant(456)); QVERIFY(ret.isValid()); QVERIFY(ret.strictlyEquals(object)); QVERIFY(ret.isVariant()); QCOMPARE(ret.toVariant(), QVariant(456)); } } } void tst_QScriptEngine::newVariant_valueOfToString() { // valueOf() and toString() QScriptEngine eng; { QScriptValue object = eng.newVariant(QVariant(123)); QScriptValue value = object.property("valueOf").call(object); QVERIFY(value.isNumber()); QCOMPARE(value.toInt32(), 123); QCOMPARE(object.toString(), QString::fromLatin1("123")); QCOMPARE(object.toVariant().toString(), object.toString()); } { QScriptValue object = eng.newVariant(QVariant(QString::fromLatin1("hello"))); QScriptValue value = object.property("valueOf").call(object); QVERIFY(value.isString()); QCOMPARE(value.toString(), QString::fromLatin1("hello")); QCOMPARE(object.toString(), QString::fromLatin1("hello")); QCOMPARE(object.toVariant().toString(), object.toString()); } { QScriptValue object = eng.newVariant(QVariant(false)); QScriptValue value = object.property("valueOf").call(object); QVERIFY(value.isBoolean()); QCOMPARE(value.toBoolean(), false); QCOMPARE(object.toString(), QString::fromLatin1("false")); QCOMPARE(object.toVariant().toString(), object.toString()); } { QScriptValue object = eng.newVariant(QVariant(QPoint(10, 20))); QScriptValue value = object.property("valueOf").call(object); QVERIFY(value.isObject()); QVERIFY(value.strictlyEquals(object)); QCOMPARE(object.toString(), QString::fromLatin1("QVariant(QPoint)")); } } void tst_QScriptEngine::newVariant_promoteNonObject() { QScriptEngine eng; { QVariant var(456); QScriptValue ret = eng.newVariant(123, var); QVERIFY(ret.isVariant()); QCOMPARE(ret.toVariant(), var); } } void tst_QScriptEngine::newVariant_promoteNonQScriptObject() { QScriptEngine eng; { QTest::ignoreMessage(QtWarningMsg, "QScriptEngine::newVariant(): changing class of non-QScriptObject not supported"); QScriptValue ret = eng.newVariant(eng.newArray(), 123); QVERIFY(!ret.isValid()); } } void tst_QScriptEngine::newRegExp() { QScriptEngine eng; for (int x = 0; x < 2; ++x) { QScriptValue rexp; if (x == 0) rexp = eng.newRegExp("foo", "bar"); else rexp = eng.newRegExp(QRegExp("foo")); QCOMPARE(rexp.isValid(), true); QCOMPARE(rexp.isRegExp(), true); QCOMPARE(rexp.isObject(), true); QVERIFY(rexp.isFunction()); // in JSC, RegExp objects are callable // prototype should be RegExp.prototype QCOMPARE(rexp.prototype().isValid(), true); QCOMPARE(rexp.prototype().isObject(), true); QCOMPARE(rexp.prototype().isRegExp(), false); QCOMPARE(rexp.prototype().strictlyEquals(eng.evaluate("RegExp.prototype")), true); QCOMPARE(rexp.toRegExp().pattern(), QRegExp("foo").pattern()); } } void tst_QScriptEngine::jsRegExp() { // See ECMA-262 Section 15.10, "RegExp Objects". // These should really be JS-only tests, as they test the implementation's // ECMA-compliance, not the C++ API. Compliance should already be covered // by the Mozilla tests (qscriptjstestsuite). // We can consider updating the expected results of this test if the // RegExp implementation changes. QScriptEngine eng; QScriptValue r = eng.evaluate("/foo/gim"); QVERIFY(r.isRegExp()); QCOMPARE(r.toString(), QString::fromLatin1("/foo/gim")); QScriptValue rxCtor = eng.globalObject().property("RegExp"); QScriptValue r2 = rxCtor.call(QScriptValue(), QScriptValueList() << r); QVERIFY(r2.isRegExp()); QVERIFY(r2.strictlyEquals(r)); QScriptValue r3 = rxCtor.call(QScriptValue(), QScriptValueList() << r << "gim"); QVERIFY(r3.isError()); QVERIFY(r3.toString().contains(QString::fromLatin1("TypeError"))); // Cannot supply flags when constructing one RegExp from another QScriptValue r4 = rxCtor.call(QScriptValue(), QScriptValueList() << "foo" << "gim"); QVERIFY(r4.isRegExp()); QScriptValue r5 = rxCtor.construct(QScriptValueList() << r); QVERIFY(r5.isRegExp()); QCOMPARE(r5.toString(), QString::fromLatin1("/foo/gim")); // In JSC, constructing a RegExp from another produces the same identical object. // This is different from SpiderMonkey and old back-end. QEXPECT_FAIL("", "RegExp copy-constructor should return a new object: https://bugs.webkit.org/show_bug.cgi?id=55040", Continue); QVERIFY(!r5.strictlyEquals(r)); QScriptValue r6 = rxCtor.construct(QScriptValueList() << "foo" << "bar"); QVERIFY(r6.isError()); QVERIFY(r6.toString().contains(QString::fromLatin1("SyntaxError"))); // Invalid regular expression flag QScriptValue r7 = eng.evaluate("/foo/gimp"); QVERIFY(r7.isError()); QVERIFY(r7.toString().contains(QString::fromLatin1("SyntaxError"))); // Invalid regular expression flag // JSC doesn't complain about duplicate flags. QScriptValue r8 = eng.evaluate("/foo/migmigmig"); QVERIFY(r8.isRegExp()); QCOMPARE(r8.toString(), QString::fromLatin1("/foo/gim")); QScriptValue r9 = rxCtor.construct(); QVERIFY(r9.isRegExp()); QCOMPARE(r9.toString(), QString::fromLatin1("/(?:)/")); QScriptValue r10 = rxCtor.construct(QScriptValueList() << "" << "gim"); QVERIFY(r10.isRegExp()); QCOMPARE(r10.toString(), QString::fromLatin1("/(?:)/gim")); QScriptValue r11 = rxCtor.construct(QScriptValueList() << "{1.*}" << "g"); QVERIFY(r11.isRegExp()); QCOMPARE(r11.toString(), QString::fromLatin1("/{1.*}/g")); } void tst_QScriptEngine::newDate() { QScriptEngine eng; { QScriptValue date = eng.newDate(0); QCOMPARE(date.isValid(), true); QCOMPARE(date.isDate(), true); QCOMPARE(date.isObject(), true); QVERIFY(!date.isFunction()); // prototype should be Date.prototype QCOMPARE(date.prototype().isValid(), true); QCOMPARE(date.prototype().isDate(), true); QCOMPARE(date.prototype().strictlyEquals(eng.evaluate("Date.prototype")), true); } { QDateTime dt = QDateTime(QDate(1, 2, 3), QTime(4, 5, 6, 7), Qt::LocalTime); QScriptValue date = eng.newDate(dt); QCOMPARE(date.isValid(), true); QCOMPARE(date.isDate(), true); QCOMPARE(date.isObject(), true); // prototype should be Date.prototype QCOMPARE(date.prototype().isValid(), true); QCOMPARE(date.prototype().isDate(), true); QCOMPARE(date.prototype().strictlyEquals(eng.evaluate("Date.prototype")), true); QCOMPARE(date.toDateTime(), dt); } { QDateTime dt = QDateTime(QDate(1, 2, 3), QTime(4, 5, 6, 7), Qt::UTC); QScriptValue date = eng.newDate(dt); // toDateTime() result should be in local time QCOMPARE(date.toDateTime(), dt.toLocalTime()); } } void tst_QScriptEngine::jsParseDate() { QScriptEngine eng; // Date.parse() should return NaN when it fails { QScriptValue ret = eng.evaluate("Date.parse()"); QVERIFY(ret.isNumber()); QVERIFY(qIsNaN(ret.toNumber())); } // Date.parse() should be able to parse the output of Date().toString() #ifndef Q_WS_WIN // TODO: Test and remove this since 169701 has been fixed { QScriptValue ret = eng.evaluate("var x = new Date(); var s = x.toString(); s == new Date(Date.parse(s)).toString()"); QVERIFY(ret.isBoolean()); QCOMPARE(ret.toBoolean(), true); } #endif } void tst_QScriptEngine::newQObject() { QScriptEngine eng; { QScriptValue qobject = eng.newQObject(0); QCOMPARE(qobject.isValid(), true); QCOMPARE(qobject.isNull(), true); QCOMPARE(qobject.isObject(), false); QCOMPARE(qobject.toQObject(), (QObject *)0); } { QScriptValue qobject = eng.newQObject(this); QCOMPARE(qobject.isValid(), true); QCOMPARE(qobject.isQObject(), true); QCOMPARE(qobject.isObject(), true); QCOMPARE(qobject.toQObject(), (QObject *)this); QVERIFY(!qobject.isFunction()); // prototype should be QObject.prototype QCOMPARE(qobject.prototype().isValid(), true); QCOMPARE(qobject.prototype().isQObject(), true); QCOMPARE(qobject.scriptClass(), (QScriptClass*)0); } } void tst_QScriptEngine::newQObject_ownership() { QScriptEngine eng; { QPointer ptr = new QObject(); QVERIFY(ptr != 0); { QScriptValue v = eng.newQObject(ptr, QScriptEngine::ScriptOwnership); } eng.evaluate("gc()"); if (ptr) QEXPECT_FAIL("", "In the JSC-based back-end, script-owned QObjects are not always deleted immediately during GC", Continue); QVERIFY(ptr == 0); } { QPointer ptr = new QObject(); QVERIFY(ptr != 0); { QScriptValue v = eng.newQObject(ptr, QScriptEngine::QtOwnership); } QObject *before = ptr; eng.evaluate("gc()"); QVERIFY(ptr == before); delete ptr; } { QObject *parent = new QObject(); QObject *child = new QObject(parent); QScriptValue v = eng.newQObject(child, QScriptEngine::QtOwnership); QCOMPARE(v.toQObject(), child); delete parent; QCOMPARE(v.toQObject(), (QObject *)0); } { QPointer ptr = new QObject(); QVERIFY(ptr != 0); { QScriptValue v = eng.newQObject(ptr, QScriptEngine::AutoOwnership); } eng.evaluate("gc()"); // no parent, so it should be like ScriptOwnership if (ptr) QEXPECT_FAIL("", "In the JSC-based back-end, script-owned QObjects are not always deleted immediately during GC", Continue); QVERIFY(ptr == 0); } { QObject *parent = new QObject(); QPointer child = new QObject(parent); QVERIFY(child != 0); { QScriptValue v = eng.newQObject(child, QScriptEngine::AutoOwnership); } eng.evaluate("gc()"); // has parent, so it should be like QtOwnership QVERIFY(child != 0); delete parent; } } void tst_QScriptEngine::newQObject_promoteObject() { QScriptEngine eng; // "promote" plain object to QObject { QScriptValue obj = eng.newObject(); QScriptValue originalProto = obj.prototype(); QScriptValue ret = eng.newQObject(obj, this); QVERIFY(ret.isValid()); QVERIFY(ret.isQObject()); QVERIFY(ret.strictlyEquals(obj)); QVERIFY(obj.isQObject()); QCOMPARE(ret.toQObject(), (QObject *)this); QVERIFY(ret.prototype().strictlyEquals(originalProto)); QScriptValue val = ret.property("objectName"); QVERIFY(val.isString()); } // "promote" variant object to QObject { QScriptValue obj = eng.newVariant(123); QVERIFY(obj.isVariant()); QScriptValue originalProto = obj.prototype(); QScriptValue ret = eng.newQObject(obj, this); QVERIFY(ret.isQObject()); QVERIFY(ret.strictlyEquals(obj)); QVERIFY(obj.isQObject()); QCOMPARE(ret.toQObject(), (QObject *)this); QVERIFY(ret.prototype().strictlyEquals(originalProto)); } // replace QObject* of existing object { QScriptValue object = eng.newVariant(123); QScriptValue originalProto = object.prototype(); QObject otherQObject; for (int x = 0; x < 2; ++x) { QScriptValue ret = eng.newQObject(object, &otherQObject); QVERIFY(ret.isValid()); QVERIFY(ret.isQObject()); QVERIFY(ret.strictlyEquals(object)); QCOMPARE(ret.toQObject(), (QObject *)&otherQObject); QVERIFY(ret.prototype().strictlyEquals(originalProto)); } } } void tst_QScriptEngine::newQObject_sameQObject() { QScriptEngine eng; // calling newQObject() several times with same object for (int x = 0; x < 2; ++x) { QObject qobj; // the default is to create a new wrapper object QScriptValue obj1 = eng.newQObject(&qobj); QScriptValue obj2 = eng.newQObject(&qobj); QVERIFY(!obj2.strictlyEquals(obj1)); QScriptEngine::QObjectWrapOptions opt = 0; bool preferExisting = (x != 0); if (preferExisting) opt |= QScriptEngine::PreferExistingWrapperObject; QScriptValue obj3 = eng.newQObject(&qobj, QScriptEngine::AutoOwnership, opt); QVERIFY(!obj3.strictlyEquals(obj2)); QScriptValue obj4 = eng.newQObject(&qobj, QScriptEngine::AutoOwnership, opt); QCOMPARE(obj4.strictlyEquals(obj3), preferExisting); QScriptValue obj5 = eng.newQObject(&qobj, QScriptEngine::ScriptOwnership, opt); QVERIFY(!obj5.strictlyEquals(obj4)); QScriptValue obj6 = eng.newQObject(&qobj, QScriptEngine::ScriptOwnership, opt); QCOMPARE(obj6.strictlyEquals(obj5), preferExisting); QScriptValue obj7 = eng.newQObject(&qobj, QScriptEngine::ScriptOwnership, QScriptEngine::ExcludeSuperClassMethods | opt); QVERIFY(!obj7.strictlyEquals(obj6)); QScriptValue obj8 = eng.newQObject(&qobj, QScriptEngine::ScriptOwnership, QScriptEngine::ExcludeSuperClassMethods | opt); QCOMPARE(obj8.strictlyEquals(obj7), preferExisting); } } void tst_QScriptEngine::newQObject_defaultPrototype() { QScriptEngine eng; // newQObject() should set the default prototype, if one has been registered { QScriptValue oldQObjectProto = eng.defaultPrototype(qMetaTypeId()); QScriptValue qobjectProto = eng.newObject(); eng.setDefaultPrototype(qMetaTypeId(), qobjectProto); { QScriptValue ret = eng.newQObject(this); QVERIFY(ret.prototype().equals(qobjectProto)); } QScriptValue tstProto = eng.newObject(); int typeId = qRegisterMetaType("tst_QScriptEngine*"); eng.setDefaultPrototype(typeId, tstProto); { QScriptValue ret = eng.newQObject(this); QVERIFY(ret.prototype().equals(tstProto)); } eng.setDefaultPrototype(qMetaTypeId(), oldQObjectProto); eng.setDefaultPrototype(typeId, QScriptValue()); } } void tst_QScriptEngine::newQObject_promoteNonObject() { QScriptEngine eng; { QScriptValue ret = eng.newQObject(123, this); QVERIFY(ret.isQObject()); QCOMPARE(ret.toQObject(), this); } } void tst_QScriptEngine::newQObject_promoteNonQScriptObject() { QScriptEngine eng; { QTest::ignoreMessage(QtWarningMsg, "QScriptEngine::newQObject(): changing class of non-QScriptObject not supported"); QScriptValue ret = eng.newQObject(eng.newArray(), this); QVERIFY(!ret.isValid()); } } QT_BEGIN_NAMESPACE Q_SCRIPT_DECLARE_QMETAOBJECT(QObject, QObject*) Q_SCRIPT_DECLARE_QMETAOBJECT(QWidget, QWidget*) QT_END_NAMESPACE static QScriptValue myConstructor(QScriptContext *ctx, QScriptEngine *eng) { QScriptValue obj; if (ctx->isCalledAsConstructor()) { obj = ctx->thisObject(); } else { obj = eng->newObject(); obj.setPrototype(ctx->callee().property("prototype")); } obj.setProperty("isCalledAsConstructor", QScriptValue(eng, ctx->isCalledAsConstructor())); return obj; } static QScriptValue instanceofJS(const QScriptValue &inst, const QScriptValue &ctor) { return inst.engine()->evaluate("(function(inst, ctor) { return inst instanceof ctor; })") .call(QScriptValue(), QScriptValueList() << inst << ctor); } void tst_QScriptEngine::newQMetaObject() { QScriptEngine eng; #if 0 QScriptValue qclass = eng.newQMetaObject(); QScriptValue qclass2 = eng.newQMetaObject(); #else QScriptValue qclass = qScriptValueFromQMetaObject(&eng); QScriptValue qclass2 = qScriptValueFromQMetaObject(&eng); #endif QCOMPARE(qclass.isValid(), true); QCOMPARE(qclass.isQMetaObject(), true); QCOMPARE(qclass.toQMetaObject(), &QObject::staticMetaObject); QCOMPARE(qclass.isFunction(), true); QVERIFY(qclass.property("prototype").isObject()); QCOMPARE(qclass2.isValid(), true); QCOMPARE(qclass2.isQMetaObject(), true); QCOMPARE(qclass2.toQMetaObject(), &QWidget::staticMetaObject); QCOMPARE(qclass2.isFunction(), true); QVERIFY(qclass2.property("prototype").isObject()); // prototype should be QMetaObject.prototype QCOMPARE(qclass.prototype().isObject(), true); QCOMPARE(qclass2.prototype().isObject(), true); QScriptValue instance = qclass.construct(); QCOMPARE(instance.isQObject(), true); QCOMPARE(instance.toQObject()->metaObject(), qclass.toQMetaObject()); QVERIFY(instance.instanceOf(qclass)); QVERIFY(instanceofJS(instance, qclass).strictlyEquals(true)); QScriptValue instance2 = qclass2.construct(); QCOMPARE(instance2.isQObject(), true); QCOMPARE(instance2.toQObject()->metaObject(), qclass2.toQMetaObject()); QVERIFY(instance2.instanceOf(qclass2)); QVERIFY(instanceofJS(instance2, qclass2).strictlyEquals(true)); QVERIFY(!instance2.instanceOf(qclass)); QVERIFY(instanceofJS(instance2, qclass).strictlyEquals(false)); QScriptValueList args; args << instance; QScriptValue instance3 = qclass.construct(args); QCOMPARE(instance3.isQObject(), true); QCOMPARE(instance3.toQObject()->parent(), instance.toQObject()); QVERIFY(instance3.instanceOf(qclass)); QVERIFY(instanceofJS(instance3, qclass).strictlyEquals(true)); QVERIFY(!instance3.instanceOf(qclass2)); QVERIFY(instanceofJS(instance3, qclass2).strictlyEquals(false)); args.clear(); QPointer qpointer1 = instance.toQObject(); QPointer qpointer2 = instance2.toQObject(); QPointer qpointer3 = instance3.toQObject(); QVERIFY(qpointer1); QVERIFY(qpointer2); QVERIFY(qpointer3); // verify that AutoOwnership is in effect instance = QScriptValue(); collectGarbage_helper(eng); QVERIFY(!qpointer1); QVERIFY(qpointer2); QVERIFY(!qpointer3); // was child of instance QVERIFY(instance.toQObject() == 0); QVERIFY(instance3.toQObject() == 0); // was child of instance QVERIFY(instance2.toQObject() != 0); instance2 = QScriptValue(); collectGarbage_helper(eng); QVERIFY(instance2.toQObject() == 0); // with custom constructor QScriptValue ctor = eng.newFunction(myConstructor); QScriptValue qclass3 = eng.newQMetaObject(&QObject::staticMetaObject, ctor); QVERIFY(qclass3.property("prototype").equals(ctor.property("prototype"))); { QScriptValue ret = qclass3.call(); QVERIFY(ret.isObject()); QVERIFY(ret.property("isCalledAsConstructor").isBoolean()); QVERIFY(!ret.property("isCalledAsConstructor").toBoolean()); QVERIFY(ret.instanceOf(qclass3)); QVERIFY(instanceofJS(ret, qclass3).strictlyEquals(true)); QVERIFY(!ret.instanceOf(qclass)); QVERIFY(instanceofJS(ret, qclass).strictlyEquals(false)); } { QScriptValue ret = qclass3.construct(); QVERIFY(ret.isObject()); QVERIFY(ret.property("isCalledAsConstructor").isBoolean()); QVERIFY(ret.property("isCalledAsConstructor").toBoolean()); QVERIFY(ret.instanceOf(qclass3)); QVERIFY(instanceofJS(ret, qclass3).strictlyEquals(true)); QVERIFY(!ret.instanceOf(qclass2)); QVERIFY(instanceofJS(ret, qclass2).strictlyEquals(false)); } // subclassing qclass2.setProperty("prototype", qclass.construct()); QVERIFY(qclass2.construct().instanceOf(qclass)); QVERIFY(instanceofJS(qclass2.construct(), qclass).strictlyEquals(true)); // with meta-constructor QScriptValue qclass4 = eng.newQMetaObject(&QObject::staticMetaObject); { QScriptValue inst = qclass4.construct(); QVERIFY(inst.isQObject()); QVERIFY(inst.toQObject() != 0); QCOMPARE(inst.toQObject()->parent(), (QObject*)0); QVERIFY(inst.instanceOf(qclass4)); QVERIFY(instanceofJS(inst, qclass4).strictlyEquals(true)); QVERIFY(!inst.instanceOf(qclass3)); QVERIFY(instanceofJS(inst, qclass3).strictlyEquals(false)); } { QScriptValue inst = qclass4.construct(QScriptValueList() << eng.newQObject(this)); QVERIFY(inst.isQObject()); QVERIFY(inst.toQObject() != 0); QCOMPARE(inst.toQObject()->parent(), (QObject*)this); QVERIFY(inst.instanceOf(qclass4)); QVERIFY(instanceofJS(inst, qclass4).strictlyEquals(true)); QVERIFY(!inst.instanceOf(qclass2)); QVERIFY(instanceofJS(inst, qclass2).strictlyEquals(false)); } } void tst_QScriptEngine::newActivationObject() { QSKIP("internal function not implemented in JSC-based back-end", SkipAll); QScriptEngine eng; QScriptValue act = eng.newActivationObject(); QEXPECT_FAIL("", "", Continue); QCOMPARE(act.isValid(), true); QEXPECT_FAIL("", "", Continue); QCOMPARE(act.isObject(), true); QVERIFY(!act.isFunction()); QScriptValue v(&eng, 123); act.setProperty("prop", v); QEXPECT_FAIL("", "", Continue); QCOMPARE(act.property("prop").strictlyEquals(v), true); QCOMPARE(act.scope().isValid(), false); QEXPECT_FAIL("", "", Continue); QVERIFY(act.prototype().isNull()); } void tst_QScriptEngine::getSetGlobalObject() { QScriptEngine eng; QScriptValue glob = eng.globalObject(); QCOMPARE(glob.isValid(), true); QCOMPARE(glob.isObject(), true); QVERIFY(!glob.isFunction()); QVERIFY(eng.currentContext()->thisObject().strictlyEquals(glob)); QVERIFY(eng.currentContext()->activationObject().strictlyEquals(glob)); QCOMPARE(glob.toString(), QString::fromLatin1("[object global]")); // prototype should be Object.prototype QCOMPARE(glob.prototype().isValid(), true); QCOMPARE(glob.prototype().isObject(), true); QCOMPARE(glob.prototype().strictlyEquals(eng.evaluate("Object.prototype")), true); eng.setGlobalObject(glob); QVERIFY(eng.globalObject().equals(glob)); eng.setGlobalObject(123); QVERIFY(eng.globalObject().equals(glob)); QScriptValue obj = eng.newObject(); eng.setGlobalObject(obj); QVERIFY(eng.globalObject().strictlyEquals(obj)); QVERIFY(eng.currentContext()->thisObject().strictlyEquals(obj)); QVERIFY(eng.currentContext()->activationObject().strictlyEquals(obj)); QVERIFY(eng.evaluate("this").strictlyEquals(obj)); QCOMPARE(eng.globalObject().toString(), QString::fromLatin1("[object Object]")); glob = QScriptValue(); // kill reference to old global object collectGarbage_helper(eng); obj = eng.newObject(); eng.setGlobalObject(obj); QVERIFY(eng.globalObject().strictlyEquals(obj)); QVERIFY(eng.currentContext()->thisObject().strictlyEquals(obj)); QVERIFY(eng.currentContext()->activationObject().strictlyEquals(obj)); collectGarbage_helper(eng); QVERIFY(eng.globalObject().strictlyEquals(obj)); QVERIFY(eng.currentContext()->thisObject().strictlyEquals(obj)); QVERIFY(eng.currentContext()->activationObject().strictlyEquals(obj)); QVERIFY(!obj.property("foo").isValid()); eng.evaluate("var foo = 123"); { QScriptValue ret = obj.property("foo"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 123); } QVERIFY(!obj.property("bar").isValid()); eng.evaluate("bar = 456"); { QScriptValue ret = obj.property("bar"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 456); } QVERIFY(!obj.property("baz").isValid()); eng.evaluate("this['baz'] = 789"); { QScriptValue ret = obj.property("baz"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 789); } { QScriptValue ret = eng.evaluate("(function() { return this; })()"); QVERIFY(ret.strictlyEquals(obj)); } // Delete property. { QScriptValue ret = eng.evaluate("delete foo"); QVERIFY(ret.isBool()); QVERIFY(ret.toBool()); QVERIFY(!obj.property("foo").isValid()); } // Getter/setter property. QVERIFY(eng.evaluate("this.__defineGetter__('oof', function() { return this.bar; })").isUndefined()); QVERIFY(eng.evaluate("this.__defineSetter__('oof', function(v) { this.bar = v; })").isUndefined()); QVERIFY(eng.evaluate("this.__lookupGetter__('oof')").isFunction()); QVERIFY(eng.evaluate("this.__lookupSetter__('oof')").isFunction()); eng.evaluate("oof = 123"); QVERIFY(eng.evaluate("oof").equals(obj.property("bar"))); // Enumeration. { QScriptValue ret = eng.evaluate("a = []; for (var p in this) a.push(p); a"); QCOMPARE(ret.toString(), QString::fromLatin1("bar,baz,oof,p,a")); } } static QScriptValue getSetFoo(QScriptContext *ctx, QScriptEngine *) { if (ctx->argumentCount() > 0) ctx->thisObject().setProperty("foo", ctx->argument(0)); return ctx->thisObject().property("foo"); } void tst_QScriptEngine::globalObjectProperties() { // See ECMA-262 Section 15.1, "The Global Object". QScriptEngine eng; QScriptValue global = eng.globalObject(); QVERIFY(global.property("NaN").isNumber()); QVERIFY(qIsNaN(global.property("NaN").toNumber())); QCOMPARE(global.propertyFlags("NaN"), QScriptValue::SkipInEnumeration | QScriptValue::Undeletable); QVERIFY(global.property("Infinity").isNumber()); QVERIFY(qIsInf(global.property("Infinity").toNumber())); QCOMPARE(global.propertyFlags("NaN"), QScriptValue::SkipInEnumeration | QScriptValue::Undeletable); QVERIFY(global.property("undefined").isUndefined()); QCOMPARE(global.propertyFlags("undefined"), QScriptValue::SkipInEnumeration | QScriptValue::Undeletable); QVERIFY(global.property("eval").isFunction()); QCOMPARE(global.propertyFlags("eval"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("parseInt").isFunction()); QCOMPARE(global.propertyFlags("parseInt"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("parseFloat").isFunction()); QCOMPARE(global.propertyFlags("parseFloat"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("isNaN").isFunction()); QCOMPARE(global.propertyFlags("isNaN"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("isFinite").isFunction()); QCOMPARE(global.propertyFlags("isFinite"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("decodeURI").isFunction()); QCOMPARE(global.propertyFlags("decodeURI"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("decodeURIComponent").isFunction()); QCOMPARE(global.propertyFlags("decodeURIComponent"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("encodeURI").isFunction()); QCOMPARE(global.propertyFlags("encodeURI"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("encodeURIComponent").isFunction()); QCOMPARE(global.propertyFlags("encodeURIComponent"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("Object").isFunction()); QCOMPARE(global.propertyFlags("Object"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("Function").isFunction()); QCOMPARE(global.propertyFlags("Function"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("Array").isFunction()); QCOMPARE(global.propertyFlags("Array"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("String").isFunction()); QCOMPARE(global.propertyFlags("String"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("Boolean").isFunction()); QCOMPARE(global.propertyFlags("Boolean"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("Number").isFunction()); QCOMPARE(global.propertyFlags("Number"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("Date").isFunction()); QCOMPARE(global.propertyFlags("Date"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("RegExp").isFunction()); QCOMPARE(global.propertyFlags("RegExp"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("Error").isFunction()); QCOMPARE(global.propertyFlags("Error"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("EvalError").isFunction()); QCOMPARE(global.propertyFlags("EvalError"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("RangeError").isFunction()); QCOMPARE(global.propertyFlags("RangeError"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("ReferenceError").isFunction()); QCOMPARE(global.propertyFlags("ReferenceError"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("SyntaxError").isFunction()); QCOMPARE(global.propertyFlags("SyntaxError"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("TypeError").isFunction()); QCOMPARE(global.propertyFlags("TypeError"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("URIError").isFunction()); QCOMPARE(global.propertyFlags("URIError"), QScriptValue::SkipInEnumeration); QVERIFY(global.property("Math").isObject()); QVERIFY(!global.property("Math").isFunction()); QEXPECT_FAIL("", "[ECMA compliance] JSC sets DontDelete flag for Math object: https://bugs.webkit.org/show_bug.cgi?id=55034", Continue); QCOMPARE(global.propertyFlags("Math"), QScriptValue::SkipInEnumeration); } void tst_QScriptEngine::globalObjectProperties_enumerate() { QScriptEngine eng; QScriptValue global = eng.globalObject(); QSet expectedNames; expectedNames << "isNaN" << "parseFloat" << "String" << "EvalError" << "URIError" << "Math" << "encodeURIComponent" << "RangeError" << "eval" << "isFinite" << "ReferenceError" << "Infinity" << "Function" << "RegExp" << "Number" << "parseInt" << "Object" << "decodeURI" << "TypeError" << "Boolean" << "encodeURI" << "NaN" << "Error" << "decodeURIComponent" << "Date" << "Array" << "escape" << "unescape" << "SyntaxError" << "undefined" // non-standard << "gc" << "version" << "print" // JavaScriptCore << "JSON" ; QSet actualNames; { QScriptValueIterator it(global); while (it.hasNext()) { it.next(); actualNames.insert(it.name()); } } QSet remainingNames = actualNames; { QSet::const_iterator it; for (it = expectedNames.constBegin(); it != expectedNames.constEnd(); ++it) { QString name = *it; QVERIFY(actualNames.contains(name)); remainingNames.remove(name); } } QVERIFY(remainingNames.isEmpty()); } void tst_QScriptEngine::createGlobalObjectProperty() { QScriptEngine eng; QScriptValue global = eng.globalObject(); // create property with no attributes { QString name = QString::fromLatin1("foo"); QVERIFY(!global.property(name).isValid()); QScriptValue val(123); global.setProperty(name, val); QVERIFY(global.property(name).equals(val)); QVERIFY(global.propertyFlags(name) == 0); global.setProperty(name, QScriptValue()); QVERIFY(!global.property(name).isValid()); } // create property with attributes { QString name = QString::fromLatin1("bar"); QVERIFY(!global.property(name).isValid()); QScriptValue val(QString::fromLatin1("ciao")); QScriptValue::PropertyFlags flags = QScriptValue::ReadOnly | QScriptValue::SkipInEnumeration; global.setProperty(name, val, flags); QVERIFY(global.property(name).equals(val)); QEXPECT_FAIL("", "QTBUG-6134: custom Global Object properties don't retain attributes", Continue); QCOMPARE(global.propertyFlags(name), flags); global.setProperty(name, QScriptValue()); QVERIFY(!global.property(name).isValid()); } } void tst_QScriptEngine::globalObjectGetterSetterProperty() { QScriptEngine engine; QScriptValue global = engine.globalObject(); global.setProperty("bar", engine.newFunction(getSetFoo), QScriptValue::PropertySetter | QScriptValue::PropertyGetter); global.setProperty("foo", 123); QVERIFY(global.property("bar").equals(global.property("foo"))); QVERIFY(engine.evaluate("bar").equals(global.property("foo"))); global.setProperty("bar", 456); QVERIFY(global.property("bar").equals(global.property("foo"))); engine.evaluate("__defineGetter__('baz', function() { return 789; })"); QVERIFY(engine.evaluate("baz").equals(789)); QVERIFY(global.property("baz").equals(789)); } void tst_QScriptEngine::customGlobalObjectWithPrototype() { for (int x = 0; x < 2; ++x) { QScriptEngine engine; QScriptValue wrap = engine.newObject(); QScriptValue global = engine.globalObject(); QScriptValue originalGlobalProto = global.prototype(); if (!x) { // Set prototype before setting global object wrap.setPrototype(global); QVERIFY(wrap.prototype().strictlyEquals(global)); engine.setGlobalObject(wrap); } else { // Set prototype after setting global object engine.setGlobalObject(wrap); wrap.setPrototype(global); QVERIFY(wrap.prototype().strictlyEquals(global)); } { QScriptValue ret = engine.evaluate("print"); QVERIFY(ret.isFunction()); QVERIFY(ret.strictlyEquals(wrap.property("print"))); } { QScriptValue ret = engine.evaluate("this.print"); QVERIFY(ret.isFunction()); QVERIFY(ret.strictlyEquals(wrap.property("print"))); } { QScriptValue ret = engine.evaluate("hasOwnProperty('print')"); QVERIFY(ret.isBool()); QVERIFY(!ret.toBool()); } { QScriptValue ret = engine.evaluate("this.hasOwnProperty('print')"); QVERIFY(ret.isBool()); QVERIFY(!ret.toBool()); } QScriptValue anotherProto = engine.newObject(); anotherProto.setProperty("anotherProtoProperty", 123); global.setPrototype(anotherProto); { QScriptValue ret = engine.evaluate("print"); QVERIFY(ret.isFunction()); QVERIFY(ret.strictlyEquals(wrap.property("print"))); } { QScriptValue ret = engine.evaluate("anotherProtoProperty"); QVERIFY(ret.isNumber()); QVERIFY(ret.strictlyEquals(wrap.property("anotherProtoProperty"))); } { QScriptValue ret = engine.evaluate("this.anotherProtoProperty"); QVERIFY(ret.isNumber()); QVERIFY(ret.strictlyEquals(wrap.property("anotherProtoProperty"))); } wrap.setPrototype(anotherProto); { QScriptValue ret = engine.evaluate("print"); QVERIFY(ret.isError()); QCOMPARE(ret.toString(), QString::fromLatin1("ReferenceError: Can't find variable: print")); } { QScriptValue ret = engine.evaluate("anotherProtoProperty"); QVERIFY(ret.isNumber()); QVERIFY(ret.strictlyEquals(wrap.property("anotherProtoProperty"))); } QVERIFY(global.prototype().strictlyEquals(anotherProto)); global.setPrototype(originalGlobalProto); engine.setGlobalObject(global); { QScriptValue ret = engine.evaluate("anotherProtoProperty"); QVERIFY(ret.isError()); QCOMPARE(ret.toString(), QString::fromLatin1("ReferenceError: Can't find variable: anotherProtoProperty")); } { QScriptValue ret = engine.evaluate("print"); QVERIFY(ret.isFunction()); QVERIFY(ret.strictlyEquals(global.property("print"))); } QVERIFY(!anotherProto.property("print").isValid()); } } void tst_QScriptEngine::globalObjectWithCustomPrototype() { QScriptEngine engine; QScriptValue proto = engine.newObject(); proto.setProperty("protoProperty", 123); QScriptValue global = engine.globalObject(); QScriptValue originalProto = global.prototype(); global.setPrototype(proto); { QScriptValue ret = engine.evaluate("protoProperty"); QVERIFY(ret.isNumber()); QVERIFY(ret.strictlyEquals(global.property("protoProperty"))); } { QScriptValue ret = engine.evaluate("this.protoProperty"); QVERIFY(ret.isNumber()); QVERIFY(ret.strictlyEquals(global.property("protoProperty"))); } { QScriptValue ret = engine.evaluate("hasOwnProperty('protoProperty')"); QVERIFY(ret.isBool()); QVERIFY(!ret.toBool()); } { QScriptValue ret = engine.evaluate("this.hasOwnProperty('protoProperty')"); QVERIFY(ret.isBool()); QVERIFY(!ret.toBool()); } // Custom prototype set from JS { QScriptValue ret = engine.evaluate("this.__proto__ = { 'a': 123 }; a"); QVERIFY(ret.isNumber()); QEXPECT_FAIL("", "QTBUG-9737: Prototype change in JS not reflected on C++ side", Continue); QVERIFY(ret.strictlyEquals(global.property("a"))); } } void tst_QScriptEngine::builtinFunctionNames_data() { QTest::addColumn("expression"); QTest::addColumn("expectedName"); // See ECMA-262 Chapter 15, "Standard Built-in ECMAScript Objects". QTest::newRow("print") << QString("print") << QString("print"); // QtScript extension. QTest::newRow("parseInt") << QString("parseInt") << QString("parseInt"); QTest::newRow("parseFloat") << QString("parseFloat") << QString("parseFloat"); QTest::newRow("isNaN") << QString("isNaN") << QString("isNaN"); QTest::newRow("isFinite") << QString("isFinite") << QString("isFinite"); QTest::newRow("decodeURI") << QString("decodeURI") << QString("decodeURI"); QTest::newRow("decodeURIComponent") << QString("decodeURIComponent") << QString("decodeURIComponent"); QTest::newRow("encodeURI") << QString("encodeURI") << QString("encodeURI"); QTest::newRow("encodeURIComponent") << QString("encodeURIComponent") << QString("encodeURIComponent"); QTest::newRow("escape") << QString("escape") << QString("escape"); QTest::newRow("unescape") << QString("unescape") << QString("unescape"); QTest::newRow("version") << QString("version") << QString("version"); // QtScript extension. QTest::newRow("gc") << QString("gc") << QString("gc"); // QtScript extension. QTest::newRow("Array") << QString("Array") << QString("Array"); QTest::newRow("Array.prototype.toString") << QString("Array.prototype.toString") << QString("toString"); QTest::newRow("Array.prototype.toLocaleString") << QString("Array.prototype.toLocaleString") << QString("toLocaleString"); QTest::newRow("Array.prototype.concat") << QString("Array.prototype.concat") << QString("concat"); QTest::newRow("Array.prototype.join") << QString("Array.prototype.join") << QString("join"); QTest::newRow("Array.prototype.pop") << QString("Array.prototype.pop") << QString("pop"); QTest::newRow("Array.prototype.push") << QString("Array.prototype.push") << QString("push"); QTest::newRow("Array.prototype.reverse") << QString("Array.prototype.reverse") << QString("reverse"); QTest::newRow("Array.prototype.shift") << QString("Array.prototype.shift") << QString("shift"); QTest::newRow("Array.prototype.slice") << QString("Array.prototype.slice") << QString("slice"); QTest::newRow("Array.prototype.sort") << QString("Array.prototype.sort") << QString("sort"); QTest::newRow("Array.prototype.splice") << QString("Array.prototype.splice") << QString("splice"); QTest::newRow("Array.prototype.unshift") << QString("Array.prototype.unshift") << QString("unshift"); QTest::newRow("Boolean") << QString("Boolean") << QString("Boolean"); QTest::newRow("Boolean.prototype.toString") << QString("Boolean.prototype.toString") << QString("toString"); QTest::newRow("Date") << QString("Date") << QString("Date"); QTest::newRow("Date.prototype.toString") << QString("Date.prototype.toString") << QString("toString"); QTest::newRow("Date.prototype.toDateString") << QString("Date.prototype.toDateString") << QString("toDateString"); QTest::newRow("Date.prototype.toTimeString") << QString("Date.prototype.toTimeString") << QString("toTimeString"); QTest::newRow("Date.prototype.toLocaleString") << QString("Date.prototype.toLocaleString") << QString("toLocaleString"); QTest::newRow("Date.prototype.toLocaleDateString") << QString("Date.prototype.toLocaleDateString") << QString("toLocaleDateString"); QTest::newRow("Date.prototype.toLocaleTimeString") << QString("Date.prototype.toLocaleTimeString") << QString("toLocaleTimeString"); QTest::newRow("Date.prototype.valueOf") << QString("Date.prototype.valueOf") << QString("valueOf"); QTest::newRow("Date.prototype.getTime") << QString("Date.prototype.getTime") << QString("getTime"); QTest::newRow("Date.prototype.getYear") << QString("Date.prototype.getYear") << QString("getYear"); QTest::newRow("Date.prototype.getFullYear") << QString("Date.prototype.getFullYear") << QString("getFullYear"); QTest::newRow("Date.prototype.getUTCFullYear") << QString("Date.prototype.getUTCFullYear") << QString("getUTCFullYear"); QTest::newRow("Date.prototype.getMonth") << QString("Date.prototype.getMonth") << QString("getMonth"); QTest::newRow("Date.prototype.getUTCMonth") << QString("Date.prototype.getUTCMonth") << QString("getUTCMonth"); QTest::newRow("Date.prototype.getDate") << QString("Date.prototype.getDate") << QString("getDate"); QTest::newRow("Date.prototype.getUTCDate") << QString("Date.prototype.getUTCDate") << QString("getUTCDate"); QTest::newRow("Date.prototype.getDay") << QString("Date.prototype.getDay") << QString("getDay"); QTest::newRow("Date.prototype.getUTCDay") << QString("Date.prototype.getUTCDay") << QString("getUTCDay"); QTest::newRow("Date.prototype.getHours") << QString("Date.prototype.getHours") << QString("getHours"); QTest::newRow("Date.prototype.getUTCHours") << QString("Date.prototype.getUTCHours") << QString("getUTCHours"); QTest::newRow("Date.prototype.getMinutes") << QString("Date.prototype.getMinutes") << QString("getMinutes"); QTest::newRow("Date.prototype.getUTCMinutes") << QString("Date.prototype.getUTCMinutes") << QString("getUTCMinutes"); QTest::newRow("Date.prototype.getSeconds") << QString("Date.prototype.getSeconds") << QString("getSeconds"); QTest::newRow("Date.prototype.getUTCSeconds") << QString("Date.prototype.getUTCSeconds") << QString("getUTCSeconds"); QTest::newRow("Date.prototype.getMilliseconds") << QString("Date.prototype.getMilliseconds") << QString("getMilliseconds"); QTest::newRow("Date.prototype.getUTCMilliseconds") << QString("Date.prototype.getUTCMilliseconds") << QString("getUTCMilliseconds"); QTest::newRow("Date.prototype.getTimezoneOffset") << QString("Date.prototype.getTimezoneOffset") << QString("getTimezoneOffset"); QTest::newRow("Date.prototype.setTime") << QString("Date.prototype.setTime") << QString("setTime"); QTest::newRow("Date.prototype.setMilliseconds") << QString("Date.prototype.setMilliseconds") << QString("setMilliseconds"); QTest::newRow("Date.prototype.setUTCMilliseconds") << QString("Date.prototype.setUTCMilliseconds") << QString("setUTCMilliseconds"); QTest::newRow("Date.prototype.setSeconds") << QString("Date.prototype.setSeconds") << QString("setSeconds"); QTest::newRow("Date.prototype.setUTCSeconds") << QString("Date.prototype.setUTCSeconds") << QString("setUTCSeconds"); QTest::newRow("Date.prototype.setMinutes") << QString("Date.prototype.setMinutes") << QString("setMinutes"); QTest::newRow("Date.prototype.setUTCMinutes") << QString("Date.prototype.setUTCMinutes") << QString("setUTCMinutes"); QTest::newRow("Date.prototype.setHours") << QString("Date.prototype.setHours") << QString("setHours"); QTest::newRow("Date.prototype.setUTCHours") << QString("Date.prototype.setUTCHours") << QString("setUTCHours"); QTest::newRow("Date.prototype.setDate") << QString("Date.prototype.setDate") << QString("setDate"); QTest::newRow("Date.prototype.setUTCDate") << QString("Date.prototype.setUTCDate") << QString("setUTCDate"); QTest::newRow("Date.prototype.setMonth") << QString("Date.prototype.setMonth") << QString("setMonth"); QTest::newRow("Date.prototype.setUTCMonth") << QString("Date.prototype.setUTCMonth") << QString("setUTCMonth"); QTest::newRow("Date.prototype.setYear") << QString("Date.prototype.setYear") << QString("setYear"); QTest::newRow("Date.prototype.setFullYear") << QString("Date.prototype.setFullYear") << QString("setFullYear"); QTest::newRow("Date.prototype.setUTCFullYear") << QString("Date.prototype.setUTCFullYear") << QString("setUTCFullYear"); QTest::newRow("Date.prototype.toUTCString") << QString("Date.prototype.toUTCString") << QString("toUTCString"); QTest::newRow("Date.prototype.toGMTString") << QString("Date.prototype.toGMTString") << QString("toGMTString"); QTest::newRow("Error") << QString("Error") << QString("Error"); // QTest::newRow("Error.prototype.backtrace") << QString("Error.prototype.backtrace") << QString("backtrace"); QTest::newRow("Error.prototype.toString") << QString("Error.prototype.toString") << QString("toString"); QTest::newRow("EvalError") << QString("EvalError") << QString("EvalError"); QTest::newRow("RangeError") << QString("RangeError") << QString("RangeError"); QTest::newRow("ReferenceError") << QString("ReferenceError") << QString("ReferenceError"); QTest::newRow("SyntaxError") << QString("SyntaxError") << QString("SyntaxError"); QTest::newRow("TypeError") << QString("TypeError") << QString("TypeError"); QTest::newRow("URIError") << QString("URIError") << QString("URIError"); QTest::newRow("Function") << QString("Function") << QString("Function"); QTest::newRow("Function.prototype.toString") << QString("Function.prototype.toString") << QString("toString"); QTest::newRow("Function.prototype.apply") << QString("Function.prototype.apply") << QString("apply"); QTest::newRow("Function.prototype.call") << QString("Function.prototype.call") << QString("call"); QTest::newRow("Function.prototype.connect") << QString("Function.prototype.connect") << QString("connect"); QTest::newRow("Function.prototype.disconnect") << QString("Function.prototype.disconnect") << QString("disconnect"); QTest::newRow("Math.abs") << QString("Math.abs") << QString("abs"); QTest::newRow("Math.acos") << QString("Math.acos") << QString("acos"); QTest::newRow("Math.asin") << QString("Math.asin") << QString("asin"); QTest::newRow("Math.atan") << QString("Math.atan") << QString("atan"); QTest::newRow("Math.atan2") << QString("Math.atan2") << QString("atan2"); QTest::newRow("Math.ceil") << QString("Math.ceil") << QString("ceil"); QTest::newRow("Math.cos") << QString("Math.cos") << QString("cos"); QTest::newRow("Math.exp") << QString("Math.exp") << QString("exp"); QTest::newRow("Math.floor") << QString("Math.floor") << QString("floor"); QTest::newRow("Math.log") << QString("Math.log") << QString("log"); QTest::newRow("Math.max") << QString("Math.max") << QString("max"); QTest::newRow("Math.min") << QString("Math.min") << QString("min"); QTest::newRow("Math.pow") << QString("Math.pow") << QString("pow"); QTest::newRow("Math.random") << QString("Math.random") << QString("random"); QTest::newRow("Math.round") << QString("Math.round") << QString("round"); QTest::newRow("Math.sin") << QString("Math.sin") << QString("sin"); QTest::newRow("Math.sqrt") << QString("Math.sqrt") << QString("sqrt"); QTest::newRow("Math.tan") << QString("Math.tan") << QString("tan"); QTest::newRow("Number") << QString("Number") << QString("Number"); QTest::newRow("Number.prototype.toString") << QString("Number.prototype.toString") << QString("toString"); QTest::newRow("Number.prototype.toLocaleString") << QString("Number.prototype.toLocaleString") << QString("toLocaleString"); QTest::newRow("Number.prototype.valueOf") << QString("Number.prototype.valueOf") << QString("valueOf"); QTest::newRow("Number.prototype.toFixed") << QString("Number.prototype.toFixed") << QString("toFixed"); QTest::newRow("Number.prototype.toExponential") << QString("Number.prototype.toExponential") << QString("toExponential"); QTest::newRow("Number.prototype.toPrecision") << QString("Number.prototype.toPrecision") << QString("toPrecision"); QTest::newRow("Object") << QString("Object") << QString("Object"); QTest::newRow("Object.prototype.toString") << QString("Object.prototype.toString") << QString("toString"); QTest::newRow("Object.prototype.toLocaleString") << QString("Object.prototype.toLocaleString") << QString("toLocaleString"); QTest::newRow("Object.prototype.valueOf") << QString("Object.prototype.valueOf") << QString("valueOf"); QTest::newRow("Object.prototype.hasOwnProperty") << QString("Object.prototype.hasOwnProperty") << QString("hasOwnProperty"); QTest::newRow("Object.prototype.isPrototypeOf") << QString("Object.prototype.isPrototypeOf") << QString("isPrototypeOf"); QTest::newRow("Object.prototype.propertyIsEnumerable") << QString("Object.prototype.propertyIsEnumerable") << QString("propertyIsEnumerable"); QTest::newRow("Object.prototype.__defineGetter__") << QString("Object.prototype.__defineGetter__") << QString("__defineGetter__"); QTest::newRow("Object.prototype.__defineSetter__") << QString("Object.prototype.__defineSetter__") << QString("__defineSetter__"); QTest::newRow("RegExp") << QString("RegExp") << QString("RegExp"); QTest::newRow("RegExp.prototype.exec") << QString("RegExp.prototype.exec") << QString("exec"); QTest::newRow("RegExp.prototype.test") << QString("RegExp.prototype.test") << QString("test"); QTest::newRow("RegExp.prototype.toString") << QString("RegExp.prototype.toString") << QString("toString"); QTest::newRow("String") << QString("String") << QString("String"); QTest::newRow("String.prototype.toString") << QString("String.prototype.toString") << QString("toString"); QTest::newRow("String.prototype.valueOf") << QString("String.prototype.valueOf") << QString("valueOf"); QTest::newRow("String.prototype.charAt") << QString("String.prototype.charAt") << QString("charAt"); QTest::newRow("String.prototype.charCodeAt") << QString("String.prototype.charCodeAt") << QString("charCodeAt"); QTest::newRow("String.prototype.concat") << QString("String.prototype.concat") << QString("concat"); QTest::newRow("String.prototype.indexOf") << QString("String.prototype.indexOf") << QString("indexOf"); QTest::newRow("String.prototype.lastIndexOf") << QString("String.prototype.lastIndexOf") << QString("lastIndexOf"); QTest::newRow("String.prototype.localeCompare") << QString("String.prototype.localeCompare") << QString("localeCompare"); QTest::newRow("String.prototype.match") << QString("String.prototype.match") << QString("match"); QTest::newRow("String.prototype.replace") << QString("String.prototype.replace") << QString("replace"); QTest::newRow("String.prototype.search") << QString("String.prototype.search") << QString("search"); QTest::newRow("String.prototype.slice") << QString("String.prototype.slice") << QString("slice"); QTest::newRow("String.prototype.split") << QString("String.prototype.split") << QString("split"); QTest::newRow("String.prototype.substring") << QString("String.prototype.substring") << QString("substring"); QTest::newRow("String.prototype.toLowerCase") << QString("String.prototype.toLowerCase") << QString("toLowerCase"); QTest::newRow("String.prototype.toLocaleLowerCase") << QString("String.prototype.toLocaleLowerCase") << QString("toLocaleLowerCase"); QTest::newRow("String.prototype.toUpperCase") << QString("String.prototype.toUpperCase") << QString("toUpperCase"); QTest::newRow("String.prototype.toLocaleUpperCase") << QString("String.prototype.toLocaleUpperCase") << QString("toLocaleUpperCase"); } void tst_QScriptEngine::builtinFunctionNames() { QFETCH(QString, expression); QFETCH(QString, expectedName); QScriptEngine eng; // The "name" property is actually non-standard, but JSC supports it. QScriptValue ret = eng.evaluate(QString::fromLatin1("%0.name").arg(expression)); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), expectedName); } void tst_QScriptEngine::checkSyntax_data() { QTest::addColumn("code"); QTest::addColumn("expectedState"); QTest::addColumn("errorLineNumber"); QTest::addColumn("errorColumnNumber"); QTest::addColumn("errorMessage"); QTest::newRow("0") << QString("0") << int(QScriptSyntaxCheckResult::Valid) << -1 << -1 << ""; QTest::newRow("if (") << QString("if (\n") << int(QScriptSyntaxCheckResult::Intermediate) << 1 << 4 << ""; QTest::newRow("if else") << QString("\nif else") << int(QScriptSyntaxCheckResult::Error) << 2 << 4 << "Expected `('"; QTest::newRow("foo[") << QString("foo[") << int(QScriptSyntaxCheckResult::Error) << 1 << 4 << ""; QTest::newRow("foo['bar']") << QString("foo['bar']") << int(QScriptSyntaxCheckResult::Valid) << -1 << -1 << ""; QTest::newRow("/*") << QString("/*") << int(QScriptSyntaxCheckResult::Intermediate) << 1 << 1 << "Unclosed comment at end of file"; QTest::newRow("/*\nMy comment") << QString("/*\nMy comment") << int(QScriptSyntaxCheckResult::Intermediate) << 1 << 1 << "Unclosed comment at end of file"; QTest::newRow("/*\nMy comment */\nfoo = 10") << QString("/*\nMy comment */\nfoo = 10") << int(QScriptSyntaxCheckResult::Valid) << -1 << -1 << ""; QTest::newRow("foo = 10 /*") << QString("foo = 10 /*") << int(QScriptSyntaxCheckResult::Intermediate) << -1 << -1 << ""; QTest::newRow("foo = 10; /*") << QString("foo = 10; /*") << int(QScriptSyntaxCheckResult::Intermediate) << 1 << 11 << "Expected `end of file'"; QTest::newRow("foo = 10 /* My comment */") << QString("foo = 10 /* My comment */") << int(QScriptSyntaxCheckResult::Valid) << -1 << -1 << ""; QTest::newRow("/=/") << QString("/=/") << int(QScriptSyntaxCheckResult::Valid) << -1 << -1 << ""; QTest::newRow("/=/g") << QString("/=/g") << int(QScriptSyntaxCheckResult::Valid) << -1 << -1 << ""; QTest::newRow("/a/") << QString("/a/") << int(QScriptSyntaxCheckResult::Valid) << -1 << -1 << ""; QTest::newRow("/a/g") << QString("/a/g") << int(QScriptSyntaxCheckResult::Valid) << -1 << -1 << ""; } void tst_QScriptEngine::checkSyntax() { QFETCH(QString, code); QFETCH(int, expectedState); QFETCH(int, errorLineNumber); QFETCH(int, errorColumnNumber); QFETCH(QString, errorMessage); QScriptSyntaxCheckResult result = QScriptEngine::checkSyntax(code); QCOMPARE(result.state(), QScriptSyntaxCheckResult::State(expectedState)); QCOMPARE(result.errorLineNumber(), errorLineNumber); QCOMPARE(result.errorColumnNumber(), errorColumnNumber); QCOMPARE(result.errorMessage(), errorMessage); // assignment { QScriptSyntaxCheckResult copy = result; QCOMPARE(copy.state(), result.state()); QCOMPARE(copy.errorLineNumber(), result.errorLineNumber()); QCOMPARE(copy.errorColumnNumber(), result.errorColumnNumber()); QCOMPARE(copy.errorMessage(), result.errorMessage()); } { QScriptSyntaxCheckResult copy(result); QCOMPARE(copy.state(), result.state()); QCOMPARE(copy.errorLineNumber(), result.errorLineNumber()); QCOMPARE(copy.errorColumnNumber(), result.errorColumnNumber()); QCOMPARE(copy.errorMessage(), result.errorMessage()); } } void tst_QScriptEngine::canEvaluate_data() { QTest::addColumn("code"); QTest::addColumn("expectSuccess"); QTest::newRow("") << QString("") << true; QTest::newRow("0") << QString("0") << true; QTest::newRow("!") << QString("!\n") << false; QTest::newRow("if (") << QString("if (\n") << false; QTest::newRow("if (10) //") << QString("if (10) //\n") << false; QTest::newRow("a = 1; if (") << QString("a = 1;\nif (\n") << false; QTest::newRow("./test.js") << QString("./test.js\n") << true; QTest::newRow("if (0) print(1)") << QString("if (0)\nprint(1)\n") << true; QTest::newRow("0 = ") << QString("0 = \n") << false; QTest::newRow("0 = 0") << QString("0 = 0\n") << true; QTest::newRow("foo[") << QString("foo[") << true; // automatic semicolon will be inserted QTest::newRow("foo[") << QString("foo[\n") << false; QTest::newRow("foo['bar']") << QString("foo['bar']") << true; QTest::newRow("/*") << QString("/*") << false; QTest::newRow("/*\nMy comment") << QString("/*\nMy comment") << false; QTest::newRow("/*\nMy comment */\nfoo = 10") << QString("/*\nMy comment */\nfoo = 10") << true; QTest::newRow("foo = 10 /*") << QString("foo = 10 /*") << false; QTest::newRow("foo = 10; /*") << QString("foo = 10; /*") << false; QTest::newRow("foo = 10 /* My comment */") << QString("foo = 10 /* My comment */") << true; QTest::newRow("/=/") << QString("/=/") << true; QTest::newRow("/=/g") << QString("/=/g") << true; QTest::newRow("/a/") << QString("/a/") << true; QTest::newRow("/a/g") << QString("/a/g") << true; } void tst_QScriptEngine::canEvaluate() { QFETCH(QString, code); QFETCH(bool, expectSuccess); QScriptEngine eng; QCOMPARE(eng.canEvaluate(code), expectSuccess); } void tst_QScriptEngine::evaluate_data() { QTest::addColumn("code"); QTest::addColumn("lineNumber"); QTest::addColumn("expectHadError"); QTest::addColumn("expectErrorLineNumber"); QTest::newRow("(newline)") << QString("\n") << -1 << false << -1; QTest::newRow("0 //") << QString("0 //") << -1 << false << -1; QTest::newRow("/* */") << QString("/* */") << -1 << false << -1; QTest::newRow("//") << QString("//") << -1 << false << -1; QTest::newRow("(spaces)") << QString(" ") << -1 << false << -1; QTest::newRow("(empty)") << QString("") << -1 << false << -1; QTest::newRow("0") << QString("0") << -1 << false << -1; QTest::newRow("0=1") << QString("\n0=1;\n") << -1 << true << 2; QTest::newRow("a=1") << QString("a=1\n") << -1 << false << -1; QTest::newRow("a=1;K") << QString("a=1;\nK") << -1 << true << 2; QTest::newRow("f()") << QString("function f()\n" "{\n" " var a;\n" " var b=\";\n" // here's the error "}\n" "f();\n") << -1 << true << 4; QTest::newRow("0") << QString("0") << 10 << false << -1; QTest::newRow("0=1") << QString("\n\n0=1\n") << 10 << true << 13; QTest::newRow("a=1") << QString("a=1\n") << 10 << false << -1; QTest::newRow("a=1;K") << QString("a=1;\n\nK") << 10 << true << 12; QTest::newRow("f()") << QString("function f()\n" "{\n" " var a;\n" "\n\n" " var b=\";\n" // here's the error "}\n" "f();\n") << 10 << true << 15; QTest::newRow("functionThatDoesntExist()") << QString(";\n;\n;\nfunctionThatDoesntExist()") << -1 << true << 4; QTest::newRow("for (var p in this) { continue labelThatDoesntExist; }") << QString("for (var p in this) {\ncontinue labelThatDoesntExist; }") << 4 << true << 5; QTest::newRow("duplicateLabel: { duplicateLabel: ; }") << QString("duplicateLabel: { duplicateLabel: ; }") << 12 << true << 12; QTest::newRow("/=/") << QString("/=/") << -1 << false << -1; QTest::newRow("/=/g") << QString("/=/g") << -1 << false << -1; QTest::newRow("/a/") << QString("/a/") << -1 << false << -1; QTest::newRow("/a/g") << QString("/a/g") << -1 << false << -1; QTest::newRow("/a/gim") << QString("/a/gim") << -1 << false << -1; QTest::newRow("/a/gimp") << QString("/a/gimp") << 1 << true << 1; } void tst_QScriptEngine::evaluate() { QFETCH(QString, code); QFETCH(int, lineNumber); QFETCH(bool, expectHadError); QFETCH(int, expectErrorLineNumber); QScriptEngine eng; QScriptValue ret; if (lineNumber != -1) ret = eng.evaluate(code, /*fileName =*/QString(), lineNumber); else ret = eng.evaluate(code); QCOMPARE(eng.hasUncaughtException(), expectHadError); QCOMPARE(eng.uncaughtExceptionLineNumber(), expectErrorLineNumber); if (eng.hasUncaughtException() && ret.isError()) QVERIFY(ret.property("lineNumber").strictlyEquals(QScriptValue(&eng, expectErrorLineNumber))); else QVERIFY(eng.uncaughtExceptionBacktrace().isEmpty()); } static QScriptValue eval_nested(QScriptContext *ctx, QScriptEngine *eng) { QScriptValue result = eng->newObject(); eng->evaluate("var bar = 'local';"); result.setProperty("thisObjectIdBefore", ctx->thisObject().property("id")); QScriptValue evaluatedThisObject = eng->evaluate("this"); result.setProperty("thisObjectIdAfter", ctx->thisObject().property("id")); result.setProperty("evaluatedThisObjectId", evaluatedThisObject.property("id")); result.setProperty("local_bar", eng->evaluate("bar")); return result; } // Tests that nested evaluate uses the "this" that was passed. void tst_QScriptEngine::nestedEvaluate() { QScriptEngine eng; QScriptValue fun = eng.newFunction(eval_nested); eng.globalObject().setProperty("fun", fun); // From JS function call { QScriptValue result = eng.evaluate("o = { id:'foo'}; o.fun = fun; o.fun()"); QCOMPARE(result.property("local_bar").toString(), QString("local")); QCOMPARE(result.property("thisObjectIdBefore").toString(), QString("foo")); QCOMPARE(result.property("thisObjectIdAfter").toString(), QString("foo")); QCOMPARE(result.property("evaluatedThisObjectId").toString(), QString("foo")); QScriptValue bar = eng.evaluate("bar"); // Was introduced in local scope. QVERIFY(bar.isError()); QVERIFY(bar.toString().contains(QString::fromLatin1("ReferenceError"))); } // From QScriptValue::call() { QScriptValue result = fun.call(eng.evaluate("p = { id:'foo' }") , QScriptValueList() ); QCOMPARE(result.property("local_bar").toString(), QString("local")); QCOMPARE(result.property("thisObjectIdBefore").toString(), QString("foo")); QCOMPARE(result.property("thisObjectIdAfter").toString(), QString("foo")); QCOMPARE(result.property("evaluatedThisObjectId").toString(), QString("foo")); QScriptValue bar = eng.evaluate("bar"); QVERIFY(bar.isError()); QVERIFY(bar.toString().contains(QString::fromLatin1("ReferenceError"))); } } void tst_QScriptEngine::uncaughtException() { QScriptEngine eng; QScriptValue fun = eng.newFunction(myFunction); QScriptValue throwFun = eng.newFunction(myThrowingFunction); for (int x = -1; x < 2; ++x) { { QScriptValue ret = eng.evaluate("a = 10;\nb = 20;\n0 = 0;\n", /*fileName=*/QString(), /*lineNumber=*/x); QVERIFY(eng.hasUncaughtException()); QCOMPARE(eng.uncaughtExceptionLineNumber(), x+2); QVERIFY(eng.uncaughtException().strictlyEquals(ret)); (void)ret.toString(); QVERIFY(eng.hasUncaughtException()); QVERIFY(eng.uncaughtException().strictlyEquals(ret)); QVERIFY(fun.call().isNull()); QVERIFY(eng.hasUncaughtException()); QCOMPARE(eng.uncaughtExceptionLineNumber(), x+2); QVERIFY(eng.uncaughtException().strictlyEquals(ret)); eng.clearExceptions(); QVERIFY(!eng.hasUncaughtException()); QCOMPARE(eng.uncaughtExceptionLineNumber(), -1); QVERIFY(!eng.uncaughtException().isValid()); eng.evaluate("2 = 3"); QVERIFY(eng.hasUncaughtException()); QScriptValue ret2 = throwFun.call(); QVERIFY(ret2.isError()); QVERIFY(eng.hasUncaughtException()); QVERIFY(eng.uncaughtException().strictlyEquals(ret2)); QCOMPARE(eng.uncaughtExceptionLineNumber(), 0); eng.clearExceptions(); QVERIFY(!eng.hasUncaughtException()); eng.evaluate("1 + 2"); QVERIFY(!eng.hasUncaughtException()); } { QScriptValue ret = eng.evaluate("a = 10"); QVERIFY(!eng.hasUncaughtException()); QVERIFY(!eng.uncaughtException().isValid()); } { QScriptValue ret = eng.evaluate("1 = 2"); QVERIFY(eng.hasUncaughtException()); eng.clearExceptions(); QVERIFY(!eng.hasUncaughtException()); } { eng.globalObject().setProperty("throwFun", throwFun); eng.evaluate("1;\nthrowFun();"); QVERIFY(eng.hasUncaughtException()); QCOMPARE(eng.uncaughtExceptionLineNumber(), 2); eng.clearExceptions(); QVERIFY(!eng.hasUncaughtException()); } } } void tst_QScriptEngine::errorMessage_QT679() { QScriptEngine engine; engine.globalObject().setProperty("foo", 15); QScriptValue error = engine.evaluate("'hello world';\nfoo.bar.blah"); QVERIFY(error.isError()); // The exact message is back-end specific and subject to change. QCOMPARE(error.toString(), QString::fromLatin1("TypeError: Result of expression 'foo.bar' [undefined] is not an object.")); } struct Foo { public: int x, y; Foo() : x(-1), y(-1) { } }; Q_DECLARE_METATYPE(Foo) Q_DECLARE_METATYPE(Foo*) void tst_QScriptEngine::getSetDefaultPrototype_int() { QScriptEngine eng; QScriptValue object = eng.newObject(); QCOMPARE(eng.defaultPrototype(qMetaTypeId()).isValid(), false); eng.setDefaultPrototype(qMetaTypeId(), object); QCOMPARE(eng.defaultPrototype(qMetaTypeId()).strictlyEquals(object), true); QScriptValue value = eng.newVariant(int(123)); QCOMPARE(value.prototype().isObject(), true); QCOMPARE(value.prototype().strictlyEquals(object), true); eng.setDefaultPrototype(qMetaTypeId(), QScriptValue()); QCOMPARE(eng.defaultPrototype(qMetaTypeId()).isValid(), false); QScriptValue value2 = eng.newVariant(int(123)); QCOMPARE(value2.prototype().strictlyEquals(object), false); } void tst_QScriptEngine::getSetDefaultPrototype_customType() { QScriptEngine eng; QScriptValue object = eng.newObject(); QCOMPARE(eng.defaultPrototype(qMetaTypeId()).isValid(), false); eng.setDefaultPrototype(qMetaTypeId(), object); QCOMPARE(eng.defaultPrototype(qMetaTypeId()).strictlyEquals(object), true); QScriptValue value = eng.newVariant(qVariantFromValue(Foo())); QCOMPARE(value.prototype().isObject(), true); QCOMPARE(value.prototype().strictlyEquals(object), true); eng.setDefaultPrototype(qMetaTypeId(), QScriptValue()); QCOMPARE(eng.defaultPrototype(qMetaTypeId()).isValid(), false); QScriptValue value2 = eng.newVariant(qVariantFromValue(Foo())); QCOMPARE(value2.prototype().strictlyEquals(object), false); } static QScriptValue fooToScriptValue(QScriptEngine *eng, const Foo &foo) { QScriptValue obj = eng->newObject(); obj.setProperty("x", QScriptValue(eng, foo.x)); obj.setProperty("y", QScriptValue(eng, foo.y)); return obj; } static void fooFromScriptValue(const QScriptValue &value, Foo &foo) { foo.x = value.property("x").toInt32(); foo.y = value.property("y").toInt32(); } static QScriptValue fooToScriptValueV2(QScriptEngine *eng, const Foo &foo) { return QScriptValue(eng, foo.x); } static void fooFromScriptValueV2(const QScriptValue &value, Foo &foo) { foo.x = value.toInt32(); } Q_DECLARE_METATYPE(QLinkedList) Q_DECLARE_METATYPE(QList) Q_DECLARE_METATYPE(QVector) Q_DECLARE_METATYPE(QStack) Q_DECLARE_METATYPE(QQueue) Q_DECLARE_METATYPE(QLinkedList >) void tst_QScriptEngine::valueConversion_basic() { QScriptEngine eng; { QScriptValue num = qScriptValueFromValue(&eng, 123); QCOMPARE(num.isNumber(), true); QCOMPARE(num.strictlyEquals(QScriptValue(&eng, 123)), true); int inum = qScriptValueToValue(num); QCOMPARE(inum, 123); QString snum = qScriptValueToValue(num); QCOMPARE(snum, QLatin1String("123")); } { QScriptValue num = eng.toScriptValue(123); QCOMPARE(num.isNumber(), true); QCOMPARE(num.strictlyEquals(QScriptValue(&eng, 123)), true); int inum = eng.fromScriptValue(num); QCOMPARE(inum, 123); QString snum = eng.fromScriptValue(num); QCOMPARE(snum, QLatin1String("123")); } { QScriptValue num(&eng, 123); QCOMPARE(qScriptValueToValue(num), char(123)); QCOMPARE(qScriptValueToValue(num), (unsigned char)(123)); QCOMPARE(qScriptValueToValue(num), short(123)); QCOMPARE(qScriptValueToValue(num), (unsigned short)(123)); QCOMPARE(qScriptValueToValue(num), float(123)); QCOMPARE(qScriptValueToValue(num), double(123)); QCOMPARE(qScriptValueToValue(num), qlonglong(123)); QCOMPARE(qScriptValueToValue(num), qulonglong(123)); } { QScriptValue num(123); QCOMPARE(qScriptValueToValue(num), char(123)); QCOMPARE(qScriptValueToValue(num), (unsigned char)(123)); QCOMPARE(qScriptValueToValue(num), short(123)); QCOMPARE(qScriptValueToValue(num), (unsigned short)(123)); QCOMPARE(qScriptValueToValue(num), float(123)); QCOMPARE(qScriptValueToValue(num), double(123)); QCOMPARE(qScriptValueToValue(num), qlonglong(123)); QCOMPARE(qScriptValueToValue(num), qulonglong(123)); } { QScriptValue num = qScriptValueFromValue(&eng, Q_INT64_C(0x100000000)); QCOMPARE(qScriptValueToValue(num), Q_INT64_C(0x100000000)); QCOMPARE(qScriptValueToValue(num), Q_UINT64_C(0x100000000)); } { QChar c = QLatin1Char('c'); QScriptValue str = QScriptValue(&eng, "ciao"); QCOMPARE(qScriptValueToValue(str), c); QScriptValue code = QScriptValue(&eng, c.unicode()); QCOMPARE(qScriptValueToValue(code), c); QCOMPARE(qScriptValueToValue(qScriptValueFromValue(&eng, c)), c); } } void tst_QScriptEngine::valueConversion_customType() { QScriptEngine eng; { // a type that we don't have built-in conversion of // (it's stored as a variant) QTime tm(1, 2, 3, 4); QScriptValue val = qScriptValueFromValue(&eng, tm); QCOMPARE(qScriptValueToValue(val), tm); } { Foo foo; foo.x = 12; foo.y = 34; QScriptValue fooVal = qScriptValueFromValue(&eng, foo); QCOMPARE(fooVal.isVariant(), true); Foo foo2 = qScriptValueToValue(fooVal); QCOMPARE(foo2.x, foo.x); QCOMPARE(foo2.y, foo.y); } qScriptRegisterMetaType(&eng, fooToScriptValue, fooFromScriptValue); { Foo foo; foo.x = 12; foo.y = 34; QScriptValue fooVal = qScriptValueFromValue(&eng, foo); QCOMPARE(fooVal.isObject(), true); QVERIFY(fooVal.prototype().strictlyEquals(eng.evaluate("Object.prototype"))); QCOMPARE(fooVal.property("x").strictlyEquals(QScriptValue(&eng, 12)), true); QCOMPARE(fooVal.property("y").strictlyEquals(QScriptValue(&eng, 34)), true); fooVal.setProperty("x", QScriptValue(&eng, 56)); fooVal.setProperty("y", QScriptValue(&eng, 78)); Foo foo2 = qScriptValueToValue(fooVal); QCOMPARE(foo2.x, 56); QCOMPARE(foo2.y, 78); QScriptValue fooProto = eng.newObject(); eng.setDefaultPrototype(qMetaTypeId(), fooProto); QScriptValue fooVal2 = qScriptValueFromValue(&eng, foo2); QVERIFY(fooVal2.prototype().strictlyEquals(fooProto)); QVERIFY(fooVal2.property("x").strictlyEquals(QScriptValue(&eng, 56))); QVERIFY(fooVal2.property("y").strictlyEquals(QScriptValue(&eng, 78))); } } void tst_QScriptEngine::valueConversion_sequence() { QScriptEngine eng; qScriptRegisterSequenceMetaType >(&eng); { QLinkedList lst; lst << QLatin1String("foo") << QLatin1String("bar"); QScriptValue lstVal = qScriptValueFromValue(&eng, lst); QCOMPARE(lstVal.isArray(), true); QCOMPARE(lstVal.property("length").toInt32(), 2); QCOMPARE(lstVal.property("0").isString(), true); QCOMPARE(lstVal.property("0").toString(), QLatin1String("foo")); QCOMPARE(lstVal.property("1").isString(), true); QCOMPARE(lstVal.property("1").toString(), QLatin1String("bar")); } qScriptRegisterSequenceMetaType >(&eng); qScriptRegisterSequenceMetaType >(&eng); qScriptRegisterSequenceMetaType >(&eng); qScriptRegisterSequenceMetaType >(&eng); qScriptRegisterSequenceMetaType > >(&eng); { QLinkedList > lst; QStack first; first << 13 << 49; lst << first; QStack second; second << 99999;lst << second; QScriptValue lstVal = qScriptValueFromValue(&eng, lst); QCOMPARE(lstVal.isArray(), true); QCOMPARE(lstVal.property("length").toInt32(), 2); QCOMPARE(lstVal.property("0").isArray(), true); QCOMPARE(lstVal.property("0").property("length").toInt32(), 2); QCOMPARE(lstVal.property("0").property("0").toInt32(), first.at(0)); QCOMPARE(lstVal.property("0").property("1").toInt32(), first.at(1)); QCOMPARE(lstVal.property("1").isArray(), true); QCOMPARE(lstVal.property("1").property("length").toInt32(), 1); QCOMPARE(lstVal.property("1").property("0").toInt32(), second.at(0)); QCOMPARE(qscriptvalue_cast >(lstVal.property("0")), first); QCOMPARE(qscriptvalue_cast >(lstVal.property("1")), second); QCOMPARE(qscriptvalue_cast > >(lstVal), lst); } // pointers { Foo foo; { QScriptValue v = qScriptValueFromValue(&eng, &foo); Foo *pfoo = qscriptvalue_cast(v); QCOMPARE(pfoo, &foo); } { Foo *pfoo = 0; QScriptValue v = qScriptValueFromValue(&eng, pfoo); QCOMPARE(v.isNull(), true); QVERIFY(qscriptvalue_cast(v) == 0); } } // QList and QObjectList should be converted from/to arrays by default { QList lst; lst << 1 << 2 << 3; QScriptValue val = qScriptValueFromValue(&eng, lst); QVERIFY(val.isArray()); QCOMPARE(val.property("length").toInt32(), lst.size()); QCOMPARE(val.property(0).toInt32(), lst.at(0)); QCOMPARE(val.property(1).toInt32(), lst.at(1)); QCOMPARE(val.property(2).toInt32(), lst.at(2)); QCOMPARE(qscriptvalue_cast >(val), lst); } { QObjectList lst; lst << this; QScriptValue val = qScriptValueFromValue(&eng, lst); QVERIFY(val.isArray()); QCOMPARE(val.property("length").toInt32(), lst.size()); QCOMPARE(val.property(0).toQObject(), (QObject *)this); QCOMPARE(qscriptvalue_cast(val), lst); } } void tst_QScriptEngine::valueConversion_QVariant() { QScriptEngine eng; // qScriptValueFromValue() should be "smart" when the argument is a QVariant { QScriptValue val = qScriptValueFromValue(&eng, QVariant()); QVERIFY(!val.isVariant()); QVERIFY(val.isUndefined()); } // Checking nested QVariants { QVariant tmp1; QVariant tmp2(QMetaType::QVariant, &tmp1); QVERIFY(QMetaType::Type(tmp2.type()) == QMetaType::QVariant); QScriptValue val1 = qScriptValueFromValue(&eng, tmp1); QScriptValue val2 = qScriptValueFromValue(&eng, tmp2); QVERIFY(val1.isValid()); QVERIFY(val2.isValid()); QVERIFY(val1.isUndefined()); QVERIFY(!val2.isUndefined()); QVERIFY(!val1.isVariant()); QVERIFY(val2.isVariant()); } { QVariant tmp1(123); QVariant tmp2(QMetaType::QVariant, &tmp1); QVariant tmp3(QMetaType::QVariant, &tmp2); QVERIFY(QMetaType::Type(tmp1.type()) == QMetaType::Int); QVERIFY(QMetaType::Type(tmp2.type()) == QMetaType::QVariant); QVERIFY(QMetaType::Type(tmp3.type()) == QMetaType::QVariant); QScriptValue val1 = qScriptValueFromValue(&eng, tmp2); QScriptValue val2 = qScriptValueFromValue(&eng, tmp3); QVERIFY(val1.isValid()); QVERIFY(val2.isValid()); QVERIFY(val1.isVariant()); QVERIFY(val2.isVariant()); QVERIFY(val1.toVariant().toInt() == 123); QVERIFY(qScriptValueFromValue(&eng, val2.toVariant()).toVariant().toInt() == 123); } { QScriptValue val = qScriptValueFromValue(&eng, QVariant(true)); QVERIFY(!val.isVariant()); QVERIFY(val.isBoolean()); QCOMPARE(val.toBoolean(), true); } { QScriptValue val = qScriptValueFromValue(&eng, QVariant(int(123))); QVERIFY(!val.isVariant()); QVERIFY(val.isNumber()); QCOMPARE(val.toNumber(), qsreal(123)); } { QScriptValue val = qScriptValueFromValue(&eng, QVariant(qsreal(1.25))); QVERIFY(!val.isVariant()); QVERIFY(val.isNumber()); QCOMPARE(val.toNumber(), qsreal(1.25)); } { QString str = QString::fromLatin1("ciao"); QScriptValue val = qScriptValueFromValue(&eng, QVariant(str)); QVERIFY(!val.isVariant()); QVERIFY(val.isString()); QCOMPARE(val.toString(), str); } { QScriptValue val = qScriptValueFromValue(&eng, qVariantFromValue((QObject*)this)); QVERIFY(!val.isVariant()); QVERIFY(val.isQObject()); QCOMPARE(val.toQObject(), (QObject*)this); } { QVariant var = qVariantFromValue(QPoint(123, 456)); QScriptValue val = qScriptValueFromValue(&eng, var); QVERIFY(val.isVariant()); QCOMPARE(val.toVariant(), var); } QCOMPARE(qscriptvalue_cast(QScriptValue(123)), QVariant(123)); } void tst_QScriptEngine::valueConversion_hooliganTask248802() { QScriptEngine eng; qScriptRegisterMetaType(&eng, fooToScriptValueV2, fooFromScriptValueV2); { QScriptValue num(&eng, 123); Foo foo = qScriptValueToValue(num); QCOMPARE(foo.x, 123); } { QScriptValue num(123); Foo foo = qScriptValueToValue(num); QCOMPARE(foo.x, -1); } { QScriptValue str(&eng, "123"); Foo foo = qScriptValueToValue(str); QCOMPARE(foo.x, 123); } } void tst_QScriptEngine::valueConversion_basic2() { QScriptEngine eng; // more built-in types { QScriptValue val = qScriptValueFromValue(&eng, uint(123)); QVERIFY(val.isNumber()); QCOMPARE(val.toInt32(), 123); } { QScriptValue val = qScriptValueFromValue(&eng, qulonglong(123)); QVERIFY(val.isNumber()); QCOMPARE(val.toInt32(), 123); } { QScriptValue val = qScriptValueFromValue(&eng, float(123)); QVERIFY(val.isNumber()); QCOMPARE(val.toInt32(), 123); } { QScriptValue val = qScriptValueFromValue(&eng, short(123)); QVERIFY(val.isNumber()); QCOMPARE(val.toInt32(), 123); } { QScriptValue val = qScriptValueFromValue(&eng, ushort(123)); QVERIFY(val.isNumber()); QCOMPARE(val.toInt32(), 123); } { QScriptValue val = qScriptValueFromValue(&eng, char(123)); QVERIFY(val.isNumber()); QCOMPARE(val.toInt32(), 123); } { QScriptValue val = qScriptValueFromValue(&eng, uchar(123)); QVERIFY(val.isNumber()); QCOMPARE(val.toInt32(), 123); } } void tst_QScriptEngine::valueConversion_dateTime() { QScriptEngine eng; { QDateTime in = QDateTime::currentDateTime(); QScriptValue val = qScriptValueFromValue(&eng, in); QVERIFY(val.isDate()); QCOMPARE(val.toDateTime(), in); } { QDate in = QDate::currentDate(); QScriptValue val = qScriptValueFromValue(&eng, in); QVERIFY(val.isDate()); QCOMPARE(val.toDateTime().date(), in); } } void tst_QScriptEngine::valueConversion_regExp() { QScriptEngine eng; { QRegExp in = QRegExp("foo"); QScriptValue val = qScriptValueFromValue(&eng, in); QVERIFY(val.isRegExp()); QRegExp out = val.toRegExp(); QEXPECT_FAIL("", "QTBUG-6136: JSC-based back-end doesn't preserve QRegExp::patternSyntax (always uses RegExp2)", Continue); QCOMPARE(out.patternSyntax(), in.patternSyntax()); QCOMPARE(out.pattern(), in.pattern()); QCOMPARE(out.caseSensitivity(), in.caseSensitivity()); QCOMPARE(out.isMinimal(), in.isMinimal()); } { QRegExp in = QRegExp("foo", Qt::CaseSensitive, QRegExp::RegExp2); QScriptValue val = qScriptValueFromValue(&eng, in); QVERIFY(val.isRegExp()); QCOMPARE(val.toRegExp(), in); } { QRegExp in = QRegExp("foo"); in.setMinimal(true); QScriptValue val = qScriptValueFromValue(&eng, in); QVERIFY(val.isRegExp()); QEXPECT_FAIL("", "QTBUG-6136: JSC-based back-end doesn't preserve QRegExp::minimal (always false)", Continue); QCOMPARE(val.toRegExp().isMinimal(), in.isMinimal()); } } void tst_QScriptEngine::qScriptValueFromValue_noEngine() { QVERIFY(!qScriptValueFromValue(0, 123).isValid()); QVERIFY(!qScriptValueFromValue(0, QVariant(123)).isValid()); } static QScriptValue __import__(QScriptContext *ctx, QScriptEngine *eng) { return eng->importExtension(ctx->argument(0).toString()); } void tst_QScriptEngine::importExtension() { QStringList libPaths = QCoreApplication::instance()->libraryPaths(); QCoreApplication::instance()->setLibraryPaths(QStringList() << SRCDIR); QStringList availableExtensions; { QScriptEngine eng; QVERIFY(eng.importedExtensions().isEmpty()); QStringList ret = eng.availableExtensions(); QCOMPARE(ret.size(), 4); QCOMPARE(ret.at(0), QString::fromLatin1("com")); QCOMPARE(ret.at(1), QString::fromLatin1("com.trolltech")); QCOMPARE(ret.at(2), QString::fromLatin1("com.trolltech.recursive")); QCOMPARE(ret.at(3), QString::fromLatin1("com.trolltech.syntaxerror")); availableExtensions = ret; } // try to import something that doesn't exist { QScriptEngine eng; QScriptValue ret = eng.importExtension("this.extension.does.not.exist"); QCOMPARE(eng.hasUncaughtException(), true); QCOMPARE(ret.isError(), true); QCOMPARE(ret.toString(), QString::fromLatin1("Error: Unable to import this.extension.does.not.exist: no such extension")); } { QScriptEngine eng; for (int x = 0; x < 2; ++x) { QCOMPARE(eng.globalObject().property("com").isValid(), x == 1); QScriptValue ret = eng.importExtension("com.trolltech"); QCOMPARE(eng.hasUncaughtException(), false); QCOMPARE(ret.isUndefined(), true); QScriptValue com = eng.globalObject().property("com"); QCOMPARE(com.isObject(), true); QCOMPARE(com.property("wasDefinedAlready") .strictlyEquals(QScriptValue(&eng, false)), true); QCOMPARE(com.property("name") .strictlyEquals(QScriptValue(&eng, "com")), true); QCOMPARE(com.property("level") .strictlyEquals(QScriptValue(&eng, 1)), true); QVERIFY(com.property("originalPostInit").isUndefined()); QVERIFY(com.property("postInitCallCount").strictlyEquals(1)); QScriptValue trolltech = com.property("trolltech"); QCOMPARE(trolltech.isObject(), true); QCOMPARE(trolltech.property("wasDefinedAlready") .strictlyEquals(QScriptValue(&eng, false)), true); QCOMPARE(trolltech.property("name") .strictlyEquals(QScriptValue(&eng, "com.trolltech")), true); QCOMPARE(trolltech.property("level") .strictlyEquals(QScriptValue(&eng, 2)), true); QVERIFY(trolltech.property("originalPostInit").isUndefined()); QVERIFY(trolltech.property("postInitCallCount").strictlyEquals(1)); } QStringList imp = eng.importedExtensions(); QCOMPARE(imp.size(), 2); QCOMPARE(imp.at(0), QString::fromLatin1("com")); QCOMPARE(imp.at(1), QString::fromLatin1("com.trolltech")); QCOMPARE(eng.availableExtensions(), availableExtensions); } // recursive import should throw an error { QScriptEngine eng; QVERIFY(eng.importedExtensions().isEmpty()); eng.globalObject().setProperty("__import__", eng.newFunction(__import__)); QScriptValue ret = eng.importExtension("com.trolltech.recursive"); QCOMPARE(eng.hasUncaughtException(), true); QVERIFY(ret.isError()); QCOMPARE(ret.toString(), QString::fromLatin1("Error: recursive import of com.trolltech.recursive")); QStringList imp = eng.importedExtensions(); QCOMPARE(imp.size(), 2); QCOMPARE(imp.at(0), QString::fromLatin1("com")); QCOMPARE(imp.at(1), QString::fromLatin1("com.trolltech")); QCOMPARE(eng.availableExtensions(), availableExtensions); } { QScriptEngine eng; eng.globalObject().setProperty("__import__", eng.newFunction(__import__)); for (int x = 0; x < 2; ++x) { if (x == 0) QVERIFY(eng.importedExtensions().isEmpty()); QScriptValue ret = eng.importExtension("com.trolltech.syntaxerror"); QVERIFY(eng.hasUncaughtException()); QEXPECT_FAIL("", "JSC throws syntax error eagerly", Continue); QCOMPARE(eng.uncaughtExceptionLineNumber(), 4); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains(QLatin1String("SyntaxError"))); } QStringList imp = eng.importedExtensions(); QCOMPARE(imp.size(), 2); QCOMPARE(imp.at(0), QString::fromLatin1("com")); QCOMPARE(imp.at(1), QString::fromLatin1("com.trolltech")); QCOMPARE(eng.availableExtensions(), availableExtensions); } QCoreApplication::instance()->setLibraryPaths(libPaths); } static QScriptValue recurse(QScriptContext *ctx, QScriptEngine *eng) { Q_UNUSED(eng); return ctx->callee().call(); } static QScriptValue recurse2(QScriptContext *ctx, QScriptEngine *eng) { Q_UNUSED(eng); return ctx->callee().construct(); } void tst_QScriptEngine::infiniteRecursion() { // Infinite recursion in JS should cause the VM to throw an error // when the JS stack is exhausted. // The exact error is back-end specific and subject to change. const QString stackOverflowError = QString::fromLatin1("RangeError: Maximum call stack size exceeded."); QScriptEngine eng; { QScriptValue ret = eng.evaluate("function foo() { foo(); }; foo();"); QCOMPARE(ret.isError(), true); QCOMPARE(ret.toString(), stackOverflowError); } #if 0 //The native C++ stack overflow before the JS stack { QScriptValue fun = eng.newFunction(recurse); QScriptValue ret = fun.call(); QCOMPARE(ret.isError(), true); QCOMPARE(ret.toString(), stackOverflowError); } { QScriptValue fun = eng.newFunction(recurse2); QScriptValue ret = fun.construct(); QCOMPARE(ret.isError(), true); QCOMPARE(ret.toString(), stackOverflowError); } #endif } struct Bar { int a; }; struct Baz : public Bar { int b; }; Q_DECLARE_METATYPE(Bar*) Q_DECLARE_METATYPE(Baz*) Q_DECLARE_METATYPE(QGradient) Q_DECLARE_METATYPE(QGradient*) Q_DECLARE_METATYPE(QLinearGradient) class Zoo : public QObject { Q_OBJECT public: Zoo() { } public slots: Baz *toBaz(Bar *b) { return reinterpret_cast(b); } }; void tst_QScriptEngine::castWithPrototypeChain() { QScriptEngine eng; Bar bar; Baz baz; QScriptValue barProto = qScriptValueFromValue(&eng, &bar); QScriptValue bazProto = qScriptValueFromValue(&eng, &baz); eng.setDefaultPrototype(qMetaTypeId(), barProto); eng.setDefaultPrototype(qMetaTypeId(), bazProto); Baz baz2; baz2.a = 123; baz2.b = 456; QScriptValue baz2Value = qScriptValueFromValue(&eng, &baz2); { // qscriptvalue_cast() does magic; if the QScriptValue contains // t of type T, and the target type is T*, &t is returned. Baz *pbaz = qscriptvalue_cast(baz2Value); QVERIFY(pbaz != 0); QCOMPARE(pbaz->b, baz2.b); Zoo zoo; QScriptValue scriptZoo = eng.newQObject(&zoo); QScriptValue toBaz = scriptZoo.property("toBaz"); QVERIFY(toBaz.isFunction()); // no relation between Bar and Baz's proto --> casting fails { Bar *pbar = qscriptvalue_cast(baz2Value); QVERIFY(pbar == 0); } { QScriptValue ret = toBaz.call(scriptZoo, QScriptValueList() << baz2Value); QVERIFY(ret.isError()); QCOMPARE(ret.toString(), QLatin1String("TypeError: incompatible type of argument(s) in call to toBaz(); candidates were\n toBaz(Bar*)")); } // establish chain -- now casting should work // Why? because qscriptvalue_cast() does magic again. // It the instance itself is not of type T, qscriptvalue_cast() // searches the prototype chain for T, and if it finds one, it infers // that the instance can also be casted to that type. This cast is // _not_ safe and thus relies on the developer doing the right thing. // This is an undocumented feature to enable qscriptvalue_cast() to // be used by prototype functions to cast the JS this-object to C++. bazProto.setPrototype(barProto); { Bar *pbar = qscriptvalue_cast(baz2Value); QVERIFY(pbar != 0); QCOMPARE(pbar->a, baz2.a); } { QScriptValue ret = toBaz.call(scriptZoo, QScriptValueList() << baz2Value); QVERIFY(!ret.isError()); QCOMPARE(qscriptvalue_cast(ret), pbaz); } } bazProto.setPrototype(barProto.prototype()); // kill chain { Baz *pbaz = qscriptvalue_cast(baz2Value); QVERIFY(pbaz != 0); // should not work anymore Bar *pbar = qscriptvalue_cast(baz2Value); QVERIFY(pbar == 0); } bazProto.setPrototype(eng.newQObject(this)); { Baz *pbaz = qscriptvalue_cast(baz2Value); QVERIFY(pbaz != 0); // should not work now either Bar *pbar = qscriptvalue_cast(baz2Value); QVERIFY(pbar == 0); } { QScriptValue b = qScriptValueFromValue(&eng, QBrush()); b.setPrototype(barProto); // this shows that a "wrong" cast is possible, if you // don't play by the rules (the pointer is actually a QBrush*)... Bar *pbar = qscriptvalue_cast(b); QVERIFY(pbar != 0); } { QScriptValue gradientProto = qScriptValueFromValue(&eng, QGradient()); QScriptValue linearGradientProto = qScriptValueFromValue(&eng, QLinearGradient()); linearGradientProto.setPrototype(gradientProto); QLinearGradient lg(10, 20, 30, 40); QScriptValue linearGradient = qScriptValueFromValue(&eng, lg); { QGradient *pgrad = qscriptvalue_cast(linearGradient); QVERIFY(pgrad == 0); } linearGradient.setPrototype(linearGradientProto); { QGradient *pgrad = qscriptvalue_cast(linearGradient); QVERIFY(pgrad != 0); QCOMPARE(pgrad->type(), QGradient::LinearGradient); QLinearGradient *plingrad = static_cast(pgrad); QCOMPARE(plingrad->start(), lg.start()); QCOMPARE(plingrad->finalStop(), lg.finalStop()); } } } class Klazz : public QWidget, public QStandardItem, public QGraphicsItem { Q_OBJECT public: Klazz(QWidget *parent = 0) : QWidget(parent) { } virtual QRectF boundingRect() const { return QRectF(); } virtual void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget*) { } }; Q_DECLARE_METATYPE(Klazz*) Q_DECLARE_METATYPE(QStandardItem*) void tst_QScriptEngine::castWithMultipleInheritance() { QScriptEngine eng; Klazz klz; QScriptValue v = eng.newQObject(&klz); QCOMPARE(qscriptvalue_cast(v), &klz); QCOMPARE(qscriptvalue_cast(v), (QWidget *)&klz); QCOMPARE(qscriptvalue_cast(v), (QObject *)&klz); QCOMPARE(qscriptvalue_cast(v), (QStandardItem *)&klz); QCOMPARE(qscriptvalue_cast(v), (QGraphicsItem *)&klz); } void tst_QScriptEngine::collectGarbage() { QScriptEngine eng; eng.evaluate("a = new Object(); a = new Object(); a = new Object()"); QScriptValue a = eng.newObject(); a = eng.newObject(); a = eng.newObject(); QPointer ptr = new QObject(); QVERIFY(ptr != 0); (void)eng.newQObject(ptr, QScriptEngine::ScriptOwnership); collectGarbage_helper(eng); QVERIFY(ptr == 0); } void tst_QScriptEngine::reportAdditionalMemoryCost() { QScriptEngine eng; // There isn't any reliable way to test whether calling // this function affects garbage collection responsiveness; // the best we can do is call it with a few different values. for (int x = 0; x < 1000; ++x) { eng.reportAdditionalMemoryCost(0); eng.reportAdditionalMemoryCost(10); eng.reportAdditionalMemoryCost(1000); eng.reportAdditionalMemoryCost(10000); eng.reportAdditionalMemoryCost(100000); eng.reportAdditionalMemoryCost(1000000); eng.reportAdditionalMemoryCost(10000000); eng.reportAdditionalMemoryCost(-1); eng.reportAdditionalMemoryCost(-1000); QScriptValue obj = eng.newObject(); eng.collectGarbage(); } } void tst_QScriptEngine::gcWithNestedDataStructure() { // The GC must be able to traverse deeply nested objects, otherwise this // test would crash. QScriptEngine eng; eng.evaluate( "function makeList(size)" "{" " var head = { };" " var l = head;" " for (var i = 0; i < size; ++i) {" " l.data = i + \"\";" " l.next = { }; l = l.next;" " }" " l.next = null;" " return head;" "}"); QCOMPARE(eng.hasUncaughtException(), false); const int size = 200; QScriptValue head = eng.evaluate(QString::fromLatin1("makeList(%0)").arg(size)); QCOMPARE(eng.hasUncaughtException(), false); for (int x = 0; x < 2; ++x) { if (x == 1) eng.evaluate("gc()"); QScriptValue l = head; // Make sure all the nodes are still alive. for (int i = 0; i < 200; ++i) { QCOMPARE(l.property("data").toString(), QString::number(i)); l = l.property("next"); } } } class EventReceiver : public QObject { public: EventReceiver() { received = false; } bool event(QEvent *e) { received |= (e->type() == QEvent::User + 1); return QObject::event(e); } bool received; }; void tst_QScriptEngine::processEventsWhileRunning() { for (int x = 0; x < 2; ++x) { QScriptEngine eng; if (x == 0) eng.pushContext(); // This is running for a silly amount of time just to make sure // the script doesn't finish before event processing is triggered. QString script = QString::fromLatin1( "var end = Number(new Date()) + 2000;" "var x = 0;" "while (Number(new Date()) < end) {" " ++x;" "}"); EventReceiver receiver; QCoreApplication::postEvent(&receiver, new QEvent(QEvent::Type(QEvent::User+1))); eng.evaluate(script); QVERIFY(!eng.hasUncaughtException()); QVERIFY(!receiver.received); QCOMPARE(eng.processEventsInterval(), -1); eng.setProcessEventsInterval(100); eng.evaluate(script); QVERIFY(!eng.hasUncaughtException()); QVERIFY(receiver.received); if (x == 0) eng.popContext(); } } class EventReceiver2 : public QObject { public: EventReceiver2(QScriptEngine *eng) { engine = eng; } bool event(QEvent *e) { if (e->type() == QEvent::User + 1) { engine->currentContext()->throwError("Killed"); } return QObject::event(e); } QScriptEngine *engine; }; void tst_QScriptEngine::throwErrorFromProcessEvents_data() { QTest::addColumn("script"); QTest::addColumn("error"); QTest::newRow("while (1)") << QString::fromLatin1("while (1) { }") << QString::fromLatin1("Error: Killed"); QTest::newRow("while (1) i++") << QString::fromLatin1("i = 0; while (1) { i++; }") << QString::fromLatin1("Error: Killed"); // Unlike abortEvaluation(), scripts should be able to catch the // exception. QTest::newRow("try catch") << QString::fromLatin1("try {" " while (1) { }" "} catch(e) {" " throw new Error('Caught');" "}") << QString::fromLatin1("Error: Caught"); } void tst_QScriptEngine::throwErrorFromProcessEvents() { QFETCH(QString, script); QFETCH(QString, error); QScriptEngine eng; EventReceiver2 receiver(&eng); QCoreApplication::postEvent(&receiver, new QEvent(QEvent::Type(QEvent::User+1))); eng.setProcessEventsInterval(100); QScriptValue ret = eng.evaluate(script); QVERIFY(ret.isError()); QCOMPARE(ret.toString(), error); } void tst_QScriptEngine::disableProcessEventsInterval() { QScriptEngine eng; eng.setProcessEventsInterval(100); QCOMPARE(eng.processEventsInterval(), 100); eng.setProcessEventsInterval(0); QCOMPARE(eng.processEventsInterval(), 0); eng.setProcessEventsInterval(-1); QCOMPARE(eng.processEventsInterval(), -1); eng.setProcessEventsInterval(-100); QCOMPARE(eng.processEventsInterval(), -100); } void tst_QScriptEngine::stacktrace() { QString script = QString::fromLatin1( "function foo(counter) {\n" " switch (counter) {\n" " case 0: foo(counter+1); break;\n" " case 1: foo(counter+1); break;\n" " case 2: foo(counter+1); break;\n" " case 3: foo(counter+1); break;\n" " case 4: foo(counter+1); break;\n" " default:\n" " throw new Error('blah');\n" " }\n" "}\n" "foo(0);"); const QString fileName("testfile"); QStringList backtrace; backtrace << "foo(5)@testfile:9" << "foo(4)@testfile:7" << "foo(3)@testfile:6" << "foo(2)@testfile:5" << "foo(1)@testfile:4" << "foo(0)@testfile:3" << "()@testfile:12"; QScriptEngine eng; QScriptValue result = eng.evaluate(script, fileName); QVERIFY(eng.hasUncaughtException()); QVERIFY(result.isError()); QEXPECT_FAIL("", "QTBUG-6139: uncaughtExceptionBacktrace() doesn't give the full backtrace", Abort); QCOMPARE(eng.uncaughtExceptionBacktrace(), backtrace); QVERIFY(eng.hasUncaughtException()); QVERIFY(result.strictlyEquals(eng.uncaughtException())); QCOMPARE(result.property("fileName").toString(), fileName); QCOMPARE(result.property("lineNumber").toInt32(), 9); QScriptValue stack = result.property("stack"); QVERIFY(stack.isArray()); QCOMPARE(stack.property("length").toInt32(), 7); QScriptValueIterator it(stack); int counter = 5; while (it.hasNext()) { it.next(); QScriptValue obj = it.value(); QScriptValue frame = obj.property("frame"); QCOMPARE(obj.property("fileName").toString(), fileName); if (counter >= 0) { QScriptValue callee = frame.property("arguments").property("callee"); QVERIFY(callee.strictlyEquals(eng.globalObject().property("foo"))); QCOMPARE(obj.property("functionName").toString(), QString("foo")); int line = obj.property("lineNumber").toInt32(); if (counter == 5) QCOMPARE(line, 9); else QCOMPARE(line, 3 + counter); } else { QVERIFY(frame.strictlyEquals(eng.globalObject())); QVERIFY(obj.property("functionName").toString().isEmpty()); } --counter; } { QScriptValue bt = result.property("backtrace").call(result); QCOMPARE(qscriptvalue_cast(bt), backtrace); } // throw something that isn't an Error object eng.clearExceptions(); QVERIFY(eng.uncaughtExceptionBacktrace().isEmpty()); QString script2 = QString::fromLatin1( "function foo(counter) {\n" " switch (counter) {\n" " case 0: foo(counter+1); break;\n" " case 1: foo(counter+1); break;\n" " case 2: foo(counter+1); break;\n" " case 3: foo(counter+1); break;\n" " case 4: foo(counter+1); break;\n" " default:\n" " throw 'just a string';\n" " }\n" "}\n" "foo(0);"); QScriptValue result2 = eng.evaluate(script2, fileName); QVERIFY(eng.hasUncaughtException()); QVERIFY(!result2.isError()); QVERIFY(result2.isString()); QCOMPARE(eng.uncaughtExceptionBacktrace(), backtrace); QVERIFY(eng.hasUncaughtException()); eng.clearExceptions(); QVERIFY(!eng.hasUncaughtException()); QVERIFY(eng.uncaughtExceptionBacktrace().isEmpty()); } void tst_QScriptEngine::numberParsing_data() { QTest::addColumn("string"); QTest::addColumn("expect"); QTest::newRow("decimal 0") << QString("0") << qsreal(0); QTest::newRow("octal 0") << QString("00") << qsreal(00); QTest::newRow("hex 0") << QString("0x0") << qsreal(0x0); QTest::newRow("decimal 100") << QString("100") << qsreal(100); QTest::newRow("hex 100") << QString("0x100") << qsreal(0x100); QTest::newRow("octal 100") << QString("0100") << qsreal(0100); QTest::newRow("decimal 4G") << QString("4294967296") << qsreal(Q_UINT64_C(4294967296)); QTest::newRow("hex 4G") << QString("0x100000000") << qsreal(Q_UINT64_C(0x100000000)); QTest::newRow("octal 4G") << QString("040000000000") << qsreal(Q_UINT64_C(040000000000)); QTest::newRow("0.5") << QString("0.5") << qsreal(0.5); QTest::newRow("1.5") << QString("1.5") << qsreal(1.5); QTest::newRow("1e2") << QString("1e2") << qsreal(100); } void tst_QScriptEngine::numberParsing() { QFETCH(QString, string); QFETCH(qsreal, expect); QScriptEngine eng; QScriptValue ret = eng.evaluate(string); QVERIFY(ret.isNumber()); qsreal actual = ret.toNumber(); QCOMPARE(actual, expect); } // see ECMA-262, section 7.9 // This is testing ECMA compliance, not our C++ API, but it's important that // the back-end is conformant in this regard. void tst_QScriptEngine::automaticSemicolonInsertion() { QScriptEngine eng; { QScriptValue ret = eng.evaluate("{ 1 2 } 3"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains("SyntaxError")); } { QScriptValue ret = eng.evaluate("{ 1\n2 } 3"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 3); } { QScriptValue ret = eng.evaluate("for (a; b\n)"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains("SyntaxError")); } { QScriptValue ret = eng.evaluate("(function() { return\n1 + 2 })()"); QVERIFY(ret.isUndefined()); } { eng.evaluate("c = 2; b = 1"); QScriptValue ret = eng.evaluate("a = b\n++c"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 3); } { QScriptValue ret = eng.evaluate("if (a > b)\nelse c = d"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains("SyntaxError")); } { eng.evaluate("function c() { return { foo: function() { return 5; } } }"); eng.evaluate("b = 1; d = 2; e = 3"); QScriptValue ret = eng.evaluate("a = b + c\n(d + e).foo()"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 6); } { QScriptValue ret = eng.evaluate("throw\n1"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains("SyntaxError")); } { QScriptValue ret = eng.evaluate("a = Number(1)\n++a"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 2); } // "a semicolon is never inserted automatically if the semicolon // would then be parsed as an empty statement" { eng.evaluate("a = 123"); QScriptValue ret = eng.evaluate("if (0)\n ++a; a"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 123); } { eng.evaluate("a = 123"); QScriptValue ret = eng.evaluate("if (0)\n --a; a"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 123); } { eng.evaluate("a = 123"); QScriptValue ret = eng.evaluate("if ((0))\n ++a; a"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 123); } { eng.evaluate("a = 123"); QScriptValue ret = eng.evaluate("if ((0))\n --a; a"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 123); } { eng.evaluate("a = 123"); QScriptValue ret = eng.evaluate("if (0\n)\n ++a; a"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 123); } { eng.evaluate("a = 123"); QScriptValue ret = eng.evaluate("if (0\n ++a; a"); QVERIFY(ret.isError()); } { eng.evaluate("a = 123"); QScriptValue ret = eng.evaluate("if (0))\n ++a; a"); QVERIFY(ret.isError()); } { QScriptValue ret = eng.evaluate("n = 0; for (i = 0; i < 10; ++i)\n ++n; n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 10); } { QScriptValue ret = eng.evaluate("n = 30; for (i = 0; i < 10; ++i)\n --n; n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 20); } { QScriptValue ret = eng.evaluate("n = 0; for (var i = 0; i < 10; ++i)\n ++n; n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 10); } { QScriptValue ret = eng.evaluate("n = 30; for (var i = 0; i < 10; ++i)\n --n; n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 20); } { QScriptValue ret = eng.evaluate("n = 0; i = 0; while (i++ < 10)\n ++n; n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 10); } { QScriptValue ret = eng.evaluate("n = 30; i = 0; while (i++ < 10)\n --n; n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 20); } { QScriptValue ret = eng.evaluate("o = { a: 0, b: 1, c: 2 }; n = 0; for (i in o)\n ++n; n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 3); } { QScriptValue ret = eng.evaluate("o = { a: 0, b: 1, c: 2 }; n = 9; for (i in o)\n --n; n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 6); } { QScriptValue ret = eng.evaluate("o = { a: 0, b: 1, c: 2 }; n = 0; for (var i in o)\n ++n; n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 3); } { QScriptValue ret = eng.evaluate("o = { a: 0, b: 1, c: 2 }; n = 9; for (var i in o)\n --n; n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 6); } { QScriptValue ret = eng.evaluate("o = { n: 3 }; n = 5; with (o)\n ++n; n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 5); } { QScriptValue ret = eng.evaluate("o = { n: 3 }; n = 10; with (o)\n --n; n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 10); } { QScriptValue ret = eng.evaluate("n = 5; i = 0; do\n ++n; while (++i < 10); n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 15); } { QScriptValue ret = eng.evaluate("n = 20; i = 0; do\n --n; while (++i < 10); n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 10); } { QScriptValue ret = eng.evaluate("n = 1; i = 0; if (n) i\n++n; n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 2); } { QScriptValue ret = eng.evaluate("n = 1; i = 0; if (n) i\n--n; n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 0); } { QScriptValue ret = eng.evaluate("if (0)"); QVERIFY(ret.isError()); } { QScriptValue ret = eng.evaluate("while (0)"); QVERIFY(ret.isError()); } { QScriptValue ret = eng.evaluate("for (;;)"); QVERIFY(ret.isError()); } { QScriptValue ret = eng.evaluate("for (p in this)"); QVERIFY(ret.isError()); } { QScriptValue ret = eng.evaluate("with (this)"); QVERIFY(ret.isError()); } { QScriptValue ret = eng.evaluate("do"); QVERIFY(ret.isError()); } } class EventReceiver3 : public QObject { public: enum AbortionResult { None = 0, String = 1, Error = 2, Number = 3 }; EventReceiver3(QScriptEngine *eng) { engine = eng; resultType = None; } bool event(QEvent *e) { if (e->type() == QEvent::User + 1) { switch (resultType) { case None: engine->abortEvaluation(); break; case String: engine->abortEvaluation(QScriptValue(engine, QString::fromLatin1("Aborted"))); break; case Error: engine->abortEvaluation(engine->currentContext()->throwError("AbortedWithError")); break; case Number: engine->abortEvaluation(QScriptValue(1234)); } } return QObject::event(e); } AbortionResult resultType; QScriptEngine *engine; }; static QScriptValue myFunctionAbortingEvaluation(QScriptContext *, QScriptEngine *eng) { eng->abortEvaluation(); return eng->nullValue(); // should be ignored } void tst_QScriptEngine::abortEvaluation_notEvaluating() { QScriptEngine eng; eng.abortEvaluation(); QVERIFY(!eng.hasUncaughtException()); eng.abortEvaluation(123); { QScriptValue ret = eng.evaluate("'ciao'"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("ciao")); } } void tst_QScriptEngine::abortEvaluation_data() { QTest::addColumn("script"); QTest::newRow("while (1)") << QString::fromLatin1("while (1) { }"); QTest::newRow("while (1) i++") << QString::fromLatin1("i = 0; while (1) { i++; }"); QTest::newRow("try catch") << QString::fromLatin1("try {" " while (1) { }" "} catch(e) {" " throw new Error('Caught');" "}"); } void tst_QScriptEngine::abortEvaluation() { QFETCH(QString, script); QScriptEngine eng; EventReceiver3 receiver(&eng); eng.setProcessEventsInterval(100); for (int x = 0; x < 4; ++x) { QCoreApplication::postEvent(&receiver, new QEvent(QEvent::Type(QEvent::User+1))); receiver.resultType = EventReceiver3::AbortionResult(x); QScriptValue ret = eng.evaluate(script); switch (receiver.resultType) { case EventReceiver3::None: QVERIFY(!eng.hasUncaughtException()); QVERIFY(!ret.isValid()); break; case EventReceiver3::Number: QVERIFY(!eng.hasUncaughtException()); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 1234); break; case EventReceiver3::String: QVERIFY(!eng.hasUncaughtException()); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("Aborted")); break; case EventReceiver3::Error: QVERIFY(eng.hasUncaughtException()); QVERIFY(ret.isError()); QCOMPARE(ret.toString(), QString::fromLatin1("Error: AbortedWithError")); break; } } } void tst_QScriptEngine::abortEvaluation_tryCatch() { QScriptEngine eng; EventReceiver3 receiver(&eng); eng.setProcessEventsInterval(100); // scripts cannot intercept the abortion with try/catch for (int y = 0; y < 4; ++y) { QCoreApplication::postEvent(&receiver, new QEvent(QEvent::Type(QEvent::User+1))); receiver.resultType = EventReceiver3::AbortionResult(y); QScriptValue ret = eng.evaluate(QString::fromLatin1( "while (1) {\n" " try {\n" " (function() { while (1) { } })();\n" " } catch (e) {\n" " ;\n" " }\n" "}")); switch (receiver.resultType) { case EventReceiver3::None: QVERIFY(!eng.hasUncaughtException()); QVERIFY(!ret.isValid()); break; case EventReceiver3::Number: QVERIFY(!eng.hasUncaughtException()); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 1234); break; case EventReceiver3::String: QVERIFY(!eng.hasUncaughtException()); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("Aborted")); break; case EventReceiver3::Error: QVERIFY(eng.hasUncaughtException()); QVERIFY(ret.isError()); break; } } } void tst_QScriptEngine::abortEvaluation_fromNative() { QScriptEngine eng; QScriptValue fun = eng.newFunction(myFunctionAbortingEvaluation); eng.globalObject().setProperty("myFunctionAbortingEvaluation", fun); QScriptValue ret = eng.evaluate("myFunctionAbortingEvaluation()"); QVERIFY(!ret.isValid()); } class ThreadedEngine : public QThread { Q_OBJECT; private: QScriptEngine* m_engine; protected: void run() { m_engine = new QScriptEngine(); m_engine->setGlobalObject(m_engine->newQObject(this)); m_engine->evaluate("while(1) { sleep(); }"); delete m_engine; } public slots: void sleep() { QTest::qSleep(25); m_engine->abortEvaluation(); } }; void tst_QScriptEngine::abortEvaluation_QTBUG9433() { ThreadedEngine engine; engine.start(); QVERIFY(engine.isRunning()); QTest::qSleep(50); for (uint i = 0; i < 50; ++i) { // up to ~2500 ms if (engine.isFinished()) return; QTest::qSleep(50); } if (!engine.isFinished()) { engine.terminate(); engine.wait(7000); QFAIL("abortEvaluation doesn't work"); } } static QScriptValue myFunctionReturningIsEvaluating(QScriptContext *, QScriptEngine *eng) { return QScriptValue(eng, eng->isEvaluating()); } class EventReceiver4 : public QObject { public: EventReceiver4(QScriptEngine *eng) { engine = eng; wasEvaluating = false; } bool event(QEvent *e) { if (e->type() == QEvent::User + 1) { wasEvaluating = engine->isEvaluating(); } return QObject::event(e); } QScriptEngine *engine; bool wasEvaluating; }; void tst_QScriptEngine::isEvaluating_notEvaluating() { QScriptEngine eng; QVERIFY(!eng.isEvaluating()); eng.evaluate(""); QVERIFY(!eng.isEvaluating()); eng.evaluate("123"); QVERIFY(!eng.isEvaluating()); eng.evaluate("0 = 0"); QVERIFY(!eng.isEvaluating()); } void tst_QScriptEngine::isEvaluating_fromNative() { QScriptEngine eng; QScriptValue fun = eng.newFunction(myFunctionReturningIsEvaluating); eng.globalObject().setProperty("myFunctionReturningIsEvaluating", fun); QScriptValue ret = eng.evaluate("myFunctionReturningIsEvaluating()"); QVERIFY(ret.isBoolean()); QVERIFY(ret.toBoolean()); } void tst_QScriptEngine::isEvaluating_fromEvent() { QScriptEngine eng; EventReceiver4 receiver(&eng); QCoreApplication::postEvent(&receiver, new QEvent(QEvent::Type(QEvent::User+1))); QString script = QString::fromLatin1( "var end = Number(new Date()) + 1000;" "var x = 0;" "while (Number(new Date()) < end) {" " ++x;" "}"); eng.setProcessEventsInterval(100); eng.evaluate(script); QVERIFY(receiver.wasEvaluating); } static QtMsgType theMessageType; static QString theMessage; static void myMsgHandler(QtMsgType type, const char *msg) { theMessageType = type; theMessage = QString::fromLatin1(msg); } void tst_QScriptEngine::printFunctionWithCustomHandler() { // The built-in print() function passes the output to Qt's message // handler. By installing a custom message handler, the output can be // redirected without changing the print() function itself. // This behavior is not documented. QScriptEngine eng; QtMsgHandler oldHandler = qInstallMsgHandler(myMsgHandler); QVERIFY(eng.globalObject().property("print").isFunction()); theMessageType = QtSystemMsg; QVERIFY(theMessage.isEmpty()); QVERIFY(eng.evaluate("print('test')").isUndefined()); QCOMPARE(theMessageType, QtDebugMsg); QCOMPARE(theMessage, QString::fromLatin1("test")); theMessageType = QtSystemMsg; theMessage.clear(); QVERIFY(eng.evaluate("print(3, true, 'little pigs')").isUndefined()); QCOMPARE(theMessageType, QtDebugMsg); QCOMPARE(theMessage, QString::fromLatin1("3 true little pigs")); qInstallMsgHandler(oldHandler); } void tst_QScriptEngine::printThrowsException() { // If an argument to print() causes an exception to be thrown when // it's converted to a string, print() should propagate the exception. QScriptEngine eng; QScriptValue ret = eng.evaluate("print({ toString: function() { throw 'foo'; } });"); QVERIFY(eng.hasUncaughtException()); QVERIFY(ret.strictlyEquals(QScriptValue(&eng, QLatin1String("foo")))); } void tst_QScriptEngine::errorConstructors() { QScriptEngine eng; QStringList prefixes; prefixes << "" << "Eval" << "Range" << "Reference" << "Syntax" << "Type" << "URI"; for (int x = 0; x < 3; ++x) { for (int i = 0; i < prefixes.size(); ++i) { QString name = prefixes.at(i) + QLatin1String("Error"); QString code = QString(i+1, QLatin1Char('\n')); if (x == 0) code += QLatin1String("throw "); else if (x == 1) code += QLatin1String("new "); code += name + QLatin1String("()"); QScriptValue ret = eng.evaluate(code); QVERIFY(ret.isError()); QCOMPARE(eng.hasUncaughtException(), x == 0); eng.clearExceptions(); QVERIFY(ret.toString().startsWith(name)); if (x != 0) QEXPECT_FAIL("", "QTBUG-6138: JSC doesn't assign lineNumber when errors are not thrown", Continue); QCOMPARE(ret.property("lineNumber").toInt32(), i+2); } } } void tst_QScriptEngine::argumentsProperty_globalContext() { QScriptEngine eng; { // Unlike function calls, the global context doesn't have an // arguments property. QScriptValue ret = eng.evaluate("arguments"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains(QString::fromLatin1("ReferenceError"))); } eng.evaluate("arguments = 10"); { QScriptValue ret = eng.evaluate("arguments"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 10); } QVERIFY(eng.evaluate("delete arguments").toBoolean()); QVERIFY(!eng.globalObject().property("arguments").isValid()); } void tst_QScriptEngine::argumentsProperty_JS() { { QScriptEngine eng; eng.evaluate("o = { arguments: 123 }"); QScriptValue ret = eng.evaluate("with (o) { arguments; }"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 123); } { QScriptEngine eng; QVERIFY(!eng.globalObject().property("arguments").isValid()); // This is testing ECMA-262 compliance. In function calls, "arguments" // appears like a local variable, and it can be replaced. QScriptValue ret = eng.evaluate("(function() { arguments = 456; return arguments; })()"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 456); QVERIFY(!eng.globalObject().property("arguments").isValid()); } } static QScriptValue argumentsProperty_fun(QScriptContext *, QScriptEngine *eng) { // Since evaluate() is done in the current context, "arguments" should // refer to currentContext()->argumentsObject(). // This is for consistency with the built-in JS eval() function. eng->evaluate("var a = arguments[0];"); eng->evaluate("arguments[0] = 200;"); return eng->evaluate("a + arguments[0]"); } void tst_QScriptEngine::argumentsProperty_evaluateInNativeFunction() { QScriptEngine eng; QScriptValue fun = eng.newFunction(argumentsProperty_fun); eng.globalObject().setProperty("fun", eng.newFunction(argumentsProperty_fun)); QScriptValue result = eng.evaluate("fun(18)"); QVERIFY(result.isNumber()); QCOMPARE(result.toInt32(), 200+18); } void tst_QScriptEngine::jsNumberClass() { // See ECMA-262 Section 15.7, "Number Objects". QScriptEngine eng; QScriptValue ctor = eng.globalObject().property("Number"); QVERIFY(ctor.property("length").isNumber()); QCOMPARE(ctor.property("length").toNumber(), qsreal(1)); QScriptValue proto = ctor.property("prototype"); QVERIFY(proto.isObject()); { QScriptValue::PropertyFlags flags = QScriptValue::SkipInEnumeration | QScriptValue::Undeletable | QScriptValue::ReadOnly; QCOMPARE(ctor.propertyFlags("prototype"), flags); QVERIFY(ctor.property("MAX_VALUE").isNumber()); QCOMPARE(ctor.propertyFlags("MAX_VALUE"), flags); QVERIFY(ctor.property("MIN_VALUE").isNumber()); QCOMPARE(ctor.propertyFlags("MIN_VALUE"), flags); QVERIFY(ctor.property("NaN").isNumber()); QCOMPARE(ctor.propertyFlags("NaN"), flags); QVERIFY(ctor.property("NEGATIVE_INFINITY").isNumber()); QCOMPARE(ctor.propertyFlags("NEGATIVE_INFINITY"), flags); QVERIFY(ctor.property("POSITIVE_INFINITY").isNumber()); QCOMPARE(ctor.propertyFlags("POSITIVE_INFINITY"), flags); } QVERIFY(proto.instanceOf(eng.globalObject().property("Object"))); QCOMPARE(proto.toNumber(), qsreal(0)); QVERIFY(proto.property("constructor").strictlyEquals(ctor)); { QScriptValue ret = eng.evaluate("Number()"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toNumber(), qsreal(0)); } { QScriptValue ret = eng.evaluate("Number(123)"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toNumber(), qsreal(123)); } { QScriptValue ret = eng.evaluate("Number('456')"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toNumber(), qsreal(456)); } { QScriptValue ret = eng.evaluate("new Number()"); QVERIFY(!ret.isNumber()); QVERIFY(ret.isObject()); QCOMPARE(ret.toNumber(), qsreal(0)); } { QScriptValue ret = eng.evaluate("new Number(123)"); QVERIFY(!ret.isNumber()); QVERIFY(ret.isObject()); QCOMPARE(ret.toNumber(), qsreal(123)); } { QScriptValue ret = eng.evaluate("new Number('456')"); QVERIFY(!ret.isNumber()); QVERIFY(ret.isObject()); QCOMPARE(ret.toNumber(), qsreal(456)); } QVERIFY(proto.property("toString").isFunction()); { QScriptValue ret = eng.evaluate("new Number(123).toString()"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("123")); } { QScriptValue ret = eng.evaluate("new Number(123).toString(8)"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("173")); } { QScriptValue ret = eng.evaluate("new Number(123).toString(16)"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("7b")); } QVERIFY(proto.property("toLocaleString").isFunction()); { QScriptValue ret = eng.evaluate("new Number(123).toLocaleString()"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("123")); } QVERIFY(proto.property("valueOf").isFunction()); { QScriptValue ret = eng.evaluate("new Number(123).valueOf()"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toNumber(), qsreal(123)); } QVERIFY(proto.property("toExponential").isFunction()); { QScriptValue ret = eng.evaluate("new Number(123).toExponential()"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("1.23e+2")); } QVERIFY(proto.property("toFixed").isFunction()); { QScriptValue ret = eng.evaluate("new Number(123).toFixed()"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("123")); } QVERIFY(proto.property("toPrecision").isFunction()); { QScriptValue ret = eng.evaluate("new Number(123).toPrecision()"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("123")); } } void tst_QScriptEngine::jsForInStatement_simple() { QScriptEngine eng; { QScriptValue ret = eng.evaluate("o = { }; r = []; for (var p in o) r[r.length] = p; r"); QStringList lst = qscriptvalue_cast(ret); QVERIFY(lst.isEmpty()); } { QScriptValue ret = eng.evaluate("o = { p: 123 }; r = [];" "for (var p in o) r[r.length] = p; r"); QStringList lst = qscriptvalue_cast(ret); QCOMPARE(lst.size(), 1); QCOMPARE(lst.at(0), QString::fromLatin1("p")); } { QScriptValue ret = eng.evaluate("o = { p: 123, q: 456 }; r = [];" "for (var p in o) r[r.length] = p; r"); QStringList lst = qscriptvalue_cast(ret); QCOMPARE(lst.size(), 2); QCOMPARE(lst.at(0), QString::fromLatin1("p")); QCOMPARE(lst.at(1), QString::fromLatin1("q")); } } void tst_QScriptEngine::jsForInStatement_prototypeProperties() { QScriptEngine eng; { QScriptValue ret = eng.evaluate("o = { }; o.__proto__ = { p: 123 }; r = [];" "for (var p in o) r[r.length] = p; r"); QStringList lst = qscriptvalue_cast(ret); QCOMPARE(lst.size(), 1); QCOMPARE(lst.at(0), QString::fromLatin1("p")); } { QScriptValue ret = eng.evaluate("o = { p: 123 }; o.__proto__ = { q: 456 }; r = [];" "for (var p in o) r[r.length] = p; r"); QStringList lst = qscriptvalue_cast(ret); QCOMPARE(lst.size(), 2); QCOMPARE(lst.at(0), QString::fromLatin1("p")); QCOMPARE(lst.at(1), QString::fromLatin1("q")); } { // shadowed property QScriptValue ret = eng.evaluate("o = { p: 123 }; o.__proto__ = { p: 456 }; r = [];" "for (var p in o) r[r.length] = p; r"); QStringList lst = qscriptvalue_cast(ret); QCOMPARE(lst.size(), 1); QCOMPARE(lst.at(0), QString::fromLatin1("p")); } } void tst_QScriptEngine::jsForInStatement_mutateWhileIterating() { QScriptEngine eng; // deleting property during enumeration { QScriptValue ret = eng.evaluate("o = { p: 123 }; r = [];" "for (var p in o) { r[r.length] = p; delete r[p]; } r"); QStringList lst = qscriptvalue_cast(ret); QCOMPARE(lst.size(), 1); QCOMPARE(lst.at(0), QString::fromLatin1("p")); } { QScriptValue ret = eng.evaluate("o = { p: 123, q: 456 }; r = [];" "for (var p in o) { r[r.length] = p; delete o.q; } r"); QStringList lst = qscriptvalue_cast(ret); QCOMPARE(lst.size(), 1); QCOMPARE(lst.at(0), QString::fromLatin1("p")); } // adding property during enumeration { QScriptValue ret = eng.evaluate("o = { p: 123 }; r = [];" "for (var p in o) { r[r.length] = p; o.q = 456; } r"); QStringList lst = qscriptvalue_cast(ret); QCOMPARE(lst.size(), 1); QCOMPARE(lst.at(0), QString::fromLatin1("p")); } } void tst_QScriptEngine::jsForInStatement_arrays() { QScriptEngine eng; { QScriptValue ret = eng.evaluate("a = [123, 456]; r = [];" "for (var p in a) r[r.length] = p; r"); QStringList lst = qscriptvalue_cast(ret); QCOMPARE(lst.size(), 2); QCOMPARE(lst.at(0), QString::fromLatin1("0")); QCOMPARE(lst.at(1), QString::fromLatin1("1")); } { QScriptValue ret = eng.evaluate("a = [123, 456]; a.foo = 'bar'; r = [];" "for (var p in a) r[r.length] = p; r"); QStringList lst = qscriptvalue_cast(ret); QCOMPARE(lst.size(), 3); QCOMPARE(lst.at(0), QString::fromLatin1("0")); QCOMPARE(lst.at(1), QString::fromLatin1("1")); QCOMPARE(lst.at(2), QString::fromLatin1("foo")); } { QScriptValue ret = eng.evaluate("a = [123, 456]; a.foo = 'bar';" "b = [111, 222, 333]; b.bar = 'baz';" "a.__proto__ = b; r = [];" "for (var p in a) r[r.length] = p; r"); QStringList lst = qscriptvalue_cast(ret); QCOMPARE(lst.size(), 5); QCOMPARE(lst.at(0), QString::fromLatin1("0")); QCOMPARE(lst.at(1), QString::fromLatin1("1")); QCOMPARE(lst.at(2), QString::fromLatin1("foo")); QCOMPARE(lst.at(3), QString::fromLatin1("2")); QCOMPARE(lst.at(4), QString::fromLatin1("bar")); } } void tst_QScriptEngine::jsForInStatement_nullAndUndefined() { QScriptEngine eng; { QScriptValue ret = eng.evaluate("r = true; for (var p in undefined) r = false; r"); QVERIFY(ret.isBool()); QVERIFY(ret.toBool()); } { QScriptValue ret = eng.evaluate("r = true; for (var p in null) r = false; r"); QVERIFY(ret.isBool()); QVERIFY(ret.toBool()); } } void tst_QScriptEngine::jsFunctionDeclarationAsStatement() { // ECMA-262 does not allow function declarations to be used as statements, // but several popular implementations (including JSC) do. See the NOTE // at the beginning of chapter 12 in ECMA-262 5th edition, where it's // recommended that implementations either disallow this usage or issue // a warning. // Since we had a bug report long ago about QtScript not supporting this // "feature" (and thus deviating from other implementations), we still // check this behavior. QScriptEngine eng; QVERIFY(!eng.globalObject().property("bar").isValid()); eng.evaluate("function foo(arg) {\n" " if (arg == 'bar')\n" " function bar() { return 'bar'; }\n" " else\n" " function baz() { return 'baz'; }\n" " return (arg == 'bar') ? bar : baz;\n" "}"); QVERIFY(!eng.globalObject().property("bar").isValid()); QVERIFY(!eng.globalObject().property("baz").isValid()); QVERIFY(eng.evaluate("foo").isFunction()); { QScriptValue ret = eng.evaluate("foo('bar')"); QVERIFY(ret.isFunction()); QScriptValue ret2 = ret.call(QScriptValue()); QCOMPARE(ret2.toString(), QString::fromLatin1("bar")); QVERIFY(!eng.globalObject().property("bar").isValid()); QVERIFY(!eng.globalObject().property("baz").isValid()); } { QScriptValue ret = eng.evaluate("foo('baz')"); QVERIFY(ret.isFunction()); QScriptValue ret2 = ret.call(QScriptValue()); QCOMPARE(ret2.toString(), QString::fromLatin1("baz")); QVERIFY(!eng.globalObject().property("bar").isValid()); QVERIFY(!eng.globalObject().property("baz").isValid()); } } void tst_QScriptEngine::stringObjects() { // See ECMA-262 Section 15.5, "String Objects". QScriptEngine eng; QString str("ciao"); // in C++ { QScriptValue obj = QScriptValue(&eng, str).toObject(); QCOMPARE(obj.property("length").toInt32(), str.length()); QCOMPARE(obj.propertyFlags("length"), QScriptValue::PropertyFlags(QScriptValue::Undeletable | QScriptValue::SkipInEnumeration | QScriptValue::ReadOnly)); for (int i = 0; i < str.length(); ++i) { QString pname = QString::number(i); QVERIFY(obj.property(pname).isString()); QCOMPARE(obj.property(pname).toString(), QString(str.at(i))); QCOMPARE(obj.propertyFlags(pname), QScriptValue::PropertyFlags(QScriptValue::Undeletable | QScriptValue::ReadOnly)); obj.setProperty(pname, QScriptValue()); obj.setProperty(pname, QScriptValue(&eng, 123)); QVERIFY(obj.property(pname).isString()); QCOMPARE(obj.property(pname).toString(), QString(str.at(i))); } QVERIFY(!obj.property("-1").isValid()); QVERIFY(!obj.property(QString::number(str.length())).isValid()); QScriptValue val(&eng, 123); obj.setProperty("-1", val); QVERIFY(obj.property("-1").strictlyEquals(val)); obj.setProperty("100", val); QVERIFY(obj.property("100").strictlyEquals(val)); } // in script { QScriptValue ret = eng.evaluate("s = new String('ciao'); r = []; for (var p in s) r.push(p); r"); QVERIFY(ret.isArray()); QStringList lst = qscriptvalue_cast(ret); QCOMPARE(lst.size(), str.length()); for (int i = 0; i < str.length(); ++i) QCOMPARE(lst.at(i), QString::number(i)); QScriptValue ret2 = eng.evaluate("s[0] = 123; s[0]"); QVERIFY(ret2.isString()); QCOMPARE(ret2.toString().length(), 1); QCOMPARE(ret2.toString().at(0), str.at(0)); QScriptValue ret3 = eng.evaluate("s[-1] = 123; s[-1]"); QVERIFY(ret3.isNumber()); QCOMPARE(ret3.toInt32(), 123); QScriptValue ret4 = eng.evaluate("s[s.length] = 456; s[s.length]"); QVERIFY(ret4.isNumber()); QCOMPARE(ret4.toInt32(), 456); QScriptValue ret5 = eng.evaluate("delete s[0]"); QVERIFY(ret5.isBoolean()); QVERIFY(!ret5.toBoolean()); QScriptValue ret6 = eng.evaluate("delete s[-1]"); QVERIFY(ret6.isBoolean()); QVERIFY(ret6.toBoolean()); QScriptValue ret7 = eng.evaluate("delete s[s.length]"); QVERIFY(ret7.isBoolean()); QVERIFY(ret7.toBoolean()); } } void tst_QScriptEngine::jsStringPrototypeReplaceBugs() { QScriptEngine eng; // task 212440 { QScriptValue ret = eng.evaluate("replace_args = []; \"a a a\".replace(/(a)/g, function() { replace_args.push(arguments); }); replace_args"); QVERIFY(ret.isArray()); int len = ret.property("length").toInt32(); QCOMPARE(len, 3); for (int i = 0; i < len; ++i) { QScriptValue args = ret.property(i); QCOMPARE(args.property("length").toInt32(), 4); QCOMPARE(args.property(0).toString(), QString::fromLatin1("a")); // matched string QCOMPARE(args.property(1).toString(), QString::fromLatin1("a")); // capture QVERIFY(args.property(2).isNumber()); QCOMPARE(args.property(2).toInt32(), i*2); // index of match QCOMPARE(args.property(3).toString(), QString::fromLatin1("a a a")); } } // task 212501 { QScriptValue ret = eng.evaluate("\"foo\".replace(/a/g, function() {})"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("foo")); } } void tst_QScriptEngine::getterSetterThisObject_global() { { QScriptEngine eng; // read eng.evaluate("__defineGetter__('x', function() { return this; });"); { QScriptValue ret = eng.evaluate("x"); QVERIFY(ret.equals(eng.globalObject())); } { QScriptValue ret = eng.evaluate("(function() { return x; })()"); QVERIFY(ret.equals(eng.globalObject())); } { QScriptValue ret = eng.evaluate("with (this) x"); QVERIFY(ret.equals(eng.globalObject())); } { QScriptValue ret = eng.evaluate("with ({}) x"); QVERIFY(ret.equals(eng.globalObject())); } { QScriptValue ret = eng.evaluate("(function() { with ({}) return x; })()"); QVERIFY(ret.equals(eng.globalObject())); } // write eng.evaluate("__defineSetter__('x', function() { return this; });"); { QScriptValue ret = eng.evaluate("x = 'foo'"); // SpiderMonkey says setter return value, JSC says RHS. QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("foo")); } { QScriptValue ret = eng.evaluate("(function() { return x = 'foo'; })()"); // SpiderMonkey says setter return value, JSC says RHS. QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("foo")); } { QScriptValue ret = eng.evaluate("with (this) x = 'foo'"); // SpiderMonkey says setter return value, JSC says RHS. QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("foo")); } { QScriptValue ret = eng.evaluate("with ({}) x = 'foo'"); // SpiderMonkey says setter return value, JSC says RHS. QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("foo")); } { QScriptValue ret = eng.evaluate("(function() { with ({}) return x = 'foo'; })()"); // SpiderMonkey says setter return value, JSC says RHS. QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("foo")); } } } void tst_QScriptEngine::getterSetterThisObject_plain() { { QScriptEngine eng; eng.evaluate("o = {}"); // read eng.evaluate("o.__defineGetter__('x', function() { return this; })"); QVERIFY(eng.evaluate("o.x === o").toBoolean()); QVERIFY(eng.evaluate("with (o) x").equals(eng.evaluate("o"))); QVERIFY(eng.evaluate("(function() { with (o) return x; })() === o").toBoolean()); eng.evaluate("q = {}; with (o) with (q) x").equals(eng.evaluate("o")); // write eng.evaluate("o.__defineSetter__('x', function() { return this; });"); // SpiderMonkey says setter return value, JSC says RHS. QVERIFY(eng.evaluate("(o.x = 'foo') === 'foo'").toBoolean()); QVERIFY(eng.evaluate("with (o) x = 'foo'").equals("foo")); QVERIFY(eng.evaluate("with (o) with (q) x = 'foo'").equals("foo")); } } void tst_QScriptEngine::getterSetterThisObject_prototypeChain() { { QScriptEngine eng; eng.evaluate("o = {}; p = {}; o.__proto__ = p"); // read eng.evaluate("p.__defineGetter__('x', function() { return this; })"); QVERIFY(eng.evaluate("o.x === o").toBoolean()); QVERIFY(eng.evaluate("with (o) x").equals(eng.evaluate("o"))); QVERIFY(eng.evaluate("(function() { with (o) return x; })() === o").toBoolean()); eng.evaluate("q = {}; with (o) with (q) x").equals(eng.evaluate("o")); eng.evaluate("with (q) with (o) x").equals(eng.evaluate("o")); // write eng.evaluate("o.__defineSetter__('x', function() { return this; });"); // SpiderMonkey says setter return value, JSC says RHS. QVERIFY(eng.evaluate("(o.x = 'foo') === 'foo'").toBoolean()); QVERIFY(eng.evaluate("with (o) x = 'foo'").equals("foo")); QVERIFY(eng.evaluate("with (o) with (q) x = 'foo'").equals("foo")); } } void tst_QScriptEngine::getterSetterThisObject_activation() { { QScriptEngine eng; QScriptContext *ctx = eng.pushContext(); QVERIFY(ctx != 0); QScriptValue act = ctx->activationObject(); act.setProperty("act", act); // read eng.evaluate("act.__defineGetter__('x', function() { return this; })"); QVERIFY(eng.evaluate("x === act").toBoolean()); QEXPECT_FAIL("", "QTBUG-17605: Not possible to implement local variables as getter/setter properties", Abort); QVERIFY(!eng.hasUncaughtException()); QVERIFY(eng.evaluate("with (act) x").equals("foo")); QVERIFY(eng.evaluate("(function() { with (act) return x; })() === act").toBoolean()); eng.evaluate("q = {}; with (act) with (q) x").equals(eng.evaluate("act")); eng.evaluate("with (q) with (act) x").equals(eng.evaluate("act")); // write eng.evaluate("act.__defineSetter__('x', function() { return this; });"); QVERIFY(eng.evaluate("(x = 'foo') === 'foo'").toBoolean()); QVERIFY(eng.evaluate("with (act) x = 'foo'").equals("foo")); QVERIFY(eng.evaluate("with (act) with (q) x = 'foo'").equals("foo")); eng.popContext(); } } void tst_QScriptEngine::jsContinueInSwitch() { // This is testing ECMA-262 compliance, not C++ API. QScriptEngine eng; // switch - continue { QScriptValue ret = eng.evaluate("switch (1) { default: continue; }"); QVERIFY(ret.isError()); } // for - switch - case - continue { QScriptValue ret = eng.evaluate("j = 0; for (i = 0; i < 100000; ++i) {\n" " switch (i) {\n" " case 1: ++j; continue;\n" " case 100: ++j; continue;\n" " case 1000: ++j; continue;\n" " }\n" "}; j"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 3); } // for - switch - case - default - continue { QScriptValue ret = eng.evaluate("j = 0; for (i = 0; i < 100000; ++i) {\n" " switch (i) {\n" " case 1: ++j; continue;\n" " case 100: ++j; continue;\n" " case 1000: ++j; continue;\n" " default: if (i < 50000) break; else continue;\n" " }\n" "}; j"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 3); } // switch - for - continue { QScriptValue ret = eng.evaluate("j = 123; switch (j) {\n" " case 123:\n" " for (i = 0; i < 100000; ++i) {\n" " continue;\n" " }\n" "}; i\n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 100000); } // switch - switch - continue { QScriptValue ret = eng.evaluate("i = 1; switch (i) { default: switch (i) { case 1: continue; } }"); QVERIFY(ret.isError()); } // for - switch - switch - continue { QScriptValue ret = eng.evaluate("j = 0; for (i = 0; i < 100000; ++i) {\n" " switch (i) {\n" " case 1:\n" " switch (i) {\n" " case 1: ++j; continue;\n" " }\n" " }\n" "}; j"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 1); } // switch - for - switch - continue { QScriptValue ret = eng.evaluate("j = 123; switch (j) {\n" " case 123:\n" " for (i = 0; i < 100000; ++i) {\n" " switch (i) {\n" " case 1:\n" " ++j; continue;\n" " }\n" " }\n" "}; i\n"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 100000); } } void tst_QScriptEngine::jsShadowReadOnlyPrototypeProperty() { // SpiderMonkey has different behavior than JSC and V8; it disallows // creating a property on the instance if there's a property with the // same name in the prototype, and that property is read-only. We // adopted that behavior in the old (4.5) QtScript back-end, but it // just seems weird -- and non-compliant. Adopt the JSC behavior instead. QScriptEngine eng; QVERIFY(eng.evaluate("o = {}; o.__proto__ = parseInt; o.length").isNumber()); QCOMPARE(eng.evaluate("o.length = 123; o.length").toInt32(), 123); QVERIFY(eng.evaluate("o.hasOwnProperty('length')").toBoolean()); } void tst_QScriptEngine::toObject() { QScriptEngine eng; QVERIFY(!eng.toObject(eng.undefinedValue()).isValid()); QVERIFY(!eng.toObject(eng.nullValue()).isValid()); QScriptValue falskt(false); { QScriptValue tmp = eng.toObject(falskt); QVERIFY(tmp.isObject()); QCOMPARE(tmp.toNumber(), falskt.toNumber()); } QVERIFY(falskt.isBool()); QScriptValue sant(true); { QScriptValue tmp = eng.toObject(sant); QVERIFY(tmp.isObject()); QCOMPARE(tmp.toNumber(), sant.toNumber()); } QVERIFY(sant.isBool()); QScriptValue number(123.0); { QScriptValue tmp = eng.toObject(number); QVERIFY(tmp.isObject()); QCOMPARE(tmp.toNumber(), number.toNumber()); } QVERIFY(number.isNumber()); QScriptValue str = QScriptValue(&eng, QString("ciao")); { QScriptValue tmp = eng.toObject(str); QVERIFY(tmp.isObject()); QCOMPARE(tmp.toString(), str.toString()); } QVERIFY(str.isString()); QScriptValue object = eng.newObject(); { QScriptValue tmp = eng.toObject(object); QVERIFY(tmp.isObject()); QVERIFY(tmp.strictlyEquals(object)); } QScriptValue qobject = eng.newQObject(this); QVERIFY(eng.toObject(qobject).strictlyEquals(qobject)); QVERIFY(!eng.toObject(QScriptValue()).isValid()); // v1 constructors QScriptValue boolValue(&eng, true); { QScriptValue ret = eng.toObject(boolValue); QVERIFY(ret.isObject()); QCOMPARE(ret.toBool(), boolValue.toBool()); } QVERIFY(boolValue.isBool()); QScriptValue numberValue(&eng, 123.0); { QScriptValue ret = eng.toObject(numberValue); QVERIFY(ret.isObject()); QCOMPARE(ret.toNumber(), numberValue.toNumber()); } QVERIFY(numberValue.isNumber()); QScriptValue stringValue(&eng, QString::fromLatin1("foo")); { QScriptValue ret = eng.toObject(stringValue); QVERIFY(ret.isObject()); QCOMPARE(ret.toString(), stringValue.toString()); } QVERIFY(stringValue.isString()); } void tst_QScriptEngine::jsReservedWords_data() { QTest::addColumn("word"); QTest::newRow("break") << QString("break"); QTest::newRow("case") << QString("case"); QTest::newRow("catch") << QString("catch"); QTest::newRow("continue") << QString("continue"); QTest::newRow("default") << QString("default"); QTest::newRow("delete") << QString("delete"); QTest::newRow("do") << QString("do"); QTest::newRow("else") << QString("else"); QTest::newRow("false") << QString("false"); QTest::newRow("finally") << QString("finally"); QTest::newRow("for") << QString("for"); QTest::newRow("function") << QString("function"); QTest::newRow("if") << QString("if"); QTest::newRow("in") << QString("in"); QTest::newRow("instanceof") << QString("instanceof"); QTest::newRow("new") << QString("new"); QTest::newRow("null") << QString("null"); QTest::newRow("return") << QString("return"); QTest::newRow("switch") << QString("switch"); QTest::newRow("this") << QString("this"); QTest::newRow("throw") << QString("throw"); QTest::newRow("true") << QString("true"); QTest::newRow("try") << QString("try"); QTest::newRow("typeof") << QString("typeof"); QTest::newRow("var") << QString("var"); QTest::newRow("void") << QString("void"); QTest::newRow("while") << QString("while"); QTest::newRow("with") << QString("with"); } void tst_QScriptEngine::jsReservedWords() { // See ECMA-262 Section 7.6.1, "Reserved Words". // We prefer that the implementation is less strict than the spec; e.g. // it's good to allow reserved words as identifiers in object literals, // and when accessing properties using dot notation. QFETCH(QString, word); { QScriptEngine eng; QScriptValue ret = eng.evaluate(word + " = 123"); QVERIFY(ret.isError()); QString str = ret.toString(); QVERIFY(str.startsWith("SyntaxError") || str.startsWith("ReferenceError")); } { QScriptEngine eng; QScriptValue ret = eng.evaluate("var " + word + " = 123"); QVERIFY(ret.isError()); QVERIFY(ret.toString().startsWith("SyntaxError")); } { QScriptEngine eng; QScriptValue ret = eng.evaluate("o = {}; o." + word + " = 123"); // in the old back-end and in SpiderMonkey this is allowed, but not in JSC QVERIFY(ret.isError()); QVERIFY(ret.toString().startsWith("SyntaxError")); } { QScriptEngine eng; QScriptValue ret = eng.evaluate("o = { " + word + ": 123 }"); // in the old back-end and in SpiderMonkey this is allowed, but not in JSC QVERIFY(ret.isError()); QVERIFY(ret.toString().startsWith("SyntaxError")); } { // SpiderMonkey allows this, but we don't QScriptEngine eng; QScriptValue ret = eng.evaluate("function " + word + "() {}"); QVERIFY(ret.isError()); QVERIFY(ret.toString().startsWith("SyntaxError")); } } void tst_QScriptEngine::jsFutureReservedWords_data() { QTest::addColumn("word"); QTest::addColumn("allowed"); QTest::newRow("abstract") << QString("abstract") << true; QTest::newRow("boolean") << QString("boolean") << true; QTest::newRow("byte") << QString("byte") << true; QTest::newRow("char") << QString("char") << true; QTest::newRow("class") << QString("class") << false; QTest::newRow("const") << QString("const") << false; QTest::newRow("debugger") << QString("debugger") << false; QTest::newRow("double") << QString("double") << true; QTest::newRow("enum") << QString("enum") << false; QTest::newRow("export") << QString("export") << false; QTest::newRow("extends") << QString("extends") << false; QTest::newRow("final") << QString("final") << true; QTest::newRow("float") << QString("float") << true; QTest::newRow("goto") << QString("goto") << true; QTest::newRow("implements") << QString("implements") << true; QTest::newRow("import") << QString("import") << false; QTest::newRow("int") << QString("int") << true; QTest::newRow("interface") << QString("interface") << true; QTest::newRow("long") << QString("long") << true; QTest::newRow("native") << QString("native") << true; QTest::newRow("package") << QString("package") << true; QTest::newRow("private") << QString("private") << true; QTest::newRow("protected") << QString("protected") << true; QTest::newRow("public") << QString("public") << true; QTest::newRow("short") << QString("short") << true; QTest::newRow("static") << QString("static") << true; QTest::newRow("super") << QString("super") << false; QTest::newRow("synchronized") << QString("synchronized") << true; QTest::newRow("throws") << QString("throws") << true; QTest::newRow("transient") << QString("transient") << true; QTest::newRow("volatile") << QString("volatile") << true; } void tst_QScriptEngine::jsFutureReservedWords() { // See ECMA-262 Section 7.6.1.2, "Future Reserved Words". // In real-world implementations, most of these words are // actually allowed as normal identifiers. QFETCH(QString, word); QFETCH(bool, allowed); { QScriptEngine eng; QScriptValue ret = eng.evaluate(word + " = 123"); QCOMPARE(!ret.isError(), allowed); } { QScriptEngine eng; QScriptValue ret = eng.evaluate("var " + word + " = 123"); QCOMPARE(!ret.isError(), allowed); } { // this should probably be allowed (see task 162567) QScriptEngine eng; QScriptValue ret = eng.evaluate("o = {}; o." + word + " = 123"); QCOMPARE(ret.isNumber(), allowed); QCOMPARE(!ret.isError(), allowed); } { // this should probably be allowed (see task 162567) QScriptEngine eng; QScriptValue ret = eng.evaluate("o = { " + word + ": 123 }"); QCOMPARE(!ret.isError(), allowed); } } void tst_QScriptEngine::jsThrowInsideWithStatement() { // This is testing ECMA-262 compliance, not C++ API. // task 209988 QScriptEngine eng; { QScriptValue ret = eng.evaluate( "try {" " o = { bad : \"bug\" };" " with (o) {" " throw 123;" " }" "} catch (e) {" " bad;" "}"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains(QString::fromLatin1("ReferenceError"))); } { QScriptValue ret = eng.evaluate( "try {" " o = { bad : \"bug\" };" " with (o) {" " throw 123;" " }" "} finally {" " bad;" "}"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains(QString::fromLatin1("ReferenceError"))); } { eng.clearExceptions(); QScriptValue ret = eng.evaluate( "o = { bug : \"no bug\" };" "with (o) {" " try {" " throw 123;" " } finally {" " bug;" " }" "}"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 123); QVERIFY(eng.hasUncaughtException()); } { eng.clearExceptions(); QScriptValue ret = eng.evaluate( "o = { bug : \"no bug\" };" "with (o) {" " throw 123;" "}"); QVERIFY(ret.isNumber()); QScriptValue ret2 = eng.evaluate("bug"); QVERIFY(ret2.isError()); QVERIFY(ret2.toString().contains(QString::fromLatin1("ReferenceError"))); } } class TestAgent : public QScriptEngineAgent { public: TestAgent(QScriptEngine *engine) : QScriptEngineAgent(engine) {} }; void tst_QScriptEngine::getSetAgent_ownership() { // engine deleted before agent --> agent deleted too QScriptEngine *eng = new QScriptEngine; QCOMPARE(eng->agent(), (QScriptEngineAgent*)0); TestAgent *agent = new TestAgent(eng); eng->setAgent(agent); QCOMPARE(eng->agent(), (QScriptEngineAgent*)agent); eng->setAgent(0); // the engine maintains ownership of the old agent QCOMPARE(eng->agent(), (QScriptEngineAgent*)0); delete eng; } void tst_QScriptEngine::getSetAgent_deleteAgent() { // agent deleted before engine --> engine's agent should become 0 QScriptEngine *eng = new QScriptEngine; TestAgent *agent = new TestAgent(eng); eng->setAgent(agent); QCOMPARE(eng->agent(), (QScriptEngineAgent*)agent); delete agent; QCOMPARE(eng->agent(), (QScriptEngineAgent*)0); eng->evaluate("(function(){ return 123; })()"); delete eng; } void tst_QScriptEngine::getSetAgent_differentEngine() { QScriptEngine eng; QScriptEngine eng2; TestAgent *agent = new TestAgent(&eng); QTest::ignoreMessage(QtWarningMsg, "QScriptEngine::setAgent(): cannot set agent belonging to different engine"); eng2.setAgent(agent); QCOMPARE(eng2.agent(), (QScriptEngineAgent*)0); } void tst_QScriptEngine::reentrancy_stringHandles() { QScriptEngine eng1; QScriptEngine eng2; QScriptString s1 = eng1.toStringHandle("foo"); QScriptString s2 = eng2.toStringHandle("foo"); QVERIFY(s1 != s2); } void tst_QScriptEngine::reentrancy_processEventsInterval() { QScriptEngine eng1; QScriptEngine eng2; eng1.setProcessEventsInterval(123); QCOMPARE(eng2.processEventsInterval(), -1); eng2.setProcessEventsInterval(456); QCOMPARE(eng1.processEventsInterval(), 123); } void tst_QScriptEngine::reentrancy_typeConversion() { QScriptEngine eng1; QScriptEngine eng2; qScriptRegisterMetaType(&eng1, fooToScriptValue, fooFromScriptValue); Foo foo; foo.x = 12; foo.y = 34; { QScriptValue fooVal = qScriptValueFromValue(&eng1, foo); QVERIFY(fooVal.isObject()); QVERIFY(!fooVal.isVariant()); QCOMPARE(fooVal.property("x").toInt32(), 12); QCOMPARE(fooVal.property("y").toInt32(), 34); fooVal.setProperty("x", 56); fooVal.setProperty("y", 78); Foo foo2 = qScriptValueToValue(fooVal); QCOMPARE(foo2.x, 56); QCOMPARE(foo2.y, 78); } { QScriptValue fooVal = qScriptValueFromValue(&eng2, foo); QVERIFY(fooVal.isVariant()); Foo foo2 = qScriptValueToValue(fooVal); QCOMPARE(foo2.x, 12); QCOMPARE(foo2.y, 34); } QVERIFY(!eng1.defaultPrototype(qMetaTypeId()).isValid()); QVERIFY(!eng2.defaultPrototype(qMetaTypeId()).isValid()); QScriptValue proto1 = eng1.newObject(); eng1.setDefaultPrototype(qMetaTypeId(), proto1); QVERIFY(!eng2.defaultPrototype(qMetaTypeId()).isValid()); QScriptValue proto2 = eng2.newObject(); eng2.setDefaultPrototype(qMetaTypeId(), proto2); QVERIFY(eng2.defaultPrototype(qMetaTypeId()).isValid()); QVERIFY(eng1.defaultPrototype(qMetaTypeId()).strictlyEquals(proto1)); } void tst_QScriptEngine::reentrancy_globalObjectProperties() { QScriptEngine eng1; QScriptEngine eng2; QVERIFY(!eng2.globalObject().property("a").isValid()); eng1.evaluate("a = 10"); QVERIFY(eng1.globalObject().property("a").isNumber()); QVERIFY(!eng2.globalObject().property("a").isValid()); eng2.evaluate("a = 20"); QVERIFY(eng2.globalObject().property("a").isNumber()); QCOMPARE(eng1.globalObject().property("a").toInt32(), 10); } void tst_QScriptEngine::reentrancy_Array() { // weird bug with JSC backend { QScriptEngine eng; QCOMPARE(eng.evaluate("Array()").toString(), QString()); eng.evaluate("Array.prototype.toString"); QCOMPARE(eng.evaluate("Array()").toString(), QString()); } { QScriptEngine eng; QCOMPARE(eng.evaluate("Array()").toString(), QString()); } } void tst_QScriptEngine::reentrancy_objectCreation() { QScriptEngine eng1; QScriptEngine eng2; { QScriptValue d1 = eng1.newDate(0); QScriptValue d2 = eng2.newDate(0); QCOMPARE(d1.toDateTime(), d2.toDateTime()); QCOMPARE(d2.toDateTime(), d1.toDateTime()); } { QScriptValue r1 = eng1.newRegExp("foo", "gim"); QScriptValue r2 = eng2.newRegExp("foo", "gim"); QCOMPARE(r1.toRegExp(), r2.toRegExp()); QCOMPARE(r2.toRegExp(), r1.toRegExp()); } { QScriptValue o1 = eng1.newQObject(this); QScriptValue o2 = eng2.newQObject(this); QCOMPARE(o1.toQObject(), o2.toQObject()); QCOMPARE(o2.toQObject(), o1.toQObject()); } { QScriptValue mo1 = eng1.newQMetaObject(&staticMetaObject); QScriptValue mo2 = eng2.newQMetaObject(&staticMetaObject); QCOMPARE(mo1.toQMetaObject(), mo2.toQMetaObject()); QCOMPARE(mo2.toQMetaObject(), mo1.toQMetaObject()); } } void tst_QScriptEngine::jsIncDecNonObjectProperty() { // This is testing ECMA-262 compliance, not C++ API. QScriptEngine eng; { QScriptValue ret = eng.evaluate("var a; a.n++"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); } { QScriptValue ret = eng.evaluate("var a; a.n--"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); } { QScriptValue ret = eng.evaluate("var a = null; a.n++"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); } { QScriptValue ret = eng.evaluate("var a = null; a.n--"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); } { QScriptValue ret = eng.evaluate("var a; ++a.n"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); } { QScriptValue ret = eng.evaluate("var a; --a.n"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); } { QScriptValue ret = eng.evaluate("var a; a.n += 1"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); } { QScriptValue ret = eng.evaluate("var a; a.n -= 1"); QVERIFY(ret.isError()); QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); } { QScriptValue ret = eng.evaluate("var a = 'ciao'; a.length++"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 4); } { QScriptValue ret = eng.evaluate("var a = 'ciao'; a.length--"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 4); } { QScriptValue ret = eng.evaluate("var a = 'ciao'; ++a.length"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 5); } { QScriptValue ret = eng.evaluate("var a = 'ciao'; --a.length"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 3); } } void tst_QScriptEngine::installTranslatorFunctions_data() { QTest::addColumn("useCustomGlobalObject"); QTest::newRow("Default global object") << false; QTest::newRow("Custom global object") << true; } void tst_QScriptEngine::installTranslatorFunctions() { QFETCH(bool, useCustomGlobalObject); QScriptEngine eng; QScriptValue globalOrig = eng.globalObject(); QScriptValue global; if (useCustomGlobalObject) { global = eng.newObject(); eng.setGlobalObject(global); } else { global = globalOrig; } QVERIFY(!global.property("qsTranslate").isValid()); QVERIFY(!global.property("QT_TRANSLATE_NOOP").isValid()); QVERIFY(!global.property("qsTr").isValid()); QVERIFY(!global.property("QT_TR_NOOP").isValid()); QVERIFY(!global.property("qsTrId").isValid()); QVERIFY(!global.property("QT_TRID_NOOP").isValid()); QVERIFY(!globalOrig.property("String").property("prototype").property("arg").isValid()); eng.installTranslatorFunctions(); QVERIFY(global.property("qsTranslate").isFunction()); QVERIFY(global.property("QT_TRANSLATE_NOOP").isFunction()); QVERIFY(global.property("qsTr").isFunction()); QVERIFY(global.property("QT_TR_NOOP").isFunction()); QVERIFY(global.property("qsTrId").isFunction()); QVERIFY(global.property("QT_TRID_NOOP").isFunction()); QVERIFY(globalOrig.property("String").property("prototype").property("arg").isFunction()); if (useCustomGlobalObject) { QVERIFY(!globalOrig.property("qsTranslate").isValid()); QVERIFY(!globalOrig.property("QT_TRANSLATE_NOOP").isValid()); QVERIFY(!globalOrig.property("qsTr").isValid()); QVERIFY(!globalOrig.property("QT_TR_NOOP").isValid()); QVERIFY(!globalOrig.property("qsTrId").isValid()); QVERIFY(!globalOrig.property("QT_TRID_NOOP").isValid()); } { QScriptValue ret = eng.evaluate("qsTr('foo')"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("foo")); } { QScriptValue ret = eng.evaluate("qsTranslate('foo', 'bar')"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("bar")); } { QScriptValue ret = eng.evaluate("QT_TR_NOOP('foo')"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("foo")); } { QScriptValue ret = eng.evaluate("QT_TRANSLATE_NOOP('foo', 'bar')"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("bar")); } { QScriptValue ret = eng.evaluate("'foo%0'.arg('bar')"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("foobar")); } { QScriptValue ret = eng.evaluate("'foo%0'.arg(123)"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("foo123")); } { // Maybe this should throw an error? QScriptValue ret = eng.evaluate("'foo%0'.arg()"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString()); } { QScriptValue ret = eng.evaluate("qsTrId('foo')"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("foo")); } { QScriptValue ret = eng.evaluate("QT_TRID_NOOP('foo')"); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), QString::fromLatin1("foo")); } QVERIFY(eng.evaluate("QT_TRID_NOOP()").isUndefined()); } class TranslationScope { public: TranslationScope(const QString &fileName) { translator.load(fileName); QCoreApplication::instance()->installTranslator(&translator); } ~TranslationScope() { QCoreApplication::instance()->removeTranslator(&translator); } private: QTranslator translator; }; void tst_QScriptEngine::translateScript_data() { QTest::addColumn("expression"); QTest::addColumn("fileName"); QTest::addColumn("expectedTranslation"); QString fileName = QString::fromLatin1("translatable.js"); // Top-level QTest::newRow("qsTr('One')@translatable.js") << QString::fromLatin1("qsTr('One')") << fileName << QString::fromLatin1("En"); QTest::newRow("qsTr('Hello')@translatable.js") << QString::fromLatin1("qsTr('Hello')") << fileName << QString::fromLatin1("Hallo"); // From function QTest::newRow("(function() { return qsTr('One'); })()@translatable.js") << QString::fromLatin1("(function() { return qsTr('One'); })()") << fileName << QString::fromLatin1("En"); QTest::newRow("(function() { return qsTr('Hello'); })()@translatable.js") << QString::fromLatin1("(function() { return qsTr('Hello'); })()") << fileName << QString::fromLatin1("Hallo"); // From eval QTest::newRow("eval('qsTr(\\'One\\')')@translatable.js") << QString::fromLatin1("eval('qsTr(\\'One\\')')") << fileName << QString::fromLatin1("En"); QTest::newRow("eval('qsTr(\\'Hello\\')')@translatable.js") << QString::fromLatin1("eval('qsTr(\\'Hello\\')')") << fileName << QString::fromLatin1("Hallo"); // Plural QTest::newRow("qsTr('%n message(s) saved', '', 1)@translatable.js") << QString::fromLatin1("qsTr('%n message(s) saved', '', 1)") << fileName << QString::fromLatin1("1 melding lagret"); QTest::newRow("qsTr('%n message(s) saved', '', 3).arg@translatable.js") << QString::fromLatin1("qsTr('%n message(s) saved', '', 3)") << fileName << QString::fromLatin1("3 meldinger lagret"); // Top-level QTest::newRow("qsTranslate('FooContext', 'Two')@translatable.js") << QString::fromLatin1("qsTranslate('FooContext', 'Two')") << fileName << QString::fromLatin1("To"); QTest::newRow("qsTranslate('FooContext', 'Goodbye')@translatable.js") << QString::fromLatin1("qsTranslate('FooContext', 'Goodbye')") << fileName << QString::fromLatin1("Farvel"); // From eval QTest::newRow("eval('qsTranslate(\\'FooContext\\', \\'Two\\')')@translatable.js") << QString::fromLatin1("eval('qsTranslate(\\'FooContext\\', \\'Two\\')')") << fileName << QString::fromLatin1("To"); QTest::newRow("eval('qsTranslate(\\'FooContext\\', \\'Goodbye\\')')@translatable.js") << QString::fromLatin1("eval('qsTranslate(\\'FooContext\\', \\'Goodbye\\')')") << fileName << QString::fromLatin1("Farvel"); QTest::newRow("qsTranslate('FooContext', 'Goodbye', '', 'UnicodeUTF8')@translatable.js") << QString::fromLatin1("qsTranslate('FooContext', 'Goodbye', '', 'UnicodeUTF8')") << fileName << QString::fromLatin1("Farvel"); QTest::newRow("qsTranslate('FooContext', 'Goodbye', '', 'CodecForTr')@translatable.js") << QString::fromLatin1("qsTranslate('FooContext', 'Goodbye', '', 'CodecForTr')") << fileName << QString::fromLatin1("Farvel"); QTest::newRow("qsTranslate('FooContext', 'Goodbye', '', 'UnicodeUTF8', 42)@translatable.js") << QString::fromLatin1("qsTranslate('FooContext', 'Goodbye', '', 'UnicodeUTF8', 42)") << fileName << QString::fromLatin1("Goodbye"); QTest::newRow("qsTr('One', 'not the same one')@translatable.js") << QString::fromLatin1("qsTr('One', 'not the same one')") << fileName << QString::fromLatin1("Enda en"); QTest::newRow("qsTr('One', 'not the same one', 42)@translatable.js") << QString::fromLatin1("qsTr('One', 'not the same one', 42)") << fileName << QString::fromLatin1("One"); // Plural QTest::newRow("qsTranslate('FooContext', '%n fooish bar(s) found', '', 'UnicodeUTF8', 1)@translatable.js") << QString::fromLatin1("qsTranslate('FooContext', '%n fooish bar(s) found', '', 'UnicodeUTF8', 1)") << fileName << QString::fromLatin1("1 fooaktig bar funnet"); QTest::newRow("qsTranslate('FooContext', '%n fooish bar(s) found', '', 'UnicodeUTF8', 2)@translatable.js") << QString::fromLatin1("qsTranslate('FooContext', '%n fooish bar(s) found', '', 'UnicodeUTF8', 2)") << fileName << QString::fromLatin1("2 fooaktige barer funnet"); // Don't exist in translation QTest::newRow("qsTr('Three')@translatable.js") << QString::fromLatin1("qsTr('Three')") << fileName << QString::fromLatin1("Three"); QTest::newRow("qsTranslate('FooContext', 'So long')@translatable.js") << QString::fromLatin1("qsTranslate('FooContext', 'So long')") << fileName << QString::fromLatin1("So long"); QTest::newRow("qsTranslate('BarContext', 'Goodbye')@translatable.js") << QString::fromLatin1("qsTranslate('BarContext', 'Goodbye')") << fileName << QString::fromLatin1("Goodbye"); // Translate strings from the second script (translatable2.js) QString fileName2 = QString::fromLatin1("translatable2.js"); QTest::newRow("qsTr('Three')@translatable2.js") << QString::fromLatin1("qsTr('Three')") << fileName2 << QString::fromLatin1("Tre"); QTest::newRow("qsTr('Happy birthday!')@translatable2.js") << QString::fromLatin1("qsTr('Happy birthday!')") << fileName2 << QString::fromLatin1("Gratulerer med dagen!"); // Not translated because translation is only in translatable.js QTest::newRow("qsTr('One')@translatable2.js") << QString::fromLatin1("qsTr('One')") << fileName2 << QString::fromLatin1("One"); QTest::newRow("(function() { return qsTr('One'); })()@translatable2.js") << QString::fromLatin1("(function() { return qsTr('One'); })()") << fileName2 << QString::fromLatin1("One"); // For qsTranslate() the filename shouldn't matter QTest::newRow("qsTranslate('FooContext', 'Two')@translatable2.js") << QString::fromLatin1("qsTranslate('FooContext', 'Two')") << fileName2 << QString::fromLatin1("To"); QTest::newRow("qsTranslate('BarContext', 'Congratulations!')@translatable.js") << QString::fromLatin1("qsTranslate('BarContext', 'Congratulations!')") << fileName << QString::fromLatin1("Gratulerer!"); } void tst_QScriptEngine::translateScript() { QFETCH(QString, expression); QFETCH(QString, fileName); QFETCH(QString, expectedTranslation); QScriptEngine engine; TranslationScope tranScope(":/translations/translatable_la"); engine.installTranslatorFunctions(); QCOMPARE(engine.evaluate(expression, fileName).toString(), expectedTranslation); QVERIFY(!engine.hasUncaughtException()); } void tst_QScriptEngine::translateScript_crossScript() { QScriptEngine engine; TranslationScope tranScope(":/translations/translatable_la"); engine.installTranslatorFunctions(); QString fileName = QString::fromLatin1("translatable.js"); QString fileName2 = QString::fromLatin1("translatable2.js"); // qsTr() should use the innermost filename as context engine.evaluate("function foo(s) { return bar(s); }", fileName); engine.evaluate("function bar(s) { return qsTr(s); }", fileName2); QCOMPARE(engine.evaluate("bar('Three')", fileName2).toString(), QString::fromLatin1("Tre")); QCOMPARE(engine.evaluate("bar('Three')", fileName).toString(), QString::fromLatin1("Tre")); QCOMPARE(engine.evaluate("bar('One')", fileName2).toString(), QString::fromLatin1("One")); engine.evaluate("function foo(s) { return bar(s); }", fileName2); engine.evaluate("function bar(s) { return qsTr(s); }", fileName); QCOMPARE(engine.evaluate("bar('Three')", fileName2).toString(), QString::fromLatin1("Three")); QCOMPARE(engine.evaluate("bar('One')", fileName).toString(), QString::fromLatin1("En")); QCOMPARE(engine.evaluate("bar('One')", fileName2).toString(), QString::fromLatin1("En")); } static QScriptValue callQsTr(QScriptContext *ctx, QScriptEngine *eng) { return eng->globalObject().property("qsTr").call(ctx->thisObject(), ctx->argumentsObject()); } void tst_QScriptEngine::translateScript_callQsTrFromNative() { QScriptEngine engine; TranslationScope tranScope(":/translations/translatable_la"); engine.installTranslatorFunctions(); QString fileName = QString::fromLatin1("translatable.js"); QString fileName2 = QString::fromLatin1("translatable2.js"); // Calling qsTr() from a native function engine.globalObject().setProperty("qsTrProxy", engine.newFunction(callQsTr)); QCOMPARE(engine.evaluate("qsTrProxy('One')", fileName).toString(), QString::fromLatin1("En")); QCOMPARE(engine.evaluate("qsTrProxy('One')", fileName2).toString(), QString::fromLatin1("One")); QCOMPARE(engine.evaluate("qsTrProxy('Three')", fileName).toString(), QString::fromLatin1("Three")); QCOMPARE(engine.evaluate("qsTrProxy('Three')", fileName2).toString(), QString::fromLatin1("Tre")); } void tst_QScriptEngine::translateScript_trNoOp() { QScriptEngine engine; TranslationScope tranScope(":/translations/translatable_la"); engine.installTranslatorFunctions(); QVERIFY(engine.evaluate("QT_TR_NOOP()").isUndefined()); QCOMPARE(engine.evaluate("QT_TR_NOOP('One')").toString(), QString::fromLatin1("One")); QVERIFY(engine.evaluate("QT_TRANSLATE_NOOP()").isUndefined()); QVERIFY(engine.evaluate("QT_TRANSLATE_NOOP('FooContext')").isUndefined()); QCOMPARE(engine.evaluate("QT_TRANSLATE_NOOP('FooContext', 'Two')").toString(), QString::fromLatin1("Two")); } void tst_QScriptEngine::translateScript_callQsTrFromCpp() { QScriptEngine engine; TranslationScope tranScope(":/translations/translatable_la"); engine.installTranslatorFunctions(); // There is no context, but it shouldn't crash QCOMPARE(engine.globalObject().property("qsTr").call( QScriptValue(), QScriptValueList() << "One").toString(), QString::fromLatin1("One")); } void tst_QScriptEngine::translateWithInvalidArgs_data() { QTest::addColumn("expression"); QTest::addColumn("expectedError"); QTest::newRow("qsTr()") << "qsTr()" << "Error: qsTr() requires at least one argument"; QTest::newRow("qsTr(123)") << "qsTr(123)" << "Error: qsTr(): first argument (text) must be a string"; QTest::newRow("qsTr('foo', 123)") << "qsTr('foo', 123)" << "Error: qsTr(): second argument (comment) must be a string"; QTest::newRow("qsTr('foo', 'bar', 'baz')") << "qsTr('foo', 'bar', 'baz')" << "Error: qsTr(): third argument (n) must be a number"; QTest::newRow("qsTr('foo', 'bar', true)") << "qsTr('foo', 'bar', true)" << "Error: qsTr(): third argument (n) must be a number"; QTest::newRow("qsTranslate()") << "qsTranslate()" << "Error: qsTranslate() requires at least two arguments"; QTest::newRow("qsTranslate('foo')") << "qsTranslate('foo')" << "Error: qsTranslate() requires at least two arguments"; QTest::newRow("qsTranslate(123, 'foo')") << "qsTranslate(123, 'foo')" << "Error: qsTranslate(): first argument (context) must be a string"; QTest::newRow("qsTranslate('foo', 123)") << "qsTranslate('foo', 123)" << "Error: qsTranslate(): second argument (text) must be a string"; QTest::newRow("qsTranslate('foo', 'bar', 123)") << "qsTranslate('foo', 'bar', 123)" << "Error: qsTranslate(): third argument (comment) must be a string"; QTest::newRow("qsTranslate('foo', 'bar', 'baz', 123)") << "qsTranslate('foo', 'bar', 'baz', 123)" << "Error: qsTranslate(): fourth argument (encoding) must be a string"; QTest::newRow("qsTranslate('foo', 'bar', 'baz', 'zab', 'rab')") << "qsTranslate('foo', 'bar', 'baz', 'zab', 'rab')" << "Error: qsTranslate(): fifth argument (n) must be a number"; QTest::newRow("qsTranslate('foo', 'bar', 'baz', 'zab', 123)") << "qsTranslate('foo', 'bar', 'baz', 'zab', 123)" << "Error: qsTranslate(): invalid encoding 'zab'"; QTest::newRow("qsTrId()") << "qsTrId()" << "Error: qsTrId() requires at least one argument"; QTest::newRow("qsTrId(123)") << "qsTrId(123)" << "TypeError: qsTrId(): first argument (id) must be a string"; QTest::newRow("qsTrId('foo', 'bar')") << "qsTrId('foo', 'bar')" << "TypeError: qsTrId(): second argument (n) must be a number"; } void tst_QScriptEngine::translateWithInvalidArgs() { QFETCH(QString, expression); QFETCH(QString, expectedError); QScriptEngine engine; engine.installTranslatorFunctions(); QScriptValue result = engine.evaluate(expression); QVERIFY(result.isError()); QCOMPARE(result.toString(), expectedError); } void tst_QScriptEngine::translationContext_data() { QTest::addColumn("path"); QTest::addColumn("text"); QTest::addColumn("expectedTranslation"); QTest::newRow("translatable.js") << "translatable.js" << "One" << "En"; QTest::newRow("/translatable.js") << "/translatable.js" << "One" << "En"; QTest::newRow("/foo/translatable.js") << "/foo/translatable.js" << "One" << "En"; QTest::newRow("/foo/bar/translatable.js") << "/foo/bar/translatable.js" << "One" << "En"; QTest::newRow("./translatable.js") << "./translatable.js" << "One" << "En"; QTest::newRow("../translatable.js") << "../translatable.js" << "One" << "En"; QTest::newRow("foo/translatable.js") << "foo/translatable.js" << "One" << "En"; QTest::newRow("file:///home/qt/translatable.js") << "file:///home/qt/translatable.js" << "One" << "En"; QTest::newRow(":/resources/translatable.js") << ":/resources/translatable.js" << "One" << "En"; QTest::newRow("/translatable.js.foo") << "/translatable.js.foo" << "One" << "En"; QTest::newRow("/translatable.txt") << "/translatable.txt" << "One" << "En"; QTest::newRow("translatable") << "translatable" << "One" << "En"; QTest::newRow("foo/translatable") << "foo/translatable" << "One" << "En"; QTest::newRow("native separators") << (QDir::toNativeSeparators(QDir::currentPath()) + QDir::separator() + "translatable.js") << "One" << "En"; QTest::newRow("translatable.js/") << "translatable.js/" << "One" << "One"; QTest::newRow("nosuchscript.js") << "" << "One" << "One"; QTest::newRow("(empty)") << "" << "One" << "One"; } void tst_QScriptEngine::translationContext() { TranslationScope tranScope(":/translations/translatable_la"); QScriptEngine engine; engine.installTranslatorFunctions(); QFETCH(QString, path); QFETCH(QString, text); QFETCH(QString, expectedTranslation); QScriptValue ret = engine.evaluate(QString::fromLatin1("qsTr('%0')").arg(text), path); QVERIFY(ret.isString()); QCOMPARE(ret.toString(), expectedTranslation); } void tst_QScriptEngine::translateScriptIdBased() { QScriptEngine engine; TranslationScope tranScope(":/translations/idtranslatable_la"); engine.installTranslatorFunctions(); QString fileName = QString::fromLatin1("idtranslatable.js"); QHash expectedTranslations; expectedTranslations["qtn_foo_bar"] = "First string"; expectedTranslations["qtn_needle"] = "Second string"; expectedTranslations["qtn_haystack"] = "Third string"; expectedTranslations["qtn_bar_baz"] = "Fourth string"; QHash::const_iterator it; for (it = expectedTranslations.constBegin(); it != expectedTranslations.constEnd(); ++it) { for (int x = 0; x < 2; ++x) { QString fn; if (x) fn = fileName; // Top-level QCOMPARE(engine.evaluate(QString::fromLatin1("qsTrId('%0')") .arg(it.key()), fn).toString(), it.value()); QCOMPARE(engine.evaluate(QString::fromLatin1("QT_TRID_NOOP('%0')") .arg(it.key()), fn).toString(), it.key()); // From function QCOMPARE(engine.evaluate(QString::fromLatin1("(function() { return qsTrId('%0'); })()") .arg(it.key()), fn).toString(), it.value()); QCOMPARE(engine.evaluate(QString::fromLatin1("(function() { return QT_TRID_NOOP('%0'); })()") .arg(it.key()), fn).toString(), it.key()); } } // Plural form QCOMPARE(engine.evaluate("qsTrId('qtn_bar_baz', 10)").toString(), QString::fromLatin1("10 fooish bar(s) found")); QCOMPARE(engine.evaluate("qsTrId('qtn_foo_bar', 10)").toString(), QString::fromLatin1("qtn_foo_bar")); // Doesn't have plural } // How to add a new test row: // - Find a nice list of Unicode characters to choose from // - Write source string/context/comment in .js using Unicode escape sequences (\uABCD) // - Update corresponding .ts file (e.g. lupdate foo.js -ts foo.ts -codecfortr UTF-8) // - Enter translation in Linguist // - Update corresponding .qm file (e.g. lrelease foo.ts) // - Evaluate script that performs translation; make sure the correct result is returned // (e.g. by setting the resulting string as the text of a QLabel and visually verifying // that it looks the same as what you entered in Linguist :-) ) // - Generate the expectedTranslation column data using toUtf8().toHex() void tst_QScriptEngine::translateScriptUnicode_data() { QTest::addColumn("expression"); QTest::addColumn("fileName"); QTest::addColumn("expectedTranslation"); QString fileName = QString::fromLatin1("translatable-unicode.js"); QTest::newRow("qsTr('H\\u2082O')@translatable-unicode.js") << QString::fromLatin1("qsTr('H\\u2082O')") << fileName << QString::fromUtf8("\xcd\xbb\xcd\xbc\xcd\xbd"); QTest::newRow("qsTranslate('\\u010C\\u0101\\u011F\\u0115', 'CO\\u2082')@translatable-unicode.js") << QString::fromLatin1("qsTranslate('\\u010C\\u0101\\u011F\\u0115', 'CO\\u2082')") << fileName << QString::fromUtf8("\xd7\x91\xd7\x9a\xd7\xa2"); QTest::newRow("qsTr('\\u0391\\u0392\\u0393')@translatable-unicode.js") << QString::fromLatin1("qsTr('\\u0391\\u0392\\u0393')") << fileName << QString::fromUtf8("\xd3\x9c\xd2\xb4\xd1\xbc"); QTest::newRow("qsTranslate('\\u010C\\u0101\\u011F\\u0115', '\\u0414\\u0415\\u0416')@translatable-unicode.js") << QString::fromLatin1("qsTranslate('\\u010C\\u0101\\u011F\\u0115', '\\u0414\\u0415\\u0416')") << fileName << QString::fromUtf8("\xd8\xae\xd8\xb3\xd8\xb3"); QTest::newRow("qsTr('H\\u2082O', 'not the same H\\u2082O')@translatable-unicode.js") << QString::fromLatin1("qsTr('H\\u2082O', 'not the same H\\u2082O')") << fileName << QString::fromUtf8("\xd4\xb6\xd5\x8a\xd5\x92"); QTest::newRow("qsTr('H\\u2082O')") << QString::fromLatin1("qsTr('H\\u2082O')") << QString() << QString::fromUtf8("\x48\xe2\x82\x82\x4f"); QTest::newRow("qsTranslate('\\u010C\\u0101\\u011F\\u0115', 'CO\\u2082')") << QString::fromLatin1("qsTranslate('\\u010C\\u0101\\u011F\\u0115', 'CO\\u2082')") << QString() << QString::fromUtf8("\xd7\x91\xd7\x9a\xd7\xa2"); } void tst_QScriptEngine::translateScriptUnicode() { QFETCH(QString, expression); QFETCH(QString, fileName); QFETCH(QString, expectedTranslation); QScriptEngine engine; TranslationScope tranScope(":/translations/translatable-unicode"); engine.installTranslatorFunctions(); QCOMPARE(engine.evaluate(expression, fileName).toString(), expectedTranslation); QVERIFY(!engine.hasUncaughtException()); } void tst_QScriptEngine::translateScriptUnicodeIdBased_data() { QTest::addColumn("expression"); QTest::addColumn("expectedTranslation"); QTest::newRow("qsTrId('\\u01F8\\u01D2\\u0199\\u01D0\\u01E1'')") << QString::fromLatin1("qsTrId('\\u01F8\\u01D2\\u0199\\u01D0\\u01E1')") << QString::fromUtf8("\xc6\xa7\xc6\xb0\xc6\x88\xc8\xbc\xc8\x9d\xc8\xbf\xc8\x99"); QTest::newRow("qsTrId('\\u0191\\u01CE\\u0211\\u0229\\u019C\\u018E\\u019A\\u01D0')") << QString::fromLatin1("qsTrId('\\u0191\\u01CE\\u0211\\u0229\\u019C\\u018E\\u019A\\u01D0')") << QString::fromUtf8("\xc7\xa0\xc8\xa1\xc8\x8b\xc8\x85\xc8\x95"); QTest::newRow("qsTrId('\\u0181\\u01A1\\u0213\\u018F\\u018C', 10)") << QString::fromLatin1("qsTrId('\\u0181\\u01A1\\u0213\\u018F\\u018C', 10)") << QString::fromUtf8("\x31\x30\x20\xc6\x92\xc6\xa1\xc7\x92\x28\xc8\x99\x29"); QTest::newRow("qsTrId('\\u0181\\u01A1\\u0213\\u018F\\u018C')") << QString::fromLatin1("qsTrId('\\u0181\\u01A1\\u0213\\u018F\\u018C')") << QString::fromUtf8("\xc6\x91\xc6\xb0\xc7\xb9"); QTest::newRow("qsTrId('\\u01CD\\u0180\\u01A8\\u0190\\u019E\\u01AB')") << QString::fromLatin1("qsTrId('\\u01CD\\u0180\\u01A8\\u0190\\u019E\\u01AB')") << QString::fromUtf8("\xc7\x8d\xc6\x80\xc6\xa8\xc6\x90\xc6\x9e\xc6\xab"); } void tst_QScriptEngine::translateScriptUnicodeIdBased() { QFETCH(QString, expression); QFETCH(QString, expectedTranslation); QScriptEngine engine; TranslationScope tranScope(":/translations/idtranslatable-unicode"); engine.installTranslatorFunctions(); QCOMPARE(engine.evaluate(expression).toString(), expectedTranslation); QVERIFY(!engine.hasUncaughtException()); } void tst_QScriptEngine::translateFromBuiltinCallback() { QScriptEngine eng; eng.installTranslatorFunctions(); // Callback has no translation context. eng.evaluate("function foo() { qsTr('foo'); }"); // Stack at translation time will be: // qsTr, foo, forEach, global // qsTr() needs to walk to the outer-most (global) frame before it finds // a translation context, and this should not crash. eng.evaluate("[10,20].forEach(foo)", "script.js"); } void tst_QScriptEngine::functionScopes() { QScriptEngine eng; { // top-level functions have only the global object in their scope QScriptValue fun = eng.evaluate("(function() {})"); QVERIFY(fun.isFunction()); QEXPECT_FAIL("", "QScriptValue::scope() is internal, not implemented", Abort); QVERIFY(fun.scope().isObject()); QVERIFY(fun.scope().strictlyEquals(eng.globalObject())); QVERIFY(!eng.globalObject().scope().isValid()); } { QScriptValue fun = eng.globalObject().property("Object"); QVERIFY(fun.isFunction()); // native built-in functions don't have scope QVERIFY(!fun.scope().isValid()); } { // closure QScriptValue fun = eng.evaluate("(function(arg) { var foo = arg; return function() { return foo; }; })(123)"); QVERIFY(fun.isFunction()); { QScriptValue ret = fun.call(); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 123); } QScriptValue scope = fun.scope(); QVERIFY(scope.isObject()); { QScriptValue ret = scope.property("foo"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 123); QCOMPARE(scope.propertyFlags("foo"), QScriptValue::Undeletable); } { QScriptValue ret = scope.property("arg"); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 123); QCOMPARE(scope.propertyFlags("arg"), QScriptValue::Undeletable | QScriptValue::SkipInEnumeration); } scope.setProperty("foo", 456); { QScriptValue ret = fun.call(); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 456); } scope = scope.scope(); QVERIFY(scope.isObject()); QVERIFY(scope.strictlyEquals(eng.globalObject())); } } static QScriptValue counter_inner(QScriptContext *ctx, QScriptEngine *) { QScriptValue outerAct = ctx->callee().scope(); double count = outerAct.property("count").toNumber(); outerAct.setProperty("count", count+1); return count; } static QScriptValue counter(QScriptContext *ctx, QScriptEngine *eng) { QScriptValue act = ctx->activationObject(); act.setProperty("count", ctx->argument(0).toInt32()); QScriptValue result = eng->newFunction(counter_inner); result.setScope(act); return result; } static QScriptValue counter_hybrid(QScriptContext *ctx, QScriptEngine *eng) { QScriptValue act = ctx->activationObject(); act.setProperty("count", ctx->argument(0).toInt32()); return eng->evaluate("(function() { return count++; })"); } void tst_QScriptEngine::nativeFunctionScopes() { QScriptEngine eng; { QScriptValue fun = eng.newFunction(counter); QScriptValue cnt = fun.call(QScriptValue(), QScriptValueList() << 123); QVERIFY(cnt.isFunction()); { QScriptValue ret = cnt.call(); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 123); } } { QScriptValue fun = eng.newFunction(counter_hybrid); QScriptValue cnt = fun.call(QScriptValue(), QScriptValueList() << 123); QVERIFY(cnt.isFunction()); { QScriptValue ret = cnt.call(); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 123); } } //from http://doc.trolltech.com/latest/qtscript.html#nested-functions-and-the-scope-chain { QScriptEngine eng; eng.evaluate("function counter() { var count = 0; return function() { return count++; } }\n" "var c1 = counter(); var c2 = counter(); "); QCOMPARE(eng.evaluate("c1()").toString(), QString::fromLatin1("0")); QCOMPARE(eng.evaluate("c1()").toString(), QString::fromLatin1("1")); QCOMPARE(eng.evaluate("c2()").toString(), QString::fromLatin1("0")); QCOMPARE(eng.evaluate("c2()").toString(), QString::fromLatin1("1")); QVERIFY(!eng.hasUncaughtException()); } { QScriptEngine eng; eng.globalObject().setProperty("counter", eng.newFunction(counter)); eng.evaluate("var c1 = counter(); var c2 = counter(); "); QCOMPARE(eng.evaluate("c1()").toString(), QString::fromLatin1("0")); QCOMPARE(eng.evaluate("c1()").toString(), QString::fromLatin1("1")); QCOMPARE(eng.evaluate("c2()").toString(), QString::fromLatin1("0")); QCOMPARE(eng.evaluate("c2()").toString(), QString::fromLatin1("1")); QVERIFY(!eng.hasUncaughtException()); } { QScriptEngine eng; eng.globalObject().setProperty("counter", eng.newFunction(counter_hybrid)); eng.evaluate("var c1 = counter(); var c2 = counter(); "); QCOMPARE(eng.evaluate("c1()").toString(), QString::fromLatin1("0")); QCOMPARE(eng.evaluate("c1()").toString(), QString::fromLatin1("1")); QCOMPARE(eng.evaluate("c2()").toString(), QString::fromLatin1("0")); QCOMPARE(eng.evaluate("c2()").toString(), QString::fromLatin1("1")); QVERIFY(!eng.hasUncaughtException()); } } static QScriptValue createProgram(QScriptContext *ctx, QScriptEngine *eng) { QString code = ctx->argument(0).toString(); QScriptProgram result(code); return qScriptValueFromValue(eng, result); } void tst_QScriptEngine::evaluateProgram() { QScriptEngine eng; { QString code("1 + 2"); QString fileName("hello.js"); int lineNumber(123); QScriptProgram program(code, fileName, lineNumber); QVERIFY(!program.isNull()); QCOMPARE(program.sourceCode(), code); QCOMPARE(program.fileName(), fileName); QCOMPARE(program.firstLineNumber(), lineNumber); QScriptValue expected = eng.evaluate(code); for (int x = 0; x < 10; ++x) { QScriptValue ret = eng.evaluate(program); QVERIFY(ret.equals(expected)); } // operator= QScriptProgram sameProgram = program; QVERIFY(sameProgram == program); QVERIFY(eng.evaluate(sameProgram).equals(expected)); // copy constructor QScriptProgram sameProgram2(program); QVERIFY(sameProgram2 == program); QVERIFY(eng.evaluate(sameProgram2).equals(expected)); QScriptProgram differentProgram("2 + 3"); QVERIFY(differentProgram != program); QVERIFY(!eng.evaluate(differentProgram).equals(expected)); } } void tst_QScriptEngine::evaluateProgram_customScope() { QScriptEngine eng; { QScriptProgram program("a"); QVERIFY(!program.isNull()); { QScriptValue ret = eng.evaluate(program); QVERIFY(ret.isError()); QCOMPARE(ret.toString(), QString::fromLatin1("ReferenceError: Can't find variable: a")); } QScriptValue obj = eng.newObject(); obj.setProperty("a", 123); QScriptContext *ctx = eng.currentContext(); ctx->pushScope(obj); { QScriptValue ret = eng.evaluate(program); QVERIFY(!ret.isError()); QVERIFY(ret.equals(obj.property("a"))); } obj.setProperty("a", QScriptValue()); { QScriptValue ret = eng.evaluate(program); QVERIFY(ret.isError()); } QScriptValue obj2 = eng.newObject(); obj2.setProperty("a", 456); ctx->pushScope(obj2); { QScriptValue ret = eng.evaluate(program); QVERIFY(!ret.isError()); QVERIFY(ret.equals(obj2.property("a"))); } ctx->popScope(); } } void tst_QScriptEngine::evaluateProgram_closure() { QScriptEngine eng; { QScriptProgram program("(function() { var count = 0; return function() { return count++; }; })"); QVERIFY(!program.isNull()); QScriptValue createCounter = eng.evaluate(program); QVERIFY(createCounter.isFunction()); QScriptValue counter = createCounter.call(); QVERIFY(counter.isFunction()); { QScriptValue ret = counter.call(); QVERIFY(ret.isNumber()); } QScriptValue counter2 = createCounter.call(); QVERIFY(counter2.isFunction()); QVERIFY(!counter2.equals(counter)); { QScriptValue ret = counter2.call(); QVERIFY(ret.isNumber()); } } } void tst_QScriptEngine::evaluateProgram_executeLater() { QScriptEngine eng; // Program created in a function call, then executed later { QScriptValue fun = eng.newFunction(createProgram); QScriptProgram program = qscriptvalue_cast( fun.call(QScriptValue(), QScriptValueList() << "a + 1")); QVERIFY(!program.isNull()); eng.globalObject().setProperty("a", QScriptValue()); { QScriptValue ret = eng.evaluate(program); QVERIFY(ret.isError()); QCOMPARE(ret.toString(), QString::fromLatin1("ReferenceError: Can't find variable: a")); } eng.globalObject().setProperty("a", 122); { QScriptValue ret = eng.evaluate(program); QVERIFY(!ret.isError()); QVERIFY(ret.isNumber()); QCOMPARE(ret.toInt32(), 123); } } } void tst_QScriptEngine::evaluateProgram_multipleEngines() { QScriptEngine eng; { QString code("1 + 2"); QScriptProgram program(code); QVERIFY(!program.isNull()); double expected = eng.evaluate(program).toNumber(); for (int x = 0; x < 2; ++x) { QScriptEngine eng2; for (int y = 0; y < 2; ++y) { double ret = eng2.evaluate(program).toNumber(); QCOMPARE(ret, expected); } } } } void tst_QScriptEngine::evaluateProgram_empty() { QScriptEngine eng; { QScriptProgram program; QVERIFY(program.isNull()); QScriptValue ret = eng.evaluate(program); QVERIFY(!ret.isValid()); } } void tst_QScriptEngine::collectGarbageAfterConnect() { // QTBUG-6366 QScriptEngine engine; QPointer widget = new QWidget; engine.globalObject().setProperty( "widget", engine.newQObject(widget, QScriptEngine::ScriptOwnership)); QVERIFY(engine.evaluate("widget.customContextMenuRequested.connect(\n" " function() { print('hello'); }\n" ");") .isUndefined()); QVERIFY(widget != 0); engine.evaluate("widget = null;"); // The connection should not keep the widget alive. collectGarbage_helper(engine); QVERIFY(widget == 0); } void tst_QScriptEngine::collectGarbageAfterNativeArguments() { // QTBUG-17788 QScriptEngine eng; QScriptContext *ctx = eng.pushContext(); QScriptValue arguments = ctx->argumentsObject(); // Shouldn't crash when marking the arguments object. collectGarbage_helper(eng); } static QScriptValue constructQObjectFromThisObject(QScriptContext *ctx, QScriptEngine *eng) { Q_ASSERT(ctx->isCalledAsConstructor()); return eng->newQObject(ctx->thisObject(), new QObject, QScriptEngine::ScriptOwnership); } void tst_QScriptEngine::promoteThisObjectToQObjectInConstructor() { QScriptEngine engine; QScriptValue ctor = engine.newFunction(constructQObjectFromThisObject); engine.globalObject().setProperty("Ctor", ctor); QScriptValue object = engine.evaluate("new Ctor"); QVERIFY(!object.isError()); QVERIFY(object.isQObject()); QVERIFY(object.toQObject() != 0); QVERIFY(object.property("objectName").isString()); QVERIFY(object.property("deleteLater").isFunction()); } static QRegExp minimal(QRegExp r) { r.setMinimal(true); return r; } void tst_QScriptEngine::qRegExpInport_data() { QTest::addColumn("rx"); QTest::addColumn("string"); QTest::addColumn("matched"); QTest::newRow("normal") << QRegExp("(test|foo)") << "test _ foo _ test _ Foo"; QTest::newRow("normal2") << QRegExp("(Test|Foo)") << "test _ foo _ test _ Foo"; QTest::newRow("case insensitive)") << QRegExp("(test|foo)", Qt::CaseInsensitive) << "test _ foo _ test _ Foo"; QTest::newRow("case insensitive2)") << QRegExp("(Test|Foo)", Qt::CaseInsensitive) << "test _ foo _ test _ Foo"; QTest::newRow("b(a*)(b*)") << QRegExp("b(a*)(b*)", Qt::CaseInsensitive) << "aaabbBbaAabaAaababaaabbaaab"; QTest::newRow("greedy") << QRegExp("a*(a*)", Qt::CaseInsensitive, QRegExp::RegExp2) << "aaaabaaba"; // this one will fail because we do not support the QRegExp::RegExp in JSC //QTest::newRow("not_greedy") << QRegExp("a*(a*)", Qt::CaseInsensitive, QRegExp::RegExp) << "aaaabaaba"; QTest::newRow("willcard") << QRegExp("*.txt", Qt::CaseSensitive, QRegExp::Wildcard) << "file.txt"; QTest::newRow("willcard 2") << QRegExp("a?b.txt", Qt::CaseSensitive, QRegExp::Wildcard) << "ab.txt abb.rtc acb.txt"; QTest::newRow("slash") << QRegExp("g/.*/s", Qt::CaseInsensitive, QRegExp::RegExp2) << "string/string/string"; QTest::newRow("slash2") << QRegExp("g / .* / s", Qt::CaseInsensitive, QRegExp::RegExp2) << "string / string / string"; QTest::newRow("fixed") << QRegExp("a*aa.a(ba)*a\\ba", Qt::CaseInsensitive, QRegExp::FixedString) << "aa*aa.a(ba)*a\\ba"; QTest::newRow("fixed insensitive") << QRegExp("A*A", Qt::CaseInsensitive, QRegExp::FixedString) << "a*A A*a A*A a*a"; QTest::newRow("fixed sensitive") << QRegExp("A*A", Qt::CaseSensitive, QRegExp::FixedString) << "a*A A*a A*A a*a"; QTest::newRow("html") << QRegExp("(.*)", Qt::CaseSensitive, QRegExp::RegExp2) << "bolditalicbold"; QTest::newRow("html minimal") << minimal(QRegExp("(.*)", Qt::CaseSensitive, QRegExp::RegExp2)) << "bolditalicbold"; QTest::newRow("aaa") << QRegExp("a{2,5}") << "aAaAaaaaaAa"; QTest::newRow("aaa minimal") << minimal(QRegExp("a{2,5}")) << "aAaAaaaaaAa"; QTest::newRow("minimal") << minimal(QRegExp(".*\\} [*8]")) << "}?} ?} *"; QTest::newRow(".? minimal") << minimal(QRegExp(".?")) << ".?"; QTest::newRow(".+ minimal") << minimal(QRegExp(".+")) << ".+"; QTest::newRow("[.?] minimal") << minimal(QRegExp("[.?]")) << ".?"; QTest::newRow("[.+] minimal") << minimal(QRegExp("[.+]")) << ".+"; } void tst_QScriptEngine::qRegExpInport() { QFETCH(QRegExp, rx); QFETCH(QString, string); QScriptEngine eng; QScriptValue rexp; rexp = eng.newRegExp(rx); QCOMPARE(rexp.isValid(), true); QCOMPARE(rexp.isRegExp(), true); QVERIFY(rexp.isFunction()); QScriptValue func = eng.evaluate("(function(string, regexp) { return string.match(regexp); })"); QScriptValue result = func.call(QScriptValue(), QScriptValueList() << string << rexp); rx.indexIn(string); for (int i = 0; i <= rx.captureCount(); i++) { QCOMPARE(result.property(i).toString(), rx.cap(i)); } } // QScriptValue::toDateTime() returns a local time, whereas JS dates // are always stored as UTC. QtScript must respect the current time // zone, and correctly adjust for daylight saving time that may be in // effect at a given date (QTBUG-9770). void tst_QScriptEngine::dateRoundtripJSQtJS() { uint secs = QDateTime(QDate(2009, 1, 1)).toUTC().toTime_t(); QScriptEngine eng; for (int i = 0; i < 8000; ++i) { QScriptValue jsDate = eng.evaluate(QString::fromLatin1("new Date(%0)").arg(secs * 1000.0)); QDateTime qtDate = jsDate.toDateTime(); QScriptValue jsDate2 = eng.newDate(qtDate); if (jsDate2.toNumber() != jsDate.toNumber()) QFAIL(qPrintable(jsDate.toString())); secs += 2*60*60; } } void tst_QScriptEngine::dateRoundtripQtJSQt() { QDateTime qtDate = QDateTime(QDate(2009, 1, 1)); QScriptEngine eng; for (int i = 0; i < 8000; ++i) { QScriptValue jsDate = eng.newDate(qtDate); QDateTime qtDate2 = jsDate.toDateTime(); if (qtDate2 != qtDate) QFAIL(qPrintable(qtDate.toString())); qtDate = qtDate.addSecs(2*60*60); } } void tst_QScriptEngine::dateConversionJSQt() { uint secs = QDateTime(QDate(2009, 1, 1)).toUTC().toTime_t(); QScriptEngine eng; for (int i = 0; i < 8000; ++i) { QScriptValue jsDate = eng.evaluate(QString::fromLatin1("new Date(%0)").arg(secs * 1000.0)); QDateTime qtDate = jsDate.toDateTime(); QString qtUTCDateStr = qtDate.toUTC().toString(Qt::ISODate); QString jsUTCDateStr = jsDate.property("toISOString").call(jsDate).toString(); jsUTCDateStr.chop(5); // get rid of milliseconds (".000Z") jsUTCDateStr.append("Z"); // append the timezone specifier again if (qtUTCDateStr != jsUTCDateStr) QFAIL(qPrintable(jsDate.toString())); secs += 2*60*60; } } void tst_QScriptEngine::dateConversionQtJS() { QDateTime qtDate = QDateTime(QDate(2009, 1, 1)); QScriptEngine eng; for (int i = 0; i < 8000; ++i) { QScriptValue jsDate = eng.newDate(qtDate); QString jsUTCDateStr = jsDate.property("toISOString").call(jsDate).toString(); jsUTCDateStr.chop(5); // get rid of milliseconds (".000Z") jsUTCDateStr.append("Z"); // append the timezone specifier again QString qtUTCDateStr = qtDate.toUTC().toString(Qt::ISODate); if (jsUTCDateStr != qtUTCDateStr) QFAIL(qPrintable(qtDate.toString())); qtDate = qtDate.addSecs(2*60*60); } } static QScriptValue createAnotherEngine(QScriptContext *, QScriptEngine *) { QScriptEngine eng; eng.evaluate("function foo(x, y) { return x + y; }" ); eng.evaluate("hello = 5; world = 6" ); return eng.evaluate("foo(hello,world)").toInt32(); } void tst_QScriptEngine::reentrency() { QScriptEngine eng; eng.globalObject().setProperty("foo", eng.newFunction(createAnotherEngine)); eng.evaluate("function bar() { return foo(); } hello = 9; function getHello() { return hello; }"); QCOMPARE(eng.evaluate("foo() + getHello() + foo()").toInt32(), 5+6 + 9 + 5+6); QCOMPARE(eng.evaluate("foo").call().toInt32(), 5+6); QCOMPARE(eng.evaluate("hello").toInt32(), 9); QCOMPARE(eng.evaluate("foo() + hello").toInt32(), 5+6+9); } void tst_QScriptEngine::newFixedStaticScopeObject() { // "Static scope objects" is an optimization we do for QML. // It enables the creation of JS objects that can guarantee to the // compiler that no properties will be added or removed. This enables // the compiler to generate a very simple (fast) property access, as // opposed to a full virtual lookup. Due to the inherent use of scope // chains in QML, this can make a huge difference (10x improvement for // benchmark in QTBUG-8576). // Ideally we would not need a special object type for this, and the // VM would dynamically optimize it to be fast... // See also QScriptEngine benchmark. QScriptEngine eng; static const int propertyCount = 4; QString names[] = { "foo", "bar", "baz", "Math" }; QScriptValue values[] = { 123, "ciao", true, false }; QScriptValue::PropertyFlags flags[] = { QScriptValue::Undeletable, QScriptValue::ReadOnly | QScriptValue::Undeletable, QScriptValue::SkipInEnumeration | QScriptValue::Undeletable, QScriptValue::Undeletable }; QScriptValue scope = QScriptDeclarativeClass::newStaticScopeObject(&eng, propertyCount, names, values, flags); // Query property. for (int i = 0; i < propertyCount; ++i) { for (int x = 0; x < 2; ++x) { if (x) { // Properties can't be deleted. scope.setProperty(names[i], QScriptValue()); } QVERIFY(scope.property(names[i]).equals(values[i])); QCOMPARE(scope.propertyFlags(names[i]), flags[i]); } } // Property that doesn't exist. QVERIFY(!scope.property("noSuchProperty").isValid()); QCOMPARE(scope.propertyFlags("noSuchProperty"), QScriptValue::PropertyFlags()); // Write to writable property. { QScriptValue oldValue = scope.property("foo"); QVERIFY(oldValue.isNumber()); QScriptValue newValue = oldValue.toNumber() * 2; scope.setProperty("foo", newValue); QVERIFY(scope.property("foo").equals(newValue)); scope.setProperty("foo", oldValue); QVERIFY(scope.property("foo").equals(oldValue)); } // Write to read-only property. scope.setProperty("bar", 456); QVERIFY(scope.property("bar").equals("ciao")); // Iterate. { QScriptValueIterator it(scope); QSet iteratedNames; while (it.hasNext()) { it.next(); iteratedNames.insert(it.name()); } for (int i = 0; i < propertyCount; ++i) QVERIFY(iteratedNames.contains(names[i])); } // Push it on the scope chain of a new context. QScriptContext *ctx = eng.pushContext(); ctx->pushScope(scope); QCOMPARE(ctx->scopeChain().size(), 3); // Global Object, native activation, custom scope QVERIFY(ctx->activationObject().equals(scope)); // Read property from JS. for (int i = 0; i < propertyCount; ++i) { for (int x = 0; x < 2; ++x) { if (x) { // Property can't be deleted from JS. QScriptValue ret = eng.evaluate(QString::fromLatin1("delete %0").arg(names[i])); QVERIFY(ret.equals(false)); } QVERIFY(eng.evaluate(names[i]).equals(values[i])); } } // Property that doesn't exist. QVERIFY(eng.evaluate("noSuchProperty").equals("ReferenceError: Can't find variable: noSuchProperty")); // Write property from JS. { QScriptValue oldValue = eng.evaluate("foo"); QVERIFY(oldValue.isNumber()); QScriptValue newValue = oldValue.toNumber() * 2; QVERIFY(eng.evaluate("foo = foo * 2; foo").equals(newValue)); scope.setProperty("foo", oldValue); QVERIFY(eng.evaluate("foo").equals(oldValue)); } // Write to read-only property. QVERIFY(eng.evaluate("bar = 456; bar").equals("ciao")); // Create a closure and return properties from there. { QScriptValue props = eng.evaluate("(function() { var baz = 'shadow'; return [foo, bar, baz, Math, Array]; })()"); QVERIFY(props.isArray()); // "foo" and "bar" come from scope object. QVERIFY(props.property(0).equals(scope.property("foo"))); QVERIFY(props.property(1).equals(scope.property("bar"))); // "baz" shadows property in scope object. QVERIFY(props.property(2).equals("shadow")); // "Math" comes from scope object, and shadows Global Object's "Math". QVERIFY(props.property(3).equals(scope.property("Math"))); QVERIFY(!props.property(3).equals(eng.globalObject().property("Math"))); // "Array" comes from Global Object. QVERIFY(props.property(4).equals(eng.globalObject().property("Array"))); } // As with normal JS, assigning to an undefined variable will create // the property on the Global Object, not the inner scope. QVERIFY(!eng.globalObject().property("newProperty").isValid()); QVERIFY(eng.evaluate("(function() { newProperty = 789; })()").isUndefined()); QVERIFY(!scope.property("newProperty").isValid()); QVERIFY(eng.globalObject().property("newProperty").isNumber()); // Nested static scope. { static const int propertyCount2 = 2; QString names2[] = { "foo", "hum" }; QScriptValue values2[] = { 321, "hello" }; QScriptValue::PropertyFlags flags2[] = { QScriptValue::Undeletable, QScriptValue::ReadOnly | QScriptValue::Undeletable }; QScriptValue scope2 = QScriptDeclarativeClass::newStaticScopeObject(&eng, propertyCount2, names2, values2, flags2); ctx->pushScope(scope2); // "foo" shadows scope.foo. QVERIFY(eng.evaluate("foo").equals(scope2.property("foo"))); QVERIFY(!eng.evaluate("foo").equals(scope.property("foo"))); // "hum" comes from scope2. QVERIFY(eng.evaluate("hum").equals(scope2.property("hum"))); // "Array" comes from Global Object. QVERIFY(eng.evaluate("Array").equals(eng.globalObject().property("Array"))); ctx->popScope(); } QScriptValue fun = eng.evaluate("(function() { return foo; })"); QVERIFY(fun.isFunction()); eng.popContext(); // Function's scope chain persists after popContext(). QVERIFY(fun.call().equals(scope.property("foo"))); } void tst_QScriptEngine::newGrowingStaticScopeObject() { // The main use case for a growing static scope object is to set it as // the activation object of a QScriptContext, so that all JS variable // declarations end up in that object. It needs to be "growable" since // we don't know in advance how many variables a script will declare. QScriptEngine eng; QScriptValue scope = QScriptDeclarativeClass::newStaticScopeObject(&eng); // Initially empty. QVERIFY(!QScriptValueIterator(scope).hasNext()); QVERIFY(!scope.property("foo").isValid()); // Add a static property. scope.setProperty("foo", 123); QVERIFY(scope.property("foo").equals(123)); QCOMPARE(scope.propertyFlags("foo"), QScriptValue::Undeletable); // Modify existing property. scope.setProperty("foo", 456); QVERIFY(scope.property("foo").equals(456)); // Add a read-only property. scope.setProperty("bar", "ciao", QScriptValue::ReadOnly); QVERIFY(scope.property("bar").equals("ciao")); QCOMPARE(scope.propertyFlags("bar"), QScriptValue::ReadOnly | QScriptValue::Undeletable); // Attempt to modify read-only property. scope.setProperty("bar", "hello"); QVERIFY(scope.property("bar").equals("ciao")); // Properties can't be deleted. scope.setProperty("foo", QScriptValue()); QVERIFY(scope.property("foo").equals(456)); scope.setProperty("bar", QScriptValue()); QVERIFY(scope.property("bar").equals("ciao")); // Iterate. { QScriptValueIterator it(scope); QSet iteratedNames; while (it.hasNext()) { it.next(); iteratedNames.insert(it.name()); } QCOMPARE(iteratedNames.size(), 2); QVERIFY(iteratedNames.contains("foo")); QVERIFY(iteratedNames.contains("bar")); } // Push it on the scope chain of a new context. QScriptContext *ctx = eng.pushContext(); ctx->pushScope(scope); QCOMPARE(ctx->scopeChain().size(), 3); // Global Object, native activation, custom scope QVERIFY(ctx->activationObject().equals(scope)); // Read property from JS. QVERIFY(eng.evaluate("foo").equals(scope.property("foo"))); QVERIFY(eng.evaluate("bar").equals(scope.property("bar"))); // Write property from JS. { QScriptValue oldValue = eng.evaluate("foo"); QVERIFY(oldValue.isNumber()); QScriptValue newValue = oldValue.toNumber() * 2; QVERIFY(eng.evaluate("foo = foo * 2; foo").equals(newValue)); scope.setProperty("foo", oldValue); QVERIFY(eng.evaluate("foo").equals(oldValue)); } // Write to read-only property. QVERIFY(eng.evaluate("bar = 456; bar").equals("ciao")); // Shadow property. QVERIFY(eng.evaluate("Math").equals(eng.globalObject().property("Math"))); scope.setProperty("Math", "fake Math"); QVERIFY(eng.evaluate("Math").equals(scope.property("Math"))); // Variable declarations will create properties on the scope. eng.evaluate("var baz = 456"); QVERIFY(scope.property("baz").equals(456)); // Function declarations will create properties on the scope. eng.evaluate("function fun() { return baz; }"); QVERIFY(scope.property("fun").isFunction()); QVERIFY(scope.property("fun").call().equals(scope.property("baz"))); // Demonstrate the limitation of a growable static scope: Once a function that // uses the scope has been compiled, it won't pick up properties that are added // to the scope later. { QScriptValue fun = eng.evaluate("(function() { return futureProperty; })"); QVERIFY(fun.isFunction()); QVERIFY(fun.call().toString().contains(QString::fromLatin1("ReferenceError"))); scope.setProperty("futureProperty", "added after the function was compiled"); // If scope were dynamic, this would return the new property. QVERIFY(fun.call().toString().contains(QString::fromLatin1("ReferenceError"))); } eng.popContext(); } QT_BEGIN_NAMESPACE Q_SCRIPT_DECLARE_QMETAOBJECT(QStandardItemModel, QObject*) QT_END_NAMESPACE void tst_QScriptEngine::scriptValueFromQMetaObject() { QScriptEngine eng; { QScriptValue meta = eng.scriptValueFromQMetaObject(); QVERIFY(meta.isQMetaObject()); QCOMPARE(meta.toQMetaObject(), &QScriptEngine::staticMetaObject); // Because of missing Q_SCRIPT_DECLARE_QMETAOBJECT() for QScriptEngine. QVERIFY(!meta.construct().isValid()); } { QScriptValue meta = eng.scriptValueFromQMetaObject(); QVERIFY(meta.isQMetaObject()); QCOMPARE(meta.toQMetaObject(), &QStandardItemModel::staticMetaObject); QScriptValue obj = meta.construct(QScriptValueList() << eng.newQObject(&eng)); QVERIFY(obj.isQObject()); QStandardItemModel *model = qobject_cast(obj.toQObject()); QVERIFY(model != 0); QCOMPARE(model->parent(), (QObject*)&eng); } } QTEST_MAIN(tst_QScriptEngine) #include "tst_qscriptengine.moc"