diff options
Diffstat (limited to 'tests/auto/declarative')
51 files changed, 11449 insertions, 75 deletions
diff --git a/tests/auto/declarative/declarative.pro b/tests/auto/declarative/declarative.pro index 43a2a682de..a99656a3ee 100644 --- a/tests/auto/declarative/declarative.pro +++ b/tests/auto/declarative/declarative.pro @@ -20,7 +20,10 @@ PUBLICTESTS += \ qdeclarativepixmapcache \ qdeclarativeqt \ qdeclarativetranslation \ - qdeclarativexmlhttprequest + qdeclarativexmlhttprequest \ + qjsvalue \ + qjsvalueiterator \ + qjsengine PRIVATETESTS += \ qdeclarativeanimations \ diff --git a/tests/auto/declarative/qdeclarativecomponent/qdeclarativecomponent.pro b/tests/auto/declarative/qdeclarativecomponent/qdeclarativecomponent.pro index 7109f2da65..50d63fea42 100644 --- a/tests/auto/declarative/qdeclarativecomponent/qdeclarativecomponent.pro +++ b/tests/auto/declarative/qdeclarativecomponent/qdeclarativecomponent.pro @@ -1,6 +1,6 @@ load(qttest_p4) contains(QT_CONFIG,declarative): QT += declarative -QT += script network +QT += network macx:CONFIG -= app_bundle SOURCES += tst_qdeclarativecomponent.cpp diff --git a/tests/auto/declarative/qdeclarativeconnection/qdeclarativeconnection.pro b/tests/auto/declarative/qdeclarativeconnection/qdeclarativeconnection.pro index 564b088817..49150c8481 100644 --- a/tests/auto/declarative/qdeclarativeconnection/qdeclarativeconnection.pro +++ b/tests/auto/declarative/qdeclarativeconnection/qdeclarativeconnection.pro @@ -14,4 +14,4 @@ symbian: { CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private opengl-private +QT += core-private gui-private declarative-private opengl-private diff --git a/tests/auto/declarative/qdeclarativedebug/qdeclarativedebug.pro b/tests/auto/declarative/qdeclarativedebug/qdeclarativedebug.pro index 430224e1e8..cd5577219d 100644 --- a/tests/auto/declarative/qdeclarativedebug/qdeclarativedebug.pro +++ b/tests/auto/declarative/qdeclarativedebug/qdeclarativedebug.pro @@ -8,4 +8,4 @@ SOURCES += tst_qdeclarativedebug.cpp \ CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativedebugclient/qdeclarativedebugclient.pro b/tests/auto/declarative/qdeclarativedebugclient/qdeclarativedebugclient.pro index 880255b6b2..189133a526 100644 --- a/tests/auto/declarative/qdeclarativedebugclient/qdeclarativedebugclient.pro +++ b/tests/auto/declarative/qdeclarativedebugclient/qdeclarativedebugclient.pro @@ -5,4 +5,4 @@ macx:CONFIG -= app_bundle HEADERS += ../shared/debugutil_p.h SOURCES += tst_qdeclarativedebugclient.cpp \ ../shared/debugutil.cpp -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativedebughelper/private_headers/qdeclarativedebughelper_p.h b/tests/auto/declarative/qdeclarativedebughelper/private_headers/qdeclarativedebughelper_p.h index 84956d0bb7..c08f6fd639 100644 --- a/tests/auto/declarative/qdeclarativedebughelper/private_headers/qdeclarativedebughelper_p.h +++ b/tests/auto/declarative/qdeclarativedebughelper/private_headers/qdeclarativedebughelper_p.h @@ -48,7 +48,7 @@ QT_BEGIN_HEADER QT_BEGIN_NAMESPACE -class QScriptEngine; +class QJSEngine; class QDeclarativeEngine; // Helper methods to access private API through a stable interface @@ -56,7 +56,7 @@ class QDeclarativeEngine; class Q_DECLARATIVE_EXPORT QDeclarativeDebugHelper { public: - static QScriptEngine *getScriptEngine(QDeclarativeEngine *engine); + static QJSEngine *getScriptEngine(QDeclarativeEngine *engine); static void setAnimationSlowDownFactor(qreal factor); // Enables remote debugging functionality diff --git a/tests/auto/declarative/qdeclarativedebughelper/qdeclarativedebughelper.pro b/tests/auto/declarative/qdeclarativedebughelper/qdeclarativedebughelper.pro index e9e8e73319..1e62c12363 100644 --- a/tests/auto/declarative/qdeclarativedebughelper/qdeclarativedebughelper.pro +++ b/tests/auto/declarative/qdeclarativedebughelper/qdeclarativedebughelper.pro @@ -1,6 +1,6 @@ load(qttest_p4) -contains(QT_CONFIG,declarative): QT += network declarative script +contains(QT_CONFIG,declarative): QT += network declarative macx:CONFIG -= app_bundle SOURCES += tst_qdeclarativedebughelper.cpp -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativedebugservice/qdeclarativedebugservice.pro b/tests/auto/declarative/qdeclarativedebugservice/qdeclarativedebugservice.pro index 55ddeb28a3..785e8a7bf1 100644 --- a/tests/auto/declarative/qdeclarativedebugservice/qdeclarativedebugservice.pro +++ b/tests/auto/declarative/qdeclarativedebugservice/qdeclarativedebugservice.pro @@ -8,4 +8,4 @@ SOURCES += tst_qdeclarativedebugservice.cpp \ CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativeecmascript/qdeclarativeecmascript.pro b/tests/auto/declarative/qdeclarativeecmascript/qdeclarativeecmascript.pro index 03834ed428..4b7aff339c 100644 --- a/tests/auto/declarative/qdeclarativeecmascript/qdeclarativeecmascript.pro +++ b/tests/auto/declarative/qdeclarativeecmascript/qdeclarativeecmascript.pro @@ -1,5 +1,5 @@ load(qttest_p4) -contains(QT_CONFIG,declarative): QT += declarative script network +contains(QT_CONFIG,declarative): QT += declarative network macx:CONFIG -= app_bundle SOURCES += tst_qdeclarativeecmascript.cpp \ @@ -22,4 +22,4 @@ symbian: { CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativeecmascript/testtypes.cpp b/tests/auto/declarative/qdeclarativeecmascript/testtypes.cpp index ea8d2c01c7..160a57215b 100644 --- a/tests/auto/declarative/qdeclarativeecmascript/testtypes.cpp +++ b/tests/auto/declarative/qdeclarativeecmascript/testtypes.cpp @@ -42,7 +42,7 @@ #include <QWidget> #include <QPlainTextEdit> #include <QDeclarativeEngine> -#include <QScriptEngine> +#include <QJSEngine> class BaseExtensionObject : public QObject { @@ -101,17 +101,17 @@ public: void setWidth(int) { } }; -static QScriptValue script_api(QDeclarativeEngine *engine, QScriptEngine *scriptEngine) +static QJSValue script_api(QDeclarativeEngine *engine, QJSEngine *scriptEngine) { Q_UNUSED(engine) static int testProperty = 13; - QScriptValue v = scriptEngine->newObject(); + QJSValue v = scriptEngine->newObject(); v.setProperty("scriptTestProperty", testProperty++); return v; } -static QObject *qobject_api(QDeclarativeEngine *engine, QScriptEngine *scriptEngine) +static QObject *qobject_api(QDeclarativeEngine *engine, QJSEngine *scriptEngine) { Q_UNUSED(engine) Q_UNUSED(scriptEngine) @@ -122,7 +122,7 @@ static QObject *qobject_api(QDeclarativeEngine *engine, QScriptEngine *scriptEng return o; } -static QObject *qobject_api_engine_parent(QDeclarativeEngine *engine, QScriptEngine *scriptEngine) +static QObject *qobject_api_engine_parent(QDeclarativeEngine *engine, QJSEngine *scriptEngine) { Q_UNUSED(scriptEngine) diff --git a/tests/auto/declarative/qdeclarativeecmascript/testtypes.h b/tests/auto/declarative/qdeclarativeecmascript/testtypes.h index aebfb22b7c..afb361e2d7 100644 --- a/tests/auto/declarative/qdeclarativeecmascript/testtypes.h +++ b/tests/auto/declarative/qdeclarativeecmascript/testtypes.h @@ -53,7 +53,7 @@ #include <QtGui/qvector3d.h> #include <QtGui/QPixmap> #include <QtCore/qdatetime.h> -#include <QtScript/qscriptvalue.h> +#include <QtDeclarative/qjsvalue.h> #include <QtDeclarative/qdeclarativescriptstring.h> #include <QtDeclarative/qdeclarativecomponent.h> @@ -581,7 +581,7 @@ public: } }; -Q_DECLARE_METATYPE(QScriptValue); +Q_DECLARE_METATYPE(QJSValue); class MyInvokableBaseObject : public QObject { Q_OBJECT @@ -614,7 +614,7 @@ public: Q_INVOKABLE QPointF method_NoArgs_QPointF() { invoke(3); return QPointF(123, 4.5); } Q_INVOKABLE QObject *method_NoArgs_QObject() { invoke(4); return this; } Q_INVOKABLE MyInvokableObject *method_NoArgs_unknown() { invoke(5); return this; } - Q_INVOKABLE QScriptValue method_NoArgs_QScriptValue() { invoke(6); return QScriptValue("Hello world"); } + Q_INVOKABLE QJSValue method_NoArgs_QScriptValue() { invoke(6); return QJSValue("Hello world"); } Q_INVOKABLE QVariant method_NoArgs_QVariant() { invoke(7); return QVariant("QML rocks"); } Q_INVOKABLE void method_int(int a) { invoke(8); m_actuals << a; } @@ -623,8 +623,8 @@ public: Q_INVOKABLE void method_QString(QString a) { invoke(11); m_actuals << a; } Q_INVOKABLE void method_QPointF(QPointF a) { invoke(12); m_actuals << a; } Q_INVOKABLE void method_QObject(QObject *a) { invoke(13); m_actuals << qVariantFromValue(a); } - Q_INVOKABLE void method_QScriptValue(QScriptValue a) { invoke(14); m_actuals << qVariantFromValue(a); } - Q_INVOKABLE void method_intQScriptValue(int a, QScriptValue b) { invoke(15); m_actuals << a << qVariantFromValue(b); } + Q_INVOKABLE void method_QScriptValue(QJSValue a) { invoke(14); m_actuals << qVariantFromValue(a); } + Q_INVOKABLE void method_intQScriptValue(int a, QJSValue b) { invoke(15); m_actuals << a << qVariantFromValue(b); } Q_INVOKABLE void method_overload(int a) { invoke(16); m_actuals << a; } Q_INVOKABLE void method_overload(int a, int b) { invoke(17); m_actuals << a << b; } diff --git a/tests/auto/declarative/qdeclarativeecmascript/tst_qdeclarativeecmascript.cpp b/tests/auto/declarative/qdeclarativeecmascript/tst_qdeclarativeecmascript.cpp index b1bc5bda2b..6c629a80f7 100644 --- a/tests/auto/declarative/qdeclarativeecmascript/tst_qdeclarativeecmascript.cpp +++ b/tests/auto/declarative/qdeclarativeecmascript/tst_qdeclarativeecmascript.cpp @@ -49,7 +49,6 @@ #include <QtCore/qdir.h> #include <QtCore/qnumeric.h> #include <private/qdeclarativeengine_p.h> -#include <private/qscriptdeclarativeclass_p.h> #include "testtypes.h" #include "testhttpserver.h" #include "../../../shared/util.h" @@ -1600,7 +1599,7 @@ void tst_qdeclarativeecmascript::callQtInvokables() QDeclarativeEngine qmlengine; QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(&qmlengine); - QV8Engine *engine = &ep->v8engine; + QV8Engine *engine = ep->v8engine(); v8::HandleScope handle_scope; v8::Context::Scope scope(engine->context()); @@ -1693,8 +1692,6 @@ void tst_qdeclarativeecmascript::callQtInvokables() QCOMPARE(o.invoked(), 5); QCOMPARE(o.actuals().count(), 0); - // XXX enable once qml/qtscript integration is implemented -#if 0 o.reset(); { v8::Handle<v8::Value> ret = EVALUATE("object.method_NoArgs_QScriptValue()"); @@ -1704,7 +1701,6 @@ void tst_qdeclarativeecmascript::callQtInvokables() QCOMPARE(o.invoked(), 6); QCOMPARE(o.actuals().count(), 0); } -#endif o.reset(); QVERIFY(EVALUATE_VALUE("object.method_NoArgs_QVariant()", engine->toString("QML rocks"))); @@ -1920,35 +1916,33 @@ void tst_qdeclarativeecmascript::callQtInvokables() QCOMPARE(o.actuals().count(), 1); QCOMPARE(o.actuals().at(0), qVariantFromValue((QObject *)&o)); - // XXX enable once qml/qtscript integration is implemented -#if 0 o.reset(); QVERIFY(EVALUATE_VALUE("object.method_QScriptValue(null)", v8::Undefined())); QCOMPARE(o.error(), false); QCOMPARE(o.invoked(), 14); QCOMPARE(o.actuals().count(), 1); - QVERIFY(qvariant_cast<QScriptValue>(o.actuals().at(0)).isNull()); + QVERIFY(qvariant_cast<QJSValue>(o.actuals().at(0)).isNull()); o.reset(); QVERIFY(EVALUATE_VALUE("object.method_QScriptValue(undefined)", v8::Undefined())); QCOMPARE(o.error(), false); QCOMPARE(o.invoked(), 14); QCOMPARE(o.actuals().count(), 1); - QVERIFY(qvariant_cast<QScriptValue>(o.actuals().at(0)).isUndefined()); + QVERIFY(qvariant_cast<QJSValue>(o.actuals().at(0)).isUndefined()); o.reset(); QVERIFY(EVALUATE_VALUE("object.method_QScriptValue(19)", v8::Undefined())); QCOMPARE(o.error(), false); QCOMPARE(o.invoked(), 14); QCOMPARE(o.actuals().count(), 1); - QVERIFY(qvariant_cast<QScriptValue>(o.actuals().at(0)).strictlyEquals(QScriptValue(engine, 19))); + QVERIFY(qvariant_cast<QJSValue>(o.actuals().at(0)).strictlyEquals(QJSValue(19))); o.reset(); QVERIFY(EVALUATE_VALUE("object.method_QScriptValue([19, 20])", v8::Undefined())); QCOMPARE(o.error(), false); QCOMPARE(o.invoked(), 14); QCOMPARE(o.actuals().count(), 1); - QVERIFY(qvariant_cast<QScriptValue>(o.actuals().at(0)).isArray()); + QVERIFY(qvariant_cast<QJSValue>(o.actuals().at(0)).isArray()); o.reset(); QVERIFY(EVALUATE_VALUE("object.method_intQScriptValue(4, null)", v8::Undefined())); @@ -1956,7 +1950,7 @@ void tst_qdeclarativeecmascript::callQtInvokables() QCOMPARE(o.invoked(), 15); QCOMPARE(o.actuals().count(), 2); QCOMPARE(o.actuals().at(0), QVariant(4)); - QVERIFY(qvariant_cast<QScriptValue>(o.actuals().at(1)).isNull()); + QVERIFY(qvariant_cast<QJSValue>(o.actuals().at(1)).isNull()); o.reset(); QVERIFY(EVALUATE_VALUE("object.method_intQScriptValue(8, undefined)", v8::Undefined())); @@ -1964,7 +1958,7 @@ void tst_qdeclarativeecmascript::callQtInvokables() QCOMPARE(o.invoked(), 15); QCOMPARE(o.actuals().count(), 2); QCOMPARE(o.actuals().at(0), QVariant(8)); - QVERIFY(qvariant_cast<QScriptValue>(o.actuals().at(1)).isUndefined()); + QVERIFY(qvariant_cast<QJSValue>(o.actuals().at(1)).isUndefined()); o.reset(); QVERIFY(EVALUATE_VALUE("object.method_intQScriptValue(3, 19)", v8::Undefined())); @@ -1972,7 +1966,7 @@ void tst_qdeclarativeecmascript::callQtInvokables() QCOMPARE(o.invoked(), 15); QCOMPARE(o.actuals().count(), 2); QCOMPARE(o.actuals().at(0), QVariant(3)); - QVERIFY(qvariant_cast<QScriptValue>(o.actuals().at(1)).strictlyEquals(QScriptValue(engine, 19))); + QVERIFY(qvariant_cast<QJSValue>(o.actuals().at(1)).strictlyEquals(QJSValue(19))); o.reset(); QVERIFY(EVALUATE_VALUE("object.method_intQScriptValue(44, [19, 20])", v8::Undefined())); @@ -1980,8 +1974,7 @@ void tst_qdeclarativeecmascript::callQtInvokables() QCOMPARE(o.invoked(), 15); QCOMPARE(o.actuals().count(), 2); QCOMPARE(o.actuals().at(0), QVariant(44)); - QVERIFY(qvariant_cast<QScriptValue>(o.actuals().at(1)).isArray()); -#endif + QVERIFY(qvariant_cast<QJSValue>(o.actuals().at(1)).isArray()); o.reset(); QVERIFY(EVALUATE_ERROR("object.method_overload()")); diff --git a/tests/auto/declarative/qdeclarativeinstruction/qdeclarativeinstruction.pro b/tests/auto/declarative/qdeclarativeinstruction/qdeclarativeinstruction.pro index a3ca541485..a4cdd81266 100644 --- a/tests/auto/declarative/qdeclarativeinstruction/qdeclarativeinstruction.pro +++ b/tests/auto/declarative/qdeclarativeinstruction/qdeclarativeinstruction.pro @@ -1,5 +1,5 @@ load(qttest_p4) -contains(QT_CONFIG,declarative): QT += declarative script +contains(QT_CONFIG,declarative): QT += declarative SOURCES += tst_qdeclarativeinstruction.cpp macx:CONFIG -= app_bundle @@ -9,4 +9,4 @@ macx:CONFIG -= app_bundle CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativelanguage/qdeclarativelanguage.pro b/tests/auto/declarative/qdeclarativelanguage/qdeclarativelanguage.pro index 88dc6128ed..71d2066608 100644 --- a/tests/auto/declarative/qdeclarativelanguage/qdeclarativelanguage.pro +++ b/tests/auto/declarative/qdeclarativelanguage/qdeclarativelanguage.pro @@ -1,6 +1,6 @@ load(qttest_p4) contains(QT_CONFIG,declarative): QT += declarative -QT += script network +QT += network macx:CONFIG -= app_bundle SOURCES += tst_qdeclarativelanguage.cpp \ @@ -20,4 +20,4 @@ symbian: { } CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativelistmodel/qdeclarativelistmodel.pro b/tests/auto/declarative/qdeclarativelistmodel/qdeclarativelistmodel.pro index 85340e70e6..83ea7992ed 100644 --- a/tests/auto/declarative/qdeclarativelistmodel/qdeclarativelistmodel.pro +++ b/tests/auto/declarative/qdeclarativelistmodel/qdeclarativelistmodel.pro @@ -1,6 +1,5 @@ load(qttest_p4) contains(QT_CONFIG,declarative): QT += declarative -QT += script macx:CONFIG -= app_bundle SOURCES += tst_qdeclarativelistmodel.cpp @@ -15,4 +14,4 @@ symbian: { CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private opengl-private +QT += core-private gui-private declarative-private opengl-private diff --git a/tests/auto/declarative/qdeclarativeproperty/qdeclarativeproperty.pro b/tests/auto/declarative/qdeclarativeproperty/qdeclarativeproperty.pro index d96b26aee9..fd55ed5160 100644 --- a/tests/auto/declarative/qdeclarativeproperty/qdeclarativeproperty.pro +++ b/tests/auto/declarative/qdeclarativeproperty/qdeclarativeproperty.pro @@ -14,4 +14,4 @@ symbian: { CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativeqt/qdeclarativeqt.pro b/tests/auto/declarative/qdeclarativeqt/qdeclarativeqt.pro index cd9dabf3bd..304e168e00 100644 --- a/tests/auto/declarative/qdeclarativeqt/qdeclarativeqt.pro +++ b/tests/auto/declarative/qdeclarativeqt/qdeclarativeqt.pro @@ -1,5 +1,5 @@ load(qttest_p4) -contains(QT_CONFIG,declarative): QT += declarative script +contains(QT_CONFIG,declarative): QT += declarative SOURCES += tst_qdeclarativeqt.cpp macx:CONFIG -= app_bundle @@ -16,4 +16,4 @@ symbian: { CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativescriptdebugging/qdeclarativescriptdebugging.pro b/tests/auto/declarative/qdeclarativescriptdebugging/qdeclarativescriptdebugging.pro index 9187bea10b..cedb92743e 100644 --- a/tests/auto/declarative/qdeclarativescriptdebugging/qdeclarativescriptdebugging.pro +++ b/tests/auto/declarative/qdeclarativescriptdebugging/qdeclarativescriptdebugging.pro @@ -1,5 +1,5 @@ load(qttest_p4) -contains(QT_CONFIG,declarative): QT += declarative script +contains(QT_CONFIG,declarative): QT += declarative macx:CONFIG -= app_bundle SOURCES += tst_qdeclarativescriptdebugging.cpp @@ -18,4 +18,4 @@ symbian: { CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativesmoothedanimation/qdeclarativesmoothedanimation.pro b/tests/auto/declarative/qdeclarativesmoothedanimation/qdeclarativesmoothedanimation.pro index 5bc4261a28..c8f8e9139b 100644 --- a/tests/auto/declarative/qdeclarativesmoothedanimation/qdeclarativesmoothedanimation.pro +++ b/tests/auto/declarative/qdeclarativesmoothedanimation/qdeclarativesmoothedanimation.pro @@ -14,4 +14,4 @@ symbian: { CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativespringanimation/qdeclarativespringanimation.pro b/tests/auto/declarative/qdeclarativespringanimation/qdeclarativespringanimation.pro index 9885c6521e..f2b5928915 100644 --- a/tests/auto/declarative/qdeclarativespringanimation/qdeclarativespringanimation.pro +++ b/tests/auto/declarative/qdeclarativespringanimation/qdeclarativespringanimation.pro @@ -14,4 +14,4 @@ symbian: { CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativesqldatabase/qdeclarativesqldatabase.pro b/tests/auto/declarative/qdeclarativesqldatabase/qdeclarativesqldatabase.pro index c48cdf7b55..a51eaf34de 100644 --- a/tests/auto/declarative/qdeclarativesqldatabase/qdeclarativesqldatabase.pro +++ b/tests/auto/declarative/qdeclarativesqldatabase/qdeclarativesqldatabase.pro @@ -1,6 +1,6 @@ load(qttest_p4) contains(QT_CONFIG,declarative): QT += declarative -QT += sql script +QT += sql macx:CONFIG -= app_bundle SOURCES += tst_qdeclarativesqldatabase.cpp @@ -15,4 +15,4 @@ symbian: { CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativestates/qdeclarativestates.pro b/tests/auto/declarative/qdeclarativestates/qdeclarativestates.pro index c34b8d8319..9823c21836 100644 --- a/tests/auto/declarative/qdeclarativestates/qdeclarativestates.pro +++ b/tests/auto/declarative/qdeclarativestates/qdeclarativestates.pro @@ -13,4 +13,4 @@ symbian: { } CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private opengl-private +QT += core-private gui-private declarative-private opengl-private diff --git a/tests/auto/declarative/qdeclarativev4/qdeclarativev4.pro b/tests/auto/declarative/qdeclarativev4/qdeclarativev4.pro index 0a2005d15d..9b66edff41 100644 --- a/tests/auto/declarative/qdeclarativev4/qdeclarativev4.pro +++ b/tests/auto/declarative/qdeclarativev4/qdeclarativev4.pro @@ -1,5 +1,5 @@ load(qttest_p4) -contains(QT_CONFIG,declarative): QT += declarative script network +contains(QT_CONFIG,declarative): QT += declarative network macx:CONFIG -= app_bundle SOURCES += tst_qdeclarativev4.cpp \ @@ -16,4 +16,4 @@ symbian: { CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativevaluetypes/qdeclarativevaluetypes.pro b/tests/auto/declarative/qdeclarativevaluetypes/qdeclarativevaluetypes.pro index f5567e96ed..f1c64398e9 100644 --- a/tests/auto/declarative/qdeclarativevaluetypes/qdeclarativevaluetypes.pro +++ b/tests/auto/declarative/qdeclarativevaluetypes/qdeclarativevaluetypes.pro @@ -17,4 +17,4 @@ symbian: { CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativeworkerscript/qdeclarativeworkerscript.pro b/tests/auto/declarative/qdeclarativeworkerscript/qdeclarativeworkerscript.pro index 08ae7c164c..d7dfe96c65 100644 --- a/tests/auto/declarative/qdeclarativeworkerscript/qdeclarativeworkerscript.pro +++ b/tests/auto/declarative/qdeclarativeworkerscript/qdeclarativeworkerscript.pro @@ -1,5 +1,5 @@ load(qttest_p4) -contains(QT_CONFIG,declarative): QT += declarative script +contains(QT_CONFIG,declarative): QT += declarative macx:CONFIG -= app_bundle SOURCES += tst_qdeclarativeworkerscript.cpp @@ -14,4 +14,4 @@ symbian: { CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qdeclarativeworkerscript/tst_qdeclarativeworkerscript.cpp b/tests/auto/declarative/qdeclarativeworkerscript/tst_qdeclarativeworkerscript.cpp index cbf152bf8b..5e67360e15 100644 --- a/tests/auto/declarative/qdeclarativeworkerscript/tst_qdeclarativeworkerscript.cpp +++ b/tests/auto/declarative/qdeclarativeworkerscript/tst_qdeclarativeworkerscript.cpp @@ -43,7 +43,7 @@ #include <QtCore/qtimer.h> #include <QtCore/qdir.h> #include <QtCore/qfileinfo.h> -#include <QtScript/qscriptengine.h> +#include <QtDeclarative/qjsengine.h> #include <QtDeclarative/qdeclarativecomponent.h> #include <QtDeclarative/qdeclarativeengine.h> diff --git a/tests/auto/declarative/qdeclarativexmllistmodel/qdeclarativexmllistmodel.pro b/tests/auto/declarative/qdeclarativexmllistmodel/qdeclarativexmllistmodel.pro index bedd0a4602..139d4b4e0b 100644 --- a/tests/auto/declarative/qdeclarativexmllistmodel/qdeclarativexmllistmodel.pro +++ b/tests/auto/declarative/qdeclarativexmllistmodel/qdeclarativexmllistmodel.pro @@ -1,5 +1,5 @@ load(qttest_p4) -contains(QT_CONFIG,declarative): QT += declarative script gui network +contains(QT_CONFIG,declarative): QT += declarative gui network contains(QT_CONFIG,xmlpatterns) { QT += xmlpatterns DEFINES += QTEST_XMLPATTERNS @@ -18,4 +18,4 @@ symbian: { CONFIG += parallel_test -QT += core-private gui-private declarative-private script-private +QT += core-private gui-private declarative-private diff --git a/tests/auto/declarative/qjsengine/qjsengine.pro b/tests/auto/declarative/qjsengine/qjsengine.pro new file mode 100644 index 0000000000..87e52ce25d --- /dev/null +++ b/tests/auto/declarative/qjsengine/qjsengine.pro @@ -0,0 +1,21 @@ +load(qttest_p4) +QT += declarative +macx:CONFIG -= app_bundle +SOURCES += tst_qjsengine.cpp + +wince* { + DEFINES += SRCDIR=\\\"./\\\" +} else:!symbian { + DEFINES += SRCDIR=\\\"$$PWD\\\" +} + +wince*|symbian: { + addFiles.files = script + addFiles.path = . + DEPLOYMENT += addFiles +} + +symbian: { + TARGET.UID3 = 0xE0340006 + DEFINES += SYMBIAN_SRCDIR_UID=$$lower($$replace(TARGET.UID3,"0x","")) +} diff --git a/tests/auto/declarative/qjsengine/script/com/__init__.js b/tests/auto/declarative/qjsengine/script/com/__init__.js new file mode 100644 index 0000000000..7db3ee4cac --- /dev/null +++ b/tests/auto/declarative/qjsengine/script/com/__init__.js @@ -0,0 +1,9 @@ +var wasDefinedAlready = (this["com"] != undefined); +__setupPackage__("com"); +com.wasDefinedAlready = wasDefinedAlready; +com.name = __extension__; +com.level = 1; + +com.postInitCallCount = 0; +com.originalPostInit = __postInit__; +__postInit__ = function() { ++com.postInitCallCount; }; diff --git a/tests/auto/declarative/qjsengine/script/com/trolltech/__init__.js b/tests/auto/declarative/qjsengine/script/com/trolltech/__init__.js new file mode 100644 index 0000000000..a55b1328ba --- /dev/null +++ b/tests/auto/declarative/qjsengine/script/com/trolltech/__init__.js @@ -0,0 +1,9 @@ +var wasDefinedAlready = (com["trolltech"] != undefined); +__setupPackage__("com.trolltech"); +com.trolltech.wasDefinedAlready = wasDefinedAlready; +com.trolltech.name = __extension__; +com.trolltech.level = com.level + 1; + +com.trolltech.postInitCallCount = 0; +com.trolltech.originalPostInit = __postInit__; +__postInit__ = function() { ++com.trolltech.postInitCallCount; }; diff --git a/tests/auto/declarative/qjsengine/script/com/trolltech/recursive/__init__.js b/tests/auto/declarative/qjsengine/script/com/trolltech/recursive/__init__.js new file mode 100644 index 0000000000..2f4cad48da --- /dev/null +++ b/tests/auto/declarative/qjsengine/script/com/trolltech/recursive/__init__.js @@ -0,0 +1 @@ +__import__("com.trolltech.recursive"); diff --git a/tests/auto/declarative/qjsengine/script/com/trolltech/syntaxerror/__init__.js b/tests/auto/declarative/qjsengine/script/com/trolltech/syntaxerror/__init__.js new file mode 100644 index 0000000000..55bc35b5f2 --- /dev/null +++ b/tests/auto/declarative/qjsengine/script/com/trolltech/syntaxerror/__init__.js @@ -0,0 +1,5 @@ +function () { +} + +0 = 1; + diff --git a/tests/auto/declarative/qjsengine/tst_qjsengine.cpp b/tests/auto/declarative/qjsengine/tst_qjsengine.cpp new file mode 100644 index 0000000000..49febdbf5e --- /dev/null +++ b/tests/auto/declarative/qjsengine/tst_qjsengine.cpp @@ -0,0 +1,6491 @@ +/**************************************************************************** +** +** 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 <QtTest/QtTest> + +#include <qjsengine.h> +#include <qgraphicsitem.h> +#include <qstandarditemmodel.h> +#include <QtCore/qnumeric.h> +#include <stdlib.h> + +Q_DECLARE_METATYPE(QList<int>) +Q_DECLARE_METATYPE(QObjectList) + +//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(QJSEngine &eng) +{ + zapSomeStack(); + eng.collectGarbage(); +} + +class tst_QJSEngine : public QObject +{ + Q_OBJECT + +public: + tst_QJSEngine(); + virtual ~tst_QJSEngine(); + +private slots: + void constructWithParent(); +#if 0 // FIXME: no QScriptContext + void currentContext(); + void pushPopContext(); +#endif +#if 0 // FIXME: No prototype API in QScriptEngine + void getSetDefaultPrototype_int(); + void getSetDefaultPrototype_customType(); +#endif +#if 0 // FIXME: no QScriptContext + void newFunction(); + void newFunctionWithArg(); + void newFunctionWithProto(); +#endif + void newObject(); + void newArray(); + void newArray_HooliganTask218092(); + void newArray_HooliganTask233836(); + void newVariant(); +#if 0 // FIXME: No prototype API in QScriptEngine + void newVariant_defaultPrototype(); +#endif +#if 0 // ###FIXME: No QVariant object promotion API + void newVariant_promoteObject(); + void newVariant_replaceValue(); +#endif + void newVariant_valueOfToString(); +#if 0 // ###FIXME: No QVariant object promotion API + void newVariant_promoteNonObject(); + void newVariant_promoteNonQScriptObject(); +#endif + void newRegExp(); + void jsRegExp(); + void newDate(); + void jsParseDate(); + void newQObject(); + void newQObject_ownership(); + void newQObject_promoteObject(); + void newQObject_sameQObject(); +#if 0 // FIXME: No prototype API in QScriptEngine + void newQObject_defaultPrototype(); +#endif + void newQObject_promoteNonObject(); + void newQObject_promoteNonQScriptObject(); +#if 0 // ### FIXME: No QScript Metaobject support right now + void newQMetaObject(); + void newActivationObject(); +#endif +#if 0 // ###FIXME: No setGlobalObject support - yay + void getSetGlobalObjectSimple(); + void getSetGlobalObject(); +#endif + void globalObjectProperties(); + void globalObjectEquals(); +#if 0 // ###FIXME: No QScriptValueIterator API + void globalObjectProperties_enumerate(); +#endif + void createGlobalObjectProperty(); + void globalObjectGetterSetterProperty(); +#if 0 // ###FIXME: No support for setting the global object + void customGlobalObjectWithPrototype(); +#endif + void globalObjectWithCustomPrototype(); + void builtinFunctionNames_data(); + void builtinFunctionNames(); +#if 0 // ###FIXME: No syntax checking result + void checkSyntax_data(); + void checkSyntax(); +#endif +#if 0 // ###FIXME: No support for canEvaluate + void canEvaluate_data(); + void canEvaluate(); +#endif + void evaluate_data(); + void evaluate(); +#if 0 // ###FIXME: no support for c-style callbacks + void nestedEvaluate(); +#endif +#if 0 // ### FIXME: No c-style callbacks + void uncaughtException(); +#endif + void errorMessage_QT679(); + void valueConversion_basic(); +#if 0 // FIXME: No API for custom types + void valueConversion_customType(); + void valueConversion_sequence(); +#endif + void valueConversion_QVariant(); +#if 0 // FIXME: No support for custom types + void valueConversion_hooliganTask248802(); +#endif + void valueConversion_basic2(); + void valueConversion_dateTime(); + void valueConversion_regExp(); +#if 0 // FIXME: No qScriptValueFromValue + void qScriptValueFromValue_noEngine(); +#endif +#if 0 // ###FIXME: No QScriptContext + void importExtension(); + void infiniteRecursion(); +#endif +#if 0 // FIXME: No support for default prototypes + void castWithPrototypeChain(); +#endif + void castWithMultipleInheritance(); +#if 0 // ###FIXME: ScriptOwnership + void collectGarbage(); +#endif +#if 0 // ###FIXME: no reportAdditionalMemoryCost API + void reportAdditionalMemoryCost(); +#endif + void gcWithNestedDataStructure(); +#if 0 // ###FIXME: No processEvents handling + void processEventsWhileRunning(); + void processEventsWhileRunning_function(); + void throwErrorFromProcessEvents_data(); + void throwErrorFromProcessEvents(); + void disableProcessEventsInterval(); +#endif +#if 0 // ###FIXME: No QScriptValueIterator API + void stacktrace(); +#endif + void numberParsing_data(); + void numberParsing(); + void automaticSemicolonInsertion(); +#if 0 // ###FIXME: no abortEvaluation API + void abortEvaluation_notEvaluating(); + void abortEvaluation_data(); + void abortEvaluation(); + void abortEvaluation_tryCatch(); + void abortEvaluation_fromNative(); + void abortEvaluation_QTBUG9433(); +#endif +#if 0 // ###FIXME: no QScriptEngine::isEvaluating + void isEvaluating_notEvaluating(); + void isEvaluating_fromNative(); + void isEvaluating_fromEvent(); +#endif +#if 0 // ###FIXME: depracated + void printFunctionWithCustomHandler(); + void printThrowsException(); +#endif + void errorConstructors(); + void argumentsProperty_globalContext(); + void argumentsProperty_JS(); +#if 0 // ###FIXME: no QScriptContext API + void argumentsProperty_evaluateInNativeFunction(); +#endif + 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(); +#if 0 // ###FIXME: no QScriptContext API + void getterSetterThisObject_activation(); +#endif + void jsContinueInSwitch(); + void jsShadowReadOnlyPrototypeProperty(); + void toObject(); + void jsReservedWords_data(); + void jsReservedWords(); + void jsFutureReservedWords_data(); + void jsFutureReservedWords(); + void jsThrowInsideWithStatement(); +#if 0 // ###FIXME: No QScriptEngineAgent API + void getSetAgent_ownership(); + void getSetAgent_deleteAgent(); + void getSetAgent_differentEngine(); +#endif +#if 0 // ###FIXME: No QScriptString API + void reentrancy_stringHandles(); +#endif +#if 0 // ###FIXME: No processEventsInterval API + void reentrancy_processEventsInterval(); +#endif +#if 0 // FIXME: No support for custom types + void reentrancy_typeConversion(); +#endif + void reentrancy_globalObjectProperties(); + void reentrancy_Array(); + void reentrancy_objectCreation(); + void jsIncDecNonObjectProperty(); +#if 0 // ###FIXME: no installTranslatorFunctions API + 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(); +#endif +#if 0 // ###FIXME: No QScriptValue::scope API + void functionScopes(); +#endif +#if 0 // ###FIXME: No QScriptContext API + void nativeFunctionScopes(); +#endif +#if 0 // ###FIXME: No QScriptProgram API + void evaluateProgram(); + void evaluateProgram_customScope(); + void evaluateProgram_closure(); + void evaluateProgram_executeLater(); + void evaluateProgram_multipleEngines(); + void evaluateProgram_empty(); +#endif +#if 0 // ###FIXME: No QScriptContext API + void collectGarbageAfterConnect(); + void collectGarbageAfterNativeArguments(); + void promoteThisObjectToQObjectInConstructor(); +#endif +#if 0 // ###FIXME: No QScript MetaObject API + void scriptValueFromQMetaObject(); +#endif + + void qRegExpInport_data(); + void qRegExpInport(); +#if 0 // ###FIXME: No QScriptContext API + void reentrency(); +#endif +#if 0 // ###FIXME: No QSCriptDeclarativeClass API + void newFixedStaticScopeObject(); + void newGrowingStaticScopeObject(); +#endif + void dateRoundtripJSQtJS(); + void dateRoundtripQtJSQt(); + void dateConversionJSQt(); + void dateConversionQtJS(); +}; + +tst_QJSEngine::tst_QJSEngine() +{ +} + +tst_QJSEngine::~tst_QJSEngine() +{ +} + +void tst_QJSEngine::constructWithParent() +{ + QPointer<QJSEngine> ptr; + { + QObject obj; + QJSEngine *engine = new QJSEngine(&obj); + ptr = engine; + } + QVERIFY(ptr == 0); +} + +#if 0 // FIXME: no QScriptContext +void tst_QJSEngine::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_QJSEngine::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"); +} + +static QScriptValue myFunctionThatReturns(QScriptContext *, QScriptEngine *eng) +{ + return QScriptValue(eng, 42); +} + +static QScriptValue myFunctionThatReturnsWithoutEngine(QScriptContext *, QScriptEngine *) +{ + return QScriptValue(1024); +} + +static QScriptValue myFunctionThatReturnsWrongEngine(QScriptContext *, QScriptEngine *, void *arg) +{ + QScriptEngine* wrongEngine = reinterpret_cast<QScriptEngine*>(arg); + return QScriptValue(wrongEngine, 42); +} + +static QScriptValue sumFunction(QScriptContext *context, QScriptEngine *engine) +{ + int sum = 0; + + for (int i = 0; i < context->argumentCount(); i++) { + QScriptValue n = context->argument(i); + if (n.isNumber()) + sum += n.toInteger(); + } + + return QScriptValue(engine, sum); +} + +void tst_QJSEngine::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_QJSEngine::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_QJSEngine::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); + } + // whether the return value is correct + { + QScriptValue fun = eng.newFunction(myFunctionThatReturns); + QCOMPARE(fun.isValid(), true); + QCOMPARE(fun.isFunction(), true); + QCOMPARE(fun.isObject(), true); + + QScriptValue result = fun.call(); + QCOMPARE(result.isNumber(), true); + QCOMPARE(result.toInt32(), 42); + } + // whether the return value is assigned to the correct engine + { + QScriptValue fun = eng.newFunction(myFunctionThatReturnsWithoutEngine); + QCOMPARE(fun.isValid(), true); + QCOMPARE(fun.isFunction(), true); + QCOMPARE(fun.isObject(), true); + + QScriptValue result = fun.call(); + QCOMPARE(result.engine(), &eng); + QCOMPARE(result.isNumber(), true); + QCOMPARE(result.toInt32(), 1024); + } + // whether the return value is undefined when returning a value with wrong engine + { + QScriptEngine wrongEngine; + + QScriptValue fun = eng.newFunction(myFunctionThatReturnsWrongEngine, reinterpret_cast<void *>(&wrongEngine)); + QCOMPARE(fun.isValid(), true); + QCOMPARE(fun.isFunction(), true); + QCOMPARE(fun.isObject(), true); + + QTest::ignoreMessage(QtWarningMsg, "QScriptValue::call(): Value from different engine returned from native function, returning undefined value instead."); + QScriptValue result = fun.call(); + QCOMPARE(result.isValid(), true); + QCOMPARE(result.isUndefined(), true); + } + // checking if arguments are passed correctly + { + QScriptEngine wrongEngine; + + QScriptValue fun = eng.newFunction(sumFunction); + QCOMPARE(fun.isValid(), true); + QCOMPARE(fun.isFunction(), true); + QCOMPARE(fun.isObject(), true); + + QScriptValue result = fun.call(); + QCOMPARE(result.isNumber(), true); + QCOMPARE(result.toInt32(), 0); + + result = fun.call(QScriptValue(), QScriptValueList() << 1); + QCOMPARE(result.isNumber(), true); + QCOMPARE(result.toInt32(), 1); + + result = fun.call(QScriptValue(), QScriptValueList() << 1 << 2 << 3); + QCOMPARE(result.isNumber(), true); + QCOMPARE(result.toInt32(), 6); + + result = fun.call(QScriptValue(), QScriptValueList() << 1 << 2 << 3 << 4); + QCOMPARE(result.isNumber(), true); + QCOMPARE(result.toInt32(), 10); + } +} +#endif + +void tst_QJSEngine::newObject() +{ + QJSEngine eng; + QJSValue object = eng.newObject(); + QCOMPARE(object.isValid(), true); + QCOMPARE(object.isObject(), true); + QCOMPARE(object.isFunction(), false); +// ###FIXME: No QScriptClass 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_QJSEngine::newArray() +{ + QJSEngine eng; + QJSValue array = eng.newArray(); + QCOMPARE(array.isValid(), true); + QCOMPARE(array.isArray(), true); + QCOMPARE(array.isObject(), true); + QVERIFY(!array.isFunction()); +// ###FIXME: No QScriptClass 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_QJSEngine::newArray_HooliganTask218092() +{ + QJSEngine eng; + { + QJSValue ret = eng.evaluate("[].splice(0, 0, 'a')"); + QVERIFY(ret.isArray()); + QCOMPARE(ret.property("length").toInt32(), 0); + } + { + QJSValue ret = eng.evaluate("['a'].splice(0, 1, 'b')"); + QVERIFY(ret.isArray()); + QCOMPARE(ret.property("length").toInt32(), 1); + } + { + QJSValue ret = eng.evaluate("['a', 'b'].splice(0, 1, 'c')"); + QVERIFY(ret.isArray()); + QCOMPARE(ret.property("length").toInt32(), 1); + } + { + QJSValue ret = eng.evaluate("['a', 'b', 'c'].splice(0, 2, 'd')"); + QVERIFY(ret.isArray()); + QCOMPARE(ret.property("length").toInt32(), 2); + } + { + QJSValue ret = eng.evaluate("['a', 'b', 'c'].splice(1, 2, 'd', 'e', 'f')"); + QVERIFY(ret.isArray()); + QCOMPARE(ret.property("length").toInt32(), 2); + } +} + +void tst_QJSEngine::newArray_HooliganTask233836() +{ + QJSEngine eng; + { + // According to ECMA-262, this should cause a RangeError. + QJSValue ret = eng.evaluate("a = new Array(4294967295); a.push('foo')"); + QVERIFY(ret.isError() && ret.toString().contains(QLatin1String("RangeError"))); + } + { + QJSValue ret = eng.newArray(0xFFFFFFFF); + QEXPECT_FAIL("", "The maximum length of arrays is defined by v8 currently and differs from QtScript", Abort); + 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_QJSEngine::newVariant() +{ + QJSEngine eng; + { + QJSValue opaque = eng.newVariant(QVariant()); + QCOMPARE(opaque.isValid(), true); + QCOMPARE(opaque.isVariant(), true); + QVERIFY(!opaque.isFunction()); + QCOMPARE(opaque.isObject(), true); + QCOMPARE(opaque.prototype().isValid(), true); + QEXPECT_FAIL("", "FIXME: newly created QObject's prototype is an JS Object", Continue); + QCOMPARE(opaque.prototype().isVariant(), true); + QVERIFY(opaque.property("valueOf").call(opaque).isUndefined()); + } +} + +#if 0 // FIXME: No prototype API in QScriptEngine +void tst_QJSEngine::newVariant_defaultPrototype() +{ + // default prototype should be set automatically + QScriptEngine eng; + { + QScriptValue proto = eng.newObject(); + eng.setDefaultPrototype(qMetaTypeId<QString>(), proto); + QScriptValue ret = eng.newVariant(QVariant(QString::fromLatin1("hello"))); + QVERIFY(ret.isVariant()); +// ###FIXME: No QScriptClass QCOMPARE(ret.scriptClass(), (QScriptClass*)0); + QVERIFY(ret.prototype().strictlyEquals(proto)); + eng.setDefaultPrototype(qMetaTypeId<QString>(), QScriptValue()); + QScriptValue ret2 = eng.newVariant(QVariant(QString::fromLatin1("hello"))); + QVERIFY(ret2.isVariant()); + QVERIFY(!ret2.prototype().strictlyEquals(proto)); + } +} +#endif + +#if 0 // ###FIXME: No QVariant object promotion API +void tst_QJSEngine::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(); + QSKIP("It is not possible to promote plain object to a wrapper", SkipAll); + 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_QJSEngine::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)); + } + } +} +#endif + +void tst_QJSEngine::newVariant_valueOfToString() +{ + // valueOf() and toString() + QJSEngine eng; + { + QJSValue object = eng.newVariant(QVariant(123)); + QJSValue 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()); + } + { + QJSValue object = eng.newVariant(QVariant(QString::fromLatin1("hello"))); + QJSValue 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()); + } + { + QJSValue object = eng.newVariant(QVariant(false)); + QJSValue 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()); + } + { + QJSValue object = eng.newVariant(QVariant(QPoint(10, 20))); + QJSValue value = object.property("valueOf").call(object); + QVERIFY(value.isObject()); + QVERIFY(value.strictlyEquals(object)); + QCOMPARE(object.toString(), QString::fromLatin1("QVariant(QPoint)")); + } +} + +#if 0 // ###FIXME: No QVariant object promotion API +void tst_QJSEngine::newVariant_promoteNonObject() +{ + QScriptEngine eng; + { + QVariant var(456); + QScriptValue ret = eng.newVariant(123, var); + QVERIFY(ret.isVariant()); + QCOMPARE(ret.toVariant(), var); + } +} + +void tst_QJSEngine::newVariant_promoteNonQScriptObject() +{ + QSKIP("This test relay on limitation of QtScript JSC implementation", SkipAll); + QScriptEngine eng; + { + QTest::ignoreMessage(QtWarningMsg, "QScriptEngine::newVariant(): changing class of non-QScriptObject not supported"); + QScriptValue ret = eng.newVariant(eng.newArray(), 123); + QVERIFY(!ret.isValid()); + } +} +#endif + +void tst_QJSEngine::newRegExp() +{ + QJSEngine eng; + for (int x = 0; x < 2; ++x) { + QJSValue 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_QJSEngine::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. + + QJSEngine eng; + QJSValue r = eng.evaluate("/foo/gim"); + QVERIFY(r.isRegExp()); + QCOMPARE(r.toString(), QString::fromLatin1("/foo/gim")); + + QJSValue rxCtor = eng.globalObject().property("RegExp"); + QJSValue r2 = rxCtor.call(QJSValue(), QJSValueList() << r); + QVERIFY(r2.isRegExp()); + QVERIFY(r2.strictlyEquals(r)); + + QJSValue r3 = rxCtor.call(QJSValue(), QJSValueList() << r << "gim"); + QVERIFY(r3.isError()); + QVERIFY(r3.toString().contains(QString::fromLatin1("TypeError"))); // Cannot supply flags when constructing one RegExp from another + + QJSValue r4 = rxCtor.call(QJSValue(), QJSValueList() << "foo" << "gim"); + QVERIFY(r4.isRegExp()); + + QJSValue r5 = rxCtor.construct(QJSValueList() << 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. + QVERIFY(!r5.strictlyEquals(r)); + + QEXPECT_FAIL("", "V8 and jsc ignores invalid flags", Continue); //https://bugs.webkit.org/show_bug.cgi?id=41614 + QJSValue r6 = rxCtor.construct(QJSValueList() << "foo" << "bar"); + QVERIFY(r6.isError()); + // QVERIFY(r6.toString().contains(QString::fromLatin1("SyntaxError"))); // Invalid regular expression flag + + + QJSValue r7 = eng.evaluate("/foo/gimp"); + /* v8 and jsc ignores invalid flags + QVERIFY(r7.isError()); + QVERIFY(r7.toString().contains(QString::fromLatin1("SyntaxError"))); // Invalid regular expression flag + */ + + // JSC doesn't complain about duplicate flags. + QJSValue r8 = eng.evaluate("/foo/migmigmig"); + QVERIFY(r8.isRegExp()); + QCOMPARE(r8.toString(), QString::fromLatin1("/foo/gim")); + + QJSValue r9 = rxCtor.construct(); + QVERIFY(r9.isRegExp()); + QCOMPARE(r9.toString(), QString::fromLatin1("/(?:)/")); + + QJSValue r10 = rxCtor.construct(QJSValueList() << "" << "gim"); + QVERIFY(r10.isRegExp()); + QCOMPARE(r10.toString(), QString::fromLatin1("/(?:)/gim")); + + QJSValue r11 = rxCtor.construct(QJSValueList() << "{1.*}" << "g"); + QVERIFY(r11.isRegExp()); + QCOMPARE(r11.toString(), QString::fromLatin1("/{1.*}/g")); +} + +void tst_QJSEngine::newDate() +{ + QJSEngine eng; + + { + QJSValue 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); + QJSValue 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); + QJSValue date = eng.newDate(dt); + // toDateTime() result should be in local time + QCOMPARE(date.toDateTime(), dt.toLocalTime()); + } +} + +void tst_QJSEngine::jsParseDate() +{ + QJSEngine eng; + // Date.parse() should return NaN when it fails + { + QJSValue 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 + { + QJSValue 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_QJSEngine::newQObject() +{ + QJSEngine eng; + + { + QJSValue qobject = eng.newQObject(0); + QCOMPARE(qobject.isValid(), true); + QCOMPARE(qobject.isNull(), true); + QCOMPARE(qobject.isObject(), false); + QCOMPARE(qobject.toQObject(), (QObject *)0); + } + { + QJSValue 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); + QEXPECT_FAIL("", "FIXME: newly created QObject's prototype is an JS Object", Continue); + QCOMPARE(qobject.prototype().isQObject(), true); +// ###FIXME: No QScriptClass QCOMPARE(qobject.scriptClass(), (QScriptClass*)0); + } +} + +void tst_QJSEngine::newQObject_ownership() +{ +#if 0 // FIXME: ownership tests need to be revivewed + QScriptEngine eng; + { + QPointer<QObject> 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<QObject> 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<QObject> 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<QObject> 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; + } +#endif +} + +void tst_QJSEngine::newQObject_promoteObject() +{ +#if 0 // ### FIXME: object promotion is not supported + 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)); + } + } +#endif +} + +void tst_QJSEngine::newQObject_sameQObject() +{ +#if 0 // ###FIXME: No QObjectWrapOptions API + QSKIP("This test stongly relay on strictlyEquals feature that would change in near future", SkipAll); + 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); + } +#endif +} + +#if 0 // FIXME: No prototype API in QScriptEngine +void tst_QJSEngine::newQObject_defaultPrototype() +{ + QScriptEngine eng; + // newQObject() should set the default prototype, if one has been registered + { + QScriptValue oldQObjectProto = eng.defaultPrototype(qMetaTypeId<QObject*>()); + + QScriptValue qobjectProto = eng.newObject(); + eng.setDefaultPrototype(qMetaTypeId<QObject*>(), qobjectProto); + { + QScriptValue ret = eng.newQObject(this); + QVERIFY(ret.prototype().equals(qobjectProto)); + } + QScriptValue tstProto = eng.newObject(); + int typeId = qRegisterMetaType<tst_QJSEngine*>("tst_QJSEngine*"); + eng.setDefaultPrototype(typeId, tstProto); + { + QScriptValue ret = eng.newQObject(this); + QVERIFY(ret.prototype().equals(tstProto)); + } + + eng.setDefaultPrototype(qMetaTypeId<QObject*>(), oldQObjectProto); + eng.setDefaultPrototype(typeId, QScriptValue()); + } +} +#endif + +void tst_QJSEngine::newQObject_promoteNonObject() +{ +#if 0 // ### FIXME: object promotion is not supported + QScriptEngine eng; + { + QScriptValue ret = eng.newQObject(123, this); + QVERIFY(ret.isQObject()); + QCOMPARE(ret.toQObject(), this); + } +#endif +} + +void tst_QJSEngine::newQObject_promoteNonQScriptObject() +{ +#if 0 // ### FIXME: object promotion is not supported + QSKIP("Promotion of non QScriptObjects kind of works (there is not difference between Object and Array, look at comments in newQObject implementation).", SkipAll); + QScriptEngine eng; + { + QTest::ignoreMessage(QtWarningMsg, "QScriptEngine::newQObject(): changing class of non-QScriptObject not supported"); + QScriptValue ret = eng.newQObject(eng.newArray(), this); + QVERIFY(!ret.isValid()); + } +#endif +} + +#if 0 // ### FIXME: No QScript Metaobject support right now +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_QJSEngine::newQMetaObject() +{ + QScriptEngine eng; +#if 0 + QScriptValue qclass = eng.newQMetaObject<QObject>(); + QScriptValue qclass2 = eng.newQMetaObject<QWidget>(); +#else + QScriptValue qclass = qScriptValueFromQMetaObject<QObject>(&eng); + QScriptValue qclass2 = qScriptValueFromQMetaObject<QWidget>(&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()); + QEXPECT_FAIL("", "FIXME: newQMetaObject not implemented properly yet", Abort); + 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<QObject> qpointer1 = instance.toQObject(); + QPointer<QObject> qpointer2 = instance2.toQObject(); + QPointer<QObject> 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)); + } +} +#endif + +#if 0 // ###FIXME: No activation object support +void tst_QJSEngine::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()); +} +#endif + +#if 0 // ###FIXME: No setGlobalObject support - yay +void tst_QJSEngine::getSetGlobalObjectSimple() +{ + QScriptEngine engine; + QScriptValue object = engine.newObject(); + object.setProperty("foo", 123); + engine.evaluate("var bar = 100"); + engine.setGlobalObject(object); + engine.evaluate("rab = 100"); + QVERIFY(engine.globalObject().property("rab").isValid()); + QVERIFY(engine.globalObject().property("foo").isValid()); + QVERIFY(!engine.globalObject().property("bar").isValid()); +} + +void tst_QJSEngine::getSetGlobalObject() +{ + QScriptEngine eng; + QScriptValue glob = eng.globalObject(); + glob = QScriptValue(); // kill reference to old global object + collectGarbage_helper(eng); + + 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)); + QEXPECT_FAIL("", "FIXME: Do we really want to enforce this? ECMA standard says that it is implementation dependent, skipping for now", Continue); + QCOMPARE(glob.toString(), QString::fromLatin1("[object global]")); + // prototype should be Object.prototype + QCOMPARE(glob.prototype().isValid(), true); + QCOMPARE(glob.prototype().isObject(), true); + QEXPECT_FAIL("", "FIXME: Do we really want to enforce this? ECMA standard says that it is implementation dependent, skipping for now", Continue); + 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)); + QEXPECT_FAIL("", "FIXME: Do we really want to enforce this? ECMA standard says that it is implementation dependent, skipping for now", Continue); + QCOMPARE(eng.globalObject().toString(), QString::fromLatin1("[object global]")); + + collectGarbage_helper(eng); + 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. + //the custom global object have an interceptor + 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")); + } +} +#endif + +#if 0 // ###FIXME: no c-style callbacks +static QScriptValue getSetFoo(QScriptContext *ctx, QScriptEngine *) +{ + if (ctx->argumentCount() > 0) + ctx->thisObject().setProperty("foo", ctx->argument(0)); + return ctx->thisObject().property("foo"); +} +#endif + +void tst_QJSEngine::globalObjectProperties() +{ + // See ECMA-262 Section 15.1, "The Global Object". + + QJSEngine eng; + QJSValue global = eng.globalObject(); + + QVERIFY(global.property("NaN").isNumber()); + QVERIFY(qIsNaN(global.property("NaN").toNumber())); + QCOMPARE(global.propertyFlags("NaN"), QJSValue::SkipInEnumeration | QJSValue::Undeletable); + + QVERIFY(global.property("Infinity").isNumber()); + QVERIFY(qIsInf(global.property("Infinity").toNumber())); + QCOMPARE(global.propertyFlags("NaN"), QJSValue::SkipInEnumeration | QJSValue::Undeletable); + + QVERIFY(global.property("undefined").isUndefined()); + QCOMPARE(global.propertyFlags("undefined"), QJSValue::SkipInEnumeration | QJSValue::Undeletable); + + QVERIFY(global.property("eval").isFunction()); + QCOMPARE(global.propertyFlags("eval"), QJSValue::SkipInEnumeration); + + QVERIFY(global.property("parseInt").isFunction()); + QCOMPARE(global.propertyFlags("parseInt"), QJSValue::SkipInEnumeration); + + QVERIFY(global.property("parseFloat").isFunction()); + QCOMPARE(global.propertyFlags("parseFloat"), QJSValue::SkipInEnumeration); + + QVERIFY(global.property("isNaN").isFunction()); + QCOMPARE(global.propertyFlags("isNaN"), QJSValue::SkipInEnumeration); + + QVERIFY(global.property("isFinite").isFunction()); + QCOMPARE(global.propertyFlags("isFinite"), QJSValue::SkipInEnumeration); + + QVERIFY(global.property("decodeURI").isFunction()); + QCOMPARE(global.propertyFlags("decodeURI"), QJSValue::SkipInEnumeration); + + QVERIFY(global.property("decodeURIComponent").isFunction()); + QCOMPARE(global.propertyFlags("decodeURIComponent"), QJSValue::SkipInEnumeration); + + QVERIFY(global.property("encodeURI").isFunction()); + QCOMPARE(global.propertyFlags("encodeURI"), QJSValue::SkipInEnumeration); + + QVERIFY(global.property("encodeURIComponent").isFunction()); + QCOMPARE(global.propertyFlags("encodeURIComponent"), QJSValue::SkipInEnumeration); + + QVERIFY(global.property("Object").isFunction()); + QCOMPARE(global.propertyFlags("Object"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("Function").isFunction()); + QCOMPARE(global.propertyFlags("Function"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("Array").isFunction()); + QCOMPARE(global.propertyFlags("Array"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("String").isFunction()); + QCOMPARE(global.propertyFlags("String"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("Boolean").isFunction()); + QCOMPARE(global.propertyFlags("Boolean"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("Number").isFunction()); + QCOMPARE(global.propertyFlags("Number"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("Date").isFunction()); + QCOMPARE(global.propertyFlags("Date"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("RegExp").isFunction()); + QCOMPARE(global.propertyFlags("RegExp"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("Error").isFunction()); + QCOMPARE(global.propertyFlags("Error"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("EvalError").isFunction()); + QCOMPARE(global.propertyFlags("EvalError"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("RangeError").isFunction()); + QCOMPARE(global.propertyFlags("RangeError"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("ReferenceError").isFunction()); + QCOMPARE(global.propertyFlags("ReferenceError"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("SyntaxError").isFunction()); + QCOMPARE(global.propertyFlags("SyntaxError"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("TypeError").isFunction()); + QCOMPARE(global.propertyFlags("TypeError"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("URIError").isFunction()); + QCOMPARE(global.propertyFlags("URIError"), QJSValue::SkipInEnumeration); + QVERIFY(global.property("Math").isObject()); + QVERIFY(!global.property("Math").isFunction()); + QCOMPARE(global.propertyFlags("Math"), QJSValue::SkipInEnumeration); +} + +void tst_QJSEngine::globalObjectEquals() +{ + QJSEngine eng; + QJSValue o = eng.globalObject(); + QVERIFY(o.strictlyEquals(eng.globalObject())); + QVERIFY(o.equals(eng.globalObject())); +} + +#if 0 // ###FIXME: No QScriptValueIterator API +void tst_QJSEngine::globalObjectProperties_enumerate() +{ + QScriptEngine eng; + QScriptValue global = eng.globalObject(); + + QSet<QString> 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" + // V8 + << "execScript" //execScript for IE compatibility. + ; + QSet<QString> actualNames; + { + QScriptValueIterator it(global); + while (it.hasNext()) { + it.next(); + actualNames.insert(it.name()); + } + } + + QSet<QString> remainingNames = actualNames; + { + QSet<QString>::const_iterator it; + for (it = expectedNames.constBegin(); it != expectedNames.constEnd(); ++it) { + QString name = *it; + QVERIFY(actualNames.contains(name)); + remainingNames.remove(name); + } + } + QVERIFY(remainingNames.isEmpty()); +} +#endif + +void tst_QJSEngine::createGlobalObjectProperty() +{ + QJSEngine eng; + QJSValue global = eng.globalObject(); + // create property with no attributes + { + QString name = QString::fromLatin1("foo"); + QVERIFY(!global.property(name).isValid()); + QJSValue val(123); + global.setProperty(name, val); + QVERIFY(global.property(name).equals(val)); + QVERIFY(global.propertyFlags(name) == 0); + global.setProperty(name, QJSValue()); + QVERIFY(!global.property(name).isValid()); + } + // create property with attributes +#if 0 // ###FIXME: setProperty with flags is not supported + { + 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()); + } +#endif +} + +void tst_QJSEngine::globalObjectGetterSetterProperty() +{ +#if 0 // ###FIXME: No c-style callbacks + 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)); +#endif +} + +#if 0 // ###FIXME: No support for setting the global object +void tst_QJSEngine::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()); + if (x) QEXPECT_FAIL("", "Why?", Continue); + QVERIFY(!ret.toBool()); + } + { + QScriptValue ret = engine.evaluate("this.hasOwnProperty('print')"); + QVERIFY(ret.isBool()); + if (x) QEXPECT_FAIL("", "Why?", Continue); + 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: print is not defined")); + } + { + 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()); + QVERIFY(ret.toString().startsWith("ReferenceError: ")); + } + { + QScriptValue ret = engine.evaluate("print"); + QVERIFY(ret.isFunction()); + QVERIFY(ret.strictlyEquals(global.property("print"))); + } + QVERIFY(!anotherProto.property("print").isValid()); + } +} +#endif + +void tst_QJSEngine::globalObjectWithCustomPrototype() +{ + QJSEngine engine; + QJSValue proto = engine.newObject(); + proto.setProperty("protoProperty", 123); + QJSValue global = engine.globalObject(); + QJSValue originalProto = global.prototype(); + global.setPrototype(proto); + { + QJSValue ret = engine.evaluate("protoProperty"); + QEXPECT_FAIL("", "Replacing the prototype of the global object is currently unsupported (see also v8 issue 1078)", Abort); + QVERIFY(ret.isNumber()); + QVERIFY(ret.strictlyEquals(global.property("protoProperty"))); + } + { + QJSValue ret = engine.evaluate("this.protoProperty"); + QVERIFY(ret.isNumber()); + QVERIFY(ret.strictlyEquals(global.property("protoProperty"))); + } + { + QJSValue ret = engine.evaluate("hasOwnProperty('protoProperty')"); + QVERIFY(ret.isBool()); + QVERIFY(!ret.toBool()); + } + { + QJSValue ret = engine.evaluate("this.hasOwnProperty('protoProperty')"); + QVERIFY(ret.isBool()); + QVERIFY(!ret.toBool()); + } + + // Custom prototype set from JS + { + QJSValue ret = engine.evaluate("this.__proto__ = { 'a': 123 }; a"); + QVERIFY(ret.isNumber()); + QVERIFY(ret.strictlyEquals(global.property("a"))); + } +} + +void tst_QJSEngine::builtinFunctionNames_data() +{ + QTest::addColumn<QString>("expression"); + QTest::addColumn<QString>("expectedName"); + + // See ECMA-262 Chapter 15, "Standard Built-in ECMAScript Objects". + + 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("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"); +/* In V8, those function are only there for signals + 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_QJSEngine::builtinFunctionNames() +{ + QFETCH(QString, expression); + QFETCH(QString, expectedName); + QJSEngine eng; + // The "name" property is actually non-standard, but JSC supports it. + QJSValue ret = eng.evaluate(QString::fromLatin1("%0.name").arg(expression)); + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), expectedName); +} + +#if 0 // ###FIXME: No syntax checking result +void tst_QJSEngine::checkSyntax_data() +{ + QTest::addColumn<QString>("code"); + QTest::addColumn<int>("expectedState"); + QTest::addColumn<int>("errorLineNumber"); + QTest::addColumn<int>("errorColumnNumber"); + QTest::addColumn<QString>("errorMessage"); + + QTest::newRow("0") + << QString("0") << int(QScriptSyntaxCheckResult::Valid) + << -1 << -1 << ""; + QTest::newRow("if (") + << QString("if (\n") << int(QScriptSyntaxCheckResult::Intermediate) + << 0 << -1 << "Uncaught SyntaxError: Unexpected end of input"; + QTest::newRow("if else") + << QString("\nif else") << int(QScriptSyntaxCheckResult::Error) + << 2 << 3 << "Uncaught SyntaxError: Unexpected token else"; + QTest::newRow("foo[") + << QString("foo[") << int(QScriptSyntaxCheckResult::Intermediate) + << 1 << 4 << "Uncaught SyntaxError: Unexpected end of input"; + QTest::newRow("foo['bar']") + << QString("foo['bar']") << int(QScriptSyntaxCheckResult::Valid) + << -1 << -1 << ""; + + QTest::newRow("/*") + << QString("/*") << int(QScriptSyntaxCheckResult::Error) + << 1 << 0 << "Uncaught SyntaxError: Unexpected token ILLEGAL"; + QTest::newRow("/*\nMy comment") + << QString("/*\nMy comment") << int(QScriptSyntaxCheckResult::Error) + << 1 << 0 << "Uncaught SyntaxError: Unexpected token ILLEGAL"; + 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::Error) + << 1 << 9 << "Uncaught SyntaxError: Unexpected token ILLEGAL"; + QTest::newRow("foo = 10; /*") + << QString("foo = 10; /*") << int(QScriptSyntaxCheckResult::Error) + << 1 << 10 << "Uncaught SyntaxError: Unexpected token ILLEGAL"; + 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_QJSEngine::checkSyntax() +{ + QFETCH(QString, code); + QFETCH(int, expectedState); + QFETCH(int, errorLineNumber); + QFETCH(int, errorColumnNumber); + QFETCH(QString, errorMessage); + + QScriptSyntaxCheckResult result = QScriptEngine::checkSyntax(code); + QCOMPARE(int(result.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()); + } +} +#endif + +#if 0 // ###FIXME: No support for canEvaluate +void tst_QJSEngine::canEvaluate_data() +{ + QTest::addColumn<QString>("code"); + QTest::addColumn<bool>("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[") << false; + QTest::newRow("foo[") << QString("foo[\n") << false; + QTest::newRow("foo['bar']") << QString("foo['bar']") << true; + + //v8 does thinks unterminated comments are error rather than unfinished +// 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_QJSEngine::canEvaluate() +{ + QFETCH(QString, code); + QFETCH(bool, expectSuccess); + + QScriptEngine eng; + QCOMPARE(eng.canEvaluate(code), expectSuccess); +} +#endif + +void tst_QJSEngine::evaluate_data() +{ + QTest::addColumn<QString>("code"); + QTest::addColumn<int>("lineNumber"); + QTest::addColumn<bool>("expectHadError"); + QTest::addColumn<int>("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 << 12; + 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_QJSEngine::evaluate() +{ + QFETCH(QString, code); + QFETCH(int, lineNumber); + QFETCH(bool, expectHadError); + QFETCH(int, expectErrorLineNumber); + + QJSEngine eng; + QJSValue ret; + if (lineNumber != -1) + ret = eng.evaluate(code, /*fileName =*/QString(), lineNumber); + else + ret = eng.evaluate(code); + QEXPECT_FAIL("/a/gimp", "v8 ignore invalid flags", Abort); + QCOMPARE(eng.hasUncaughtException(), expectHadError); +#if 0 // ###FIXME: No support for the line number of an uncaught exception + QEXPECT_FAIL("f()", "SyntaxError do not report line number", Continue); + QEXPECT_FAIL("duplicateLabel: { duplicateLabel: ; }", "SyntaxError do not report line number", Continue); + QCOMPARE(eng.uncaughtExceptionLineNumber(), expectErrorLineNumber); +#endif + if (eng.hasUncaughtException() && ret.isError()) { + QEXPECT_FAIL("", "we have no more lineNumber property ", Continue); + QVERIFY(ret.property("lineNumber").strictlyEquals(QJSValue(&eng, expectErrorLineNumber))); + } else { +#if 0 // ###FIXME: No support for the backtrace of an uncaught exception + QVERIFY(eng.uncaughtExceptionBacktrace().isEmpty()); +#endif + } +} + +#if 0 // ###FIXME: no support for c-style callbacks +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_QJSEngine::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"))); + } +} +#endif + +#if 0 // ### FIXME: No c-style callbacks +void tst_QJSEngine::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()); + } + } +} +#endif + +void tst_QJSEngine::errorMessage_QT679() +{ + QJSEngine engine; + engine.globalObject().setProperty("foo", 15); + QJSValue error = engine.evaluate("'hello world';\nfoo.bar.blah"); + QVERIFY(error.isError()); + QVERIFY(error.toString().startsWith(QString::fromLatin1("TypeError: "))); +} + +struct Foo { +public: + int x, y; + Foo() : x(-1), y(-1) { } +}; + +Q_DECLARE_METATYPE(Foo) +Q_DECLARE_METATYPE(Foo*) + +#if 0 // FIXME: No prototype API in QScriptEngine +void tst_QJSEngine::getSetDefaultPrototype_int() +{ + QScriptEngine eng; + + QScriptValue object = eng.newObject(); + QCOMPARE(eng.defaultPrototype(qMetaTypeId<int>()).isValid(), false); + eng.setDefaultPrototype(qMetaTypeId<int>(), object); + QCOMPARE(eng.defaultPrototype(qMetaTypeId<int>()).strictlyEquals(object), true); + QScriptValue value = eng.newVariant(int(123)); + QCOMPARE(value.prototype().isObject(), true); + QCOMPARE(value.prototype().strictlyEquals(object), true); + + eng.setDefaultPrototype(qMetaTypeId<int>(), QScriptValue()); + QCOMPARE(eng.defaultPrototype(qMetaTypeId<int>()).isValid(), false); + QScriptValue value2 = eng.newVariant(int(123)); + QCOMPARE(value2.prototype().strictlyEquals(object), false); +} + +void tst_QJSEngine::getSetDefaultPrototype_customType() +{ + QScriptEngine eng; + + QScriptValue object = eng.newObject(); + QCOMPARE(eng.defaultPrototype(qMetaTypeId<Foo>()).isValid(), false); + eng.setDefaultPrototype(qMetaTypeId<Foo>(), object); + QCOMPARE(eng.defaultPrototype(qMetaTypeId<Foo>()).strictlyEquals(object), true); + QScriptValue value = eng.newVariant(qVariantFromValue(Foo())); + QCOMPARE(value.prototype().isObject(), true); + QCOMPARE(value.prototype().strictlyEquals(object), true); + + eng.setDefaultPrototype(qMetaTypeId<Foo>(), QScriptValue()); + QCOMPARE(eng.defaultPrototype(qMetaTypeId<Foo>()).isValid(), false); + QScriptValue value2 = eng.newVariant(qVariantFromValue(Foo())); + QCOMPARE(value2.prototype().strictlyEquals(object), false); +} +#endif + +static QJSValue fooToScriptValue(QJSEngine *eng, const Foo &foo) +{ + QJSValue obj = eng->newObject(); + obj.setProperty("x", QJSValue(eng, foo.x)); + obj.setProperty("y", QJSValue(eng, foo.y)); + return obj; +} + +static void fooFromScriptValue(const QJSValue &value, Foo &foo) +{ + foo.x = value.property("x").toInt32(); + foo.y = value.property("y").toInt32(); +} + +static QJSValue fooToScriptValueV2(QJSEngine *eng, const Foo &foo) +{ + return QJSValue(eng, foo.x); +} + +static void fooFromScriptValueV2(const QJSValue &value, Foo &foo) +{ + foo.x = value.toInt32(); +} + +Q_DECLARE_METATYPE(QLinkedList<QString>) +Q_DECLARE_METATYPE(QList<Foo>) +Q_DECLARE_METATYPE(QVector<QChar>) +Q_DECLARE_METATYPE(QStack<int>) +Q_DECLARE_METATYPE(QQueue<char>) +Q_DECLARE_METATYPE(QLinkedList<QStack<int> >) + +void tst_QJSEngine::valueConversion_basic() +{ + QJSEngine eng; + { + QJSValue num = eng.toScriptValue(123); + QCOMPARE(num.isNumber(), true); + QCOMPARE(num.strictlyEquals(QJSValue(&eng, 123)), true); + + int inum = eng.fromScriptValue<int>(num); + QCOMPARE(inum, 123); + + QString snum = eng.fromScriptValue<QString>(num); + QCOMPARE(snum, QLatin1String("123")); + } + { + QJSValue num = eng.toScriptValue(123); + QCOMPARE(num.isNumber(), true); + QCOMPARE(num.strictlyEquals(QJSValue(&eng, 123)), true); + + int inum = eng.fromScriptValue<int>(num); + QCOMPARE(inum, 123); + + QString snum = eng.fromScriptValue<QString>(num); + QCOMPARE(snum, QLatin1String("123")); + } + { + QJSValue num(&eng, 123); + QCOMPARE(eng.fromScriptValue<char>(num), char(123)); + QCOMPARE(eng.fromScriptValue<unsigned char>(num), (unsigned char)(123)); + QCOMPARE(eng.fromScriptValue<short>(num), short(123)); + QCOMPARE(eng.fromScriptValue<unsigned short>(num), (unsigned short)(123)); + QCOMPARE(eng.fromScriptValue<float>(num), float(123)); + QCOMPARE(eng.fromScriptValue<double>(num), double(123)); + QCOMPARE(eng.fromScriptValue<qlonglong>(num), qlonglong(123)); + QCOMPARE(eng.fromScriptValue<qulonglong>(num), qulonglong(123)); + } + { + QJSValue num(123); + QCOMPARE(eng.fromScriptValue<char>(num), char(123)); + QCOMPARE(eng.fromScriptValue<unsigned char>(num), (unsigned char)(123)); + QCOMPARE(eng.fromScriptValue<short>(num), short(123)); + QCOMPARE(eng.fromScriptValue<unsigned short>(num), (unsigned short)(123)); + QCOMPARE(eng.fromScriptValue<float>(num), float(123)); + QCOMPARE(eng.fromScriptValue<double>(num), double(123)); + QCOMPARE(eng.fromScriptValue<qlonglong>(num), qlonglong(123)); + QCOMPARE(eng.fromScriptValue<qulonglong>(num), qulonglong(123)); + } + + { + QJSValue num = eng.toScriptValue(Q_INT64_C(0x100000000)); + QCOMPARE(eng.fromScriptValue<qlonglong>(num), Q_INT64_C(0x100000000)); + QCOMPARE(eng.fromScriptValue<qulonglong>(num), Q_UINT64_C(0x100000000)); + } + + { + QChar c = QLatin1Char('c'); + QJSValue str = QJSValue(&eng, QLatin1String("ciao")); + QCOMPARE(eng.fromScriptValue<QChar>(str), c); + QJSValue code = QJSValue(&eng, c.unicode()); + QCOMPARE(eng.fromScriptValue<QChar>(code), c); + QCOMPARE(eng.fromScriptValue<QChar>(eng.toScriptValue(c)), c); + } +} + +#if 0 // FIXME: No API for custom types +void tst_QJSEngine::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 = eng.toScriptValue(tm); + QCOMPARE(eng.fromScriptValue<QTime>(val), tm); + } + + { + Foo foo; + foo.x = 12; + foo.y = 34; + QScriptValue fooVal = eng.toScriptValue(foo); + QCOMPARE(fooVal.isVariant(), true); + + Foo foo2 = eng.fromScriptValue<Foo>(fooVal); + QCOMPARE(foo2.x, foo.x); + QCOMPARE(foo2.y, foo.y); + } + + qScriptRegisterMetaType<Foo>(&eng, fooToScriptValue, fooFromScriptValue); + + { + Foo foo; + foo.x = 12; + foo.y = 34; + QScriptValue fooVal = eng.toScriptValue(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 = eng.fromScriptValue<Foo>(fooVal); + QCOMPARE(foo2.x, 56); + QCOMPARE(foo2.y, 78); + + QScriptValue fooProto = eng.newObject(); + eng.setDefaultPrototype(qMetaTypeId<Foo>(), fooProto); + QScriptValue fooVal2 = eng.toScriptValue(foo2); + QVERIFY(fooVal2.prototype().strictlyEquals(fooProto)); + QVERIFY(fooVal2.property("x").strictlyEquals(QScriptValue(&eng, 56))); + QVERIFY(fooVal2.property("y").strictlyEquals(QScriptValue(&eng, 78))); + } +} + +void tst_QJSEngine::valueConversion_sequence() +{ + QScriptEngine eng; + qScriptRegisterSequenceMetaType<QLinkedList<QString> >(&eng); + + { + QLinkedList<QString> lst; + lst << QLatin1String("foo") << QLatin1String("bar"); + QScriptValue lstVal = eng.toScriptValue(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<QList<Foo> >(&eng); + qScriptRegisterSequenceMetaType<QStack<int> >(&eng); + qScriptRegisterSequenceMetaType<QVector<QChar> >(&eng); + qScriptRegisterSequenceMetaType<QQueue<char> >(&eng); + qScriptRegisterSequenceMetaType<QLinkedList<QStack<int> > >(&eng); + + { + QLinkedList<QStack<int> > lst; + QStack<int> first; first << 13 << 49; lst << first; + QStack<int> second; second << 99999;lst << second; + QScriptValue lstVal = eng.toScriptValue(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<QStack<int> >(lstVal.property("0")), first); + QCOMPARE(qscriptvalue_cast<QStack<int> >(lstVal.property("1")), second); + QCOMPARE(qscriptvalue_cast<QLinkedList<QStack<int> > >(lstVal), lst); + } + + // pointers + { + Foo foo; + { + QScriptValue v = eng.toScriptValue(&foo); + Foo *pfoo = qscriptvalue_cast<Foo*>(v); + QCOMPARE(pfoo, &foo); + } + { + Foo *pfoo = 0; + QScriptValue v = eng.toScriptValue(pfoo); + QCOMPARE(v.isNull(), true); + QVERIFY(qscriptvalue_cast<Foo*>(v) == 0); + } + } + + // QList<int> and QObjectList should be converted from/to arrays by default + { + QList<int> lst; + lst << 1 << 2 << 3; + QScriptValue val = eng.toScriptValue(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<QList<int> >(val), lst); + } + { + QObjectList lst; + lst << this; + QScriptValue val = eng.toScriptValue(lst); + QVERIFY(val.isArray()); + QCOMPARE(val.property("length").toInt32(), lst.size()); + QCOMPARE(val.property(0).toQObject(), (QObject *)this); + + QCOMPARE(qscriptvalue_cast<QObjectList>(val), lst); + } +} +#endif + +void tst_QJSEngine::valueConversion_QVariant() +{ + QJSEngine eng; + // qScriptValueFromValue() should be "smart" when the argument is a QVariant + { + QJSValue val = eng.toScriptValue(QVariant()); + QVERIFY(!val.isVariant()); + QVERIFY(val.isUndefined()); + } + // Checking nested QVariants + { + QVariant tmp1; + QVariant tmp2(QMetaType::QVariant, &tmp1); + QVERIFY(QMetaType::Type(tmp2.type()) == QMetaType::QVariant); + + QJSValue val1 = eng.toScriptValue(tmp1); + QJSValue val2 = eng.toScriptValue(tmp2); + QVERIFY(val1.isValid()); + QVERIFY(val2.isValid()); + QVERIFY(val1.isUndefined()); + QEXPECT_FAIL("", "Variant are unrwapped, maybe we should not...", Continue); + QVERIFY(!val2.isUndefined()); + QVERIFY(!val1.isVariant()); + QEXPECT_FAIL("", "Variant are unrwapped, maybe we should not...", Continue); + 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); + + QJSValue val1 = eng.toScriptValue(tmp2); + QJSValue val2 = eng.toScriptValue(tmp3); + QVERIFY(val1.isValid()); + QVERIFY(val2.isValid()); + QEXPECT_FAIL("", "Variant are unrwapped, maybe we should not...", Continue); + QVERIFY(val1.isVariant()); + QEXPECT_FAIL("", "Variant are unrwapped, maybe we should not...", Continue); + QVERIFY(val2.isVariant()); + QVERIFY(val1.toVariant().toInt() == 123); + QVERIFY(eng.toScriptValue(val2.toVariant()).toVariant().toInt() == 123); + } + { + QJSValue val = eng.toScriptValue(QVariant(true)); + QVERIFY(!val.isVariant()); + QVERIFY(val.isBoolean()); + QCOMPARE(val.toBoolean(), true); + } + { + QJSValue val = eng.toScriptValue(QVariant(int(123))); + QVERIFY(!val.isVariant()); + QVERIFY(val.isNumber()); + QCOMPARE(val.toNumber(), qreal(123)); + } + { + QJSValue val = eng.toScriptValue(QVariant(qreal(1.25))); + QVERIFY(!val.isVariant()); + QVERIFY(val.isNumber()); + QCOMPARE(val.toNumber(), qreal(1.25)); + } + { + QString str = QString::fromLatin1("ciao"); + QJSValue val = eng.toScriptValue(QVariant(str)); + QVERIFY(!val.isVariant()); + QVERIFY(val.isString()); + QCOMPARE(val.toString(), str); + } + { + QJSValue val = eng.toScriptValue(qVariantFromValue((QObject*)this)); + QVERIFY(!val.isVariant()); + QVERIFY(val.isQObject()); + QCOMPARE(val.toQObject(), (QObject*)this); + } + { + QVariant var = qVariantFromValue(QPoint(123, 456)); + QJSValue val = eng.toScriptValue(var); + QVERIFY(val.isVariant()); + QCOMPARE(val.toVariant(), var); + } + + QCOMPARE(qjsvalue_cast<QVariant>(QJSValue(123)), QVariant(123)); +} + +#if 0 // FIXME: No support for custom types +void tst_QJSEngine::valueConversion_hooliganTask248802() +{ + QScriptEngine eng; + qScriptRegisterMetaType<Foo>(&eng, fooToScriptValueV2, fooFromScriptValueV2); + { + QScriptValue num(&eng, 123); + Foo foo = eng.fromScriptValue<Foo>(num); + QCOMPARE(foo.x, 123); + } + { + QScriptValue num(123); + Foo foo = eng.fromScriptValue<Foo>(num); + QCOMPARE(foo.x, -1); + } + { + QScriptValue str(&eng, QLatin1String("123")); + Foo foo = eng.fromScriptValue<Foo>(str); + QCOMPARE(foo.x, 123); + } + +} +#endif + +void tst_QJSEngine::valueConversion_basic2() +{ + QJSEngine eng; + // more built-in types + { + QJSValue val = eng.toScriptValue(uint(123)); + QVERIFY(val.isNumber()); + QCOMPARE(val.toInt32(), 123); + } + { + QJSValue val = eng.toScriptValue(qulonglong(123)); + QVERIFY(val.isNumber()); + QCOMPARE(val.toInt32(), 123); + } + { + QJSValue val = eng.toScriptValue(float(123)); + QVERIFY(val.isNumber()); + QCOMPARE(val.toInt32(), 123); + } + { + QJSValue val = eng.toScriptValue(short(123)); + QVERIFY(val.isNumber()); + QCOMPARE(val.toInt32(), 123); + } + { + QJSValue val = eng.toScriptValue(ushort(123)); + QVERIFY(val.isNumber()); + QCOMPARE(val.toInt32(), 123); + } + { + QJSValue val = eng.toScriptValue(char(123)); + QVERIFY(val.isNumber()); + QCOMPARE(val.toInt32(), 123); + } + { + QJSValue val = eng.toScriptValue(uchar(123)); + QVERIFY(val.isNumber()); + QCOMPARE(val.toInt32(), 123); + } +} + +void tst_QJSEngine::valueConversion_dateTime() +{ + QJSEngine eng; + { + QDateTime in = QDateTime::currentDateTime(); + QJSValue val = eng.toScriptValue(in); + QVERIFY(val.isDate()); + QCOMPARE(val.toDateTime(), in); + } + { + QDate in = QDate::currentDate(); + QJSValue val = eng.toScriptValue(in); + QVERIFY(val.isDate()); + QCOMPARE(val.toDateTime().date(), in); + } +} + +void tst_QJSEngine::valueConversion_regExp() +{ + QJSEngine eng; + { + QRegExp in = QRegExp("foo"); + QJSValue val = eng.toScriptValue(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); + QJSValue val = eng.toScriptValue(in); + QVERIFY(val.isRegExp()); + QCOMPARE(val.toRegExp(), in); + } + { + QRegExp in = QRegExp("foo"); + in.setMinimal(true); + QJSValue val = eng.toScriptValue(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()); + } +} + +#if 0 // FIXME: No qScriptValueFromValue +void tst_QJSEngine::qScriptValueFromValue_noEngine() +{ + QVERIFY(!qScriptValueFromValue(0, 123).isValid()); + QVERIFY(!qScriptValueFromValue(0, QVariant(123)).isValid()); +} +#endif + +#if 0 // ###FIXME: No QScriptContext +static QScriptValue __import__(QScriptContext *ctx, QScriptEngine *eng) +{ + return eng->importExtension(ctx->argument(0).toString()); +} + +void tst_QJSEngine::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_QJSEngine::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); + QVERIFY(ret.toString().startsWith(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 +} +#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) + +#if 0 // FIXME: No support for default prototypes +class Zoo : public QObject +{ + Q_OBJECT +public: + Zoo() { } +public slots: + Baz *toBaz(Bar *b) { return reinterpret_cast<Baz*>(b); } +}; + +void tst_QJSEngine::castWithPrototypeChain() +{ + QScriptEngine eng; + Bar bar; + Baz baz; + QScriptValue barProto = eng.toScriptValue(&bar); + QScriptValue bazProto = eng.toScriptValue(&baz); + eng.setDefaultPrototype(qMetaTypeId<Bar*>(), barProto); + eng.setDefaultPrototype(qMetaTypeId<Baz*>(), bazProto); + + Baz baz2; + baz2.a = 123; + baz2.b = 456; + QScriptValue baz2Value = eng.toScriptValue(&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<Baz*>(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<Bar*>(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<Bar*>(baz2Value); + QVERIFY(pbar != 0); + QCOMPARE(pbar->a, baz2.a); + } + + { + QScriptValue ret = toBaz.call(scriptZoo, QScriptValueList() << baz2Value); + QEXPECT_FAIL("", "Cannot convert Baz* to Bar*", Continue); + QVERIFY(!ret.isError()); + QEXPECT_FAIL("", "Cannot convert Baz* to Bar*", Continue); + QCOMPARE(qscriptvalue_cast<Baz*>(ret), pbaz); + } + } + + bazProto.setPrototype(barProto.prototype()); // kill chain + { + Baz *pbaz = qscriptvalue_cast<Baz*>(baz2Value); + QVERIFY(pbaz != 0); + // should not work anymore + Bar *pbar = qscriptvalue_cast<Bar*>(baz2Value); + QVERIFY(pbar == 0); + } + + bazProto.setPrototype(eng.newQObject(this)); + { + Baz *pbaz = qscriptvalue_cast<Baz*>(baz2Value); + QVERIFY(pbaz != 0); + // should not work now either + Bar *pbar = qscriptvalue_cast<Bar*>(baz2Value); + QVERIFY(pbar == 0); + } + + { + QScriptValue b = eng.toScriptValue(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<Bar*>(b); + QVERIFY(pbar != 0); + } + + { + QScriptValue gradientProto = eng.toScriptValue(QGradient()); + QScriptValue linearGradientProto = eng.toScriptValue(QLinearGradient()); + linearGradientProto.setPrototype(gradientProto); + QLinearGradient lg(10, 20, 30, 40); + QScriptValue linearGradient = eng.toScriptValue(lg); + { + QGradient *pgrad = qscriptvalue_cast<QGradient*>(linearGradient); + QVERIFY(pgrad == 0); + } + linearGradient.setPrototype(linearGradientProto); + { + QGradient *pgrad = qscriptvalue_cast<QGradient*>(linearGradient); + QVERIFY(pgrad != 0); + QCOMPARE(pgrad->type(), QGradient::LinearGradient); + QLinearGradient *plingrad = static_cast<QLinearGradient*>(pgrad); + QCOMPARE(plingrad->start(), lg.start()); + QCOMPARE(plingrad->finalStop(), lg.finalStop()); + } + } +} +#endif + +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_QJSEngine::castWithMultipleInheritance() +{ + QJSEngine eng; + Klazz klz; + QJSValue v = eng.newQObject(&klz); + + QCOMPARE(qjsvalue_cast<Klazz*>(v), &klz); + QCOMPARE(qjsvalue_cast<QWidget*>(v), (QWidget *)&klz); + QCOMPARE(qjsvalue_cast<QObject*>(v), (QObject *)&klz); + QCOMPARE(qjsvalue_cast<QStandardItem*>(v), (QStandardItem *)&klz); + QCOMPARE(qjsvalue_cast<QGraphicsItem*>(v), (QGraphicsItem *)&klz); +} + +#if 0 // ###FIXME: ScriptOwnership +void tst_QJSEngine::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<QObject> ptr = new QObject(); + QVERIFY(ptr != 0); + (void)eng.newQObject(ptr, QScriptEngine::ScriptOwnership); + collectGarbage_helper(eng); + QVERIFY(ptr == 0); +} +#endif + +#if 0 // ###FIXME: no reportAdditionalMemoryCost API +void tst_QJSEngine::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 < 100; ++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(); + } +} +#endif + +void tst_QJSEngine::gcWithNestedDataStructure() +{ + // The GC must be able to traverse deeply nested objects, otherwise this + // test would crash. + QJSEngine 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; + QJSValue 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()"); + QJSValue 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"); + } + } +} + +#if 0 // ###FIXME: No processEvents handling +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_QJSEngine::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(); + } +} + +void tst_QJSEngine::processEventsWhileRunning_function() +{ + QScriptEngine eng; + QScriptValue script = eng.evaluate(QString::fromLatin1( + "(function() { var end = Number(new Date()) + 2000;" + "var x = 0;" + "while (Number(new Date()) < end) {" + " ++x;" + "} })")); + + eng.setProcessEventsInterval(100); + + for (int x = 0; x < 2; ++x) { + EventReceiver receiver; + QCoreApplication::postEvent(&receiver, new QEvent(QEvent::Type(QEvent::User+1))); + QVERIFY(!eng.hasUncaughtException()); + QVERIFY(!receiver.received); + QCOMPARE(eng.processEventsInterval(), 100); + + if (x) script.call(); + else script.construct(); + + QVERIFY(!eng.hasUncaughtException()); + QVERIFY(receiver.received); + } +} + + +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_QJSEngine::throwErrorFromProcessEvents_data() +{ + QTest::addColumn<QString>("script"); + QTest::addColumn<QString>("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_QJSEngine::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_QJSEngine::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); +} +#endif + +#if 0 // ###FIXME: No QScriptValueIterator API +void tst_QJSEngine::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" + << "<global>()@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); + // ###FIXME: no uncahgutExceptionBacktrace: 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<QStringList>(bt), backtrace); + } + + // throw something that isn't an Error object + eng.clearExceptions(); + // ###FIXME: No uncaughtExceptionBacktrace: 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()); + + // ###FIXME: No uncaughtExceptionBacktrace: QCOMPARE(eng.uncaughtExceptionBacktrace(), backtrace); + QVERIFY(eng.hasUncaughtException()); + + eng.clearExceptions(); + QVERIFY(!eng.hasUncaughtException()); + // ###FIXME: No uncaughtExceptionBacktrace: QVERIFY(eng.uncaughtExceptionBacktrace().isEmpty()); +} +#endif + +void tst_QJSEngine::numberParsing_data() +{ + QTest::addColumn<QString>("string"); + QTest::addColumn<qreal>("expect"); + + QTest::newRow("decimal 0") << QString("0") << qreal(0); + QTest::newRow("octal 0") << QString("00") << qreal(00); + QTest::newRow("hex 0") << QString("0x0") << qreal(0x0); + QTest::newRow("decimal 100") << QString("100") << qreal(100); + QTest::newRow("hex 100") << QString("0x100") << qreal(0x100); + QTest::newRow("octal 100") << QString("0100") << qreal(0100); + QTest::newRow("decimal 4G") << QString("4294967296") << qreal(Q_UINT64_C(4294967296)); + QTest::newRow("hex 4G") << QString("0x100000000") << qreal(Q_UINT64_C(0x100000000)); + QTest::newRow("octal 4G") << QString("040000000000") << qreal(Q_UINT64_C(040000000000)); + QTest::newRow("0.5") << QString("0.5") << qreal(0.5); + QTest::newRow("1.5") << QString("1.5") << qreal(1.5); + QTest::newRow("1e2") << QString("1e2") << qreal(100); +} + +void tst_QJSEngine::numberParsing() +{ + QFETCH(QString, string); + QFETCH(qreal, expect); + + QJSEngine eng; + QJSValue ret = eng.evaluate(string); + QVERIFY(ret.isNumber()); + qreal 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_QJSEngine::automaticSemicolonInsertion() +{ + QJSEngine eng; + { + QJSValue ret = eng.evaluate("{ 1 2 } 3"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().contains("SyntaxError")); + } + { + QJSValue ret = eng.evaluate("{ 1\n2 } 3"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 3); + } + { + QJSValue ret = eng.evaluate("for (a; b\n)"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().contains("SyntaxError")); + } + { + QJSValue ret = eng.evaluate("(function() { return\n1 + 2 })()"); + QVERIFY(ret.isUndefined()); + } + { + eng.evaluate("c = 2; b = 1"); + QJSValue ret = eng.evaluate("a = b\n++c"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 3); + } + { + QJSValue 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"); + QJSValue ret = eng.evaluate("a = b + c\n(d + e).foo()"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 6); + } + { + QJSValue ret = eng.evaluate("throw\n1"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().contains("SyntaxError")); + } + { + QJSValue 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"); + QJSValue ret = eng.evaluate("if (0)\n ++a; a"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 123); + } + { + eng.evaluate("a = 123"); + QJSValue ret = eng.evaluate("if (0)\n --a; a"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 123); + } + { + eng.evaluate("a = 123"); + QJSValue ret = eng.evaluate("if ((0))\n ++a; a"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 123); + } + { + eng.evaluate("a = 123"); + QJSValue ret = eng.evaluate("if ((0))\n --a; a"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 123); + } + { + eng.evaluate("a = 123"); + QJSValue ret = eng.evaluate("if (0\n)\n ++a; a"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 123); + } + { + eng.evaluate("a = 123"); + QJSValue ret = eng.evaluate("if (0\n ++a; a"); + QVERIFY(ret.isError()); + } + { + eng.evaluate("a = 123"); + QJSValue ret = eng.evaluate("if (0))\n ++a; a"); + QVERIFY(ret.isError()); + } + { + QJSValue ret = eng.evaluate("n = 0; for (i = 0; i < 10; ++i)\n ++n; n"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 10); + } + { + QJSValue ret = eng.evaluate("n = 30; for (i = 0; i < 10; ++i)\n --n; n"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 20); + } + { + QJSValue ret = eng.evaluate("n = 0; for (var i = 0; i < 10; ++i)\n ++n; n"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 10); + } + { + QJSValue ret = eng.evaluate("n = 30; for (var i = 0; i < 10; ++i)\n --n; n"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 20); + } + { + QJSValue ret = eng.evaluate("n = 0; i = 0; while (i++ < 10)\n ++n; n"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 10); + } + { + QJSValue ret = eng.evaluate("n = 30; i = 0; while (i++ < 10)\n --n; n"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 20); + } + { + QJSValue 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); + } + { + QJSValue 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); + } + { + QJSValue 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); + } + { + QJSValue 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); + } + { + QJSValue ret = eng.evaluate("o = { n: 3 }; n = 5; with (o)\n ++n; n"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 5); + } + { + QJSValue ret = eng.evaluate("o = { n: 3 }; n = 10; with (o)\n --n; n"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 10); + } + { + QJSValue ret = eng.evaluate("n = 5; i = 0; do\n ++n; while (++i < 10); n"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 15); + } + { + QJSValue ret = eng.evaluate("n = 20; i = 0; do\n --n; while (++i < 10); n"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 10); + } + + { + QJSValue ret = eng.evaluate("n = 1; i = 0; if (n) i\n++n; n"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 2); + } + { + QJSValue ret = eng.evaluate("n = 1; i = 0; if (n) i\n--n; n"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 0); + } + + { + QJSValue ret = eng.evaluate("if (0)"); + QVERIFY(ret.isError()); + } + { + QJSValue ret = eng.evaluate("while (0)"); + QVERIFY(ret.isError()); + } + { + QJSValue ret = eng.evaluate("for (;;)"); + QVERIFY(ret.isError()); + } + { + QJSValue ret = eng.evaluate("for (p in this)"); + QVERIFY(ret.isError()); + } + { + QJSValue ret = eng.evaluate("with (this)"); + QVERIFY(ret.isError()); + } + { + QJSValue ret = eng.evaluate("do"); + QVERIFY(ret.isError()); + } +} + +#if 0 // ###FIXME: no abortEvaluation API +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_QJSEngine::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_QJSEngine::abortEvaluation_data() +{ + QTest::addColumn<QString>("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_QJSEngine::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_QJSEngine::abortEvaluation_tryCatch() +{ + QSKIP("It crashes", SkipAll); + 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_QJSEngine::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_QJSEngine::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"); + } + +} +#endif + +#if 0 // ###FIXME: no QScriptEngine::isEvaluating +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_QJSEngine::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_QJSEngine::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()); + ret = fun.call(); + QVERIFY(ret.isBoolean()); + QVERIFY(ret.toBoolean()); + ret = myFunctionReturningIsEvaluating(eng.currentContext(), &eng); + QVERIFY(ret.isBoolean()); + QVERIFY(!ret.toBoolean()); +} + +void tst_QJSEngine::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); +} +#endif + +static QtMsgType theMessageType; +static QString theMessage; + +static void myMsgHandler(QtMsgType type, const char *msg) +{ + theMessageType = type; + theMessage = QString::fromLatin1(msg); +} + +#if 0 +void tst_QJSEngine::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. + QJSEngine 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_QJSEngine::printThrowsException() +{ + // If an argument to print() causes an exception to be thrown when + // it's converted to a string, print() should propagate the exception. + QJSEngine eng; + QJSValue ret = eng.evaluate("print({ toString: function() { throw 'foo'; } });"); + QVERIFY(eng.hasUncaughtException()); + QVERIFY(ret.strictlyEquals(QJSValue(&eng, QLatin1String("foo")))); +} +#endif + +void tst_QJSEngine::errorConstructors() +{ + QJSEngine 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("()"); + QJSValue ret = eng.evaluate(code); + QVERIFY(ret.isError()); + QCOMPARE(eng.hasUncaughtException(), x == 0); + eng.clearExceptions(); + QVERIFY(ret.toString().startsWith(name)); + //QTBUG-6138: JSC doesn't assign lineNumber when errors are not thrown + QEXPECT_FAIL("", "we have no more lineNumber property ", Continue); + QCOMPARE(ret.property("lineNumber").toInt32(), i+2); + } + } +} + +void tst_QJSEngine::argumentsProperty_globalContext() +{ + QJSEngine eng; + { + // Unlike function calls, the global context doesn't have an + // arguments property. + QJSValue ret = eng.evaluate("arguments"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().contains(QString::fromLatin1("ReferenceError"))); + } + eng.evaluate("arguments = 10"); + { + QJSValue 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_QJSEngine::argumentsProperty_JS() +{ + { + QJSEngine eng; + eng.evaluate("o = { arguments: 123 }"); + QJSValue ret = eng.evaluate("with (o) { arguments; }"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 123); + } + { + QJSEngine 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. + QJSValue ret = eng.evaluate("(function() { arguments = 456; return arguments; })()"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 456); + QVERIFY(!eng.globalObject().property("arguments").isValid()); + } +} + +#if 0 // ###FIXME: no QScriptContext API +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_QJSEngine::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); +} +#endif + +void tst_QJSEngine::jsNumberClass() +{ + // See ECMA-262 Section 15.7, "Number Objects". + + QJSEngine eng; + + QJSValue ctor = eng.globalObject().property("Number"); + QVERIFY(ctor.property("length").isNumber()); + QCOMPARE(ctor.property("length").toNumber(), qreal(1)); + QJSValue proto = ctor.property("prototype"); + QVERIFY(proto.isObject()); + { + QJSValue::PropertyFlags flags = QJSValue::SkipInEnumeration + | QJSValue::Undeletable + | QJSValue::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(), qreal(0)); + QVERIFY(proto.property("constructor").strictlyEquals(ctor)); + + { + QJSValue ret = eng.evaluate("Number()"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toNumber(), qreal(0)); + } + { + QJSValue ret = eng.evaluate("Number(123)"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toNumber(), qreal(123)); + } + { + QJSValue ret = eng.evaluate("Number('456')"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toNumber(), qreal(456)); + } + { + QJSValue ret = eng.evaluate("new Number()"); + QVERIFY(!ret.isNumber()); + QVERIFY(ret.isObject()); + QCOMPARE(ret.toNumber(), qreal(0)); + } + { + QJSValue ret = eng.evaluate("new Number(123)"); + QVERIFY(!ret.isNumber()); + QVERIFY(ret.isObject()); + QCOMPARE(ret.toNumber(), qreal(123)); + } + { + QJSValue ret = eng.evaluate("new Number('456')"); + QVERIFY(!ret.isNumber()); + QVERIFY(ret.isObject()); + QCOMPARE(ret.toNumber(), qreal(456)); + } + + QVERIFY(proto.property("toString").isFunction()); + { + QJSValue ret = eng.evaluate("new Number(123).toString()"); + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), QString::fromLatin1("123")); + } + { + QJSValue ret = eng.evaluate("new Number(123).toString(8)"); + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), QString::fromLatin1("173")); + } + { + QJSValue ret = eng.evaluate("new Number(123).toString(16)"); + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), QString::fromLatin1("7b")); + } + QVERIFY(proto.property("toLocaleString").isFunction()); + { + QJSValue ret = eng.evaluate("new Number(123).toLocaleString()"); + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), QString::fromLatin1("123")); + } + QVERIFY(proto.property("valueOf").isFunction()); + { + QJSValue ret = eng.evaluate("new Number(123).valueOf()"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toNumber(), qreal(123)); + } + QVERIFY(proto.property("toExponential").isFunction()); + { + QJSValue ret = eng.evaluate("new Number(123).toExponential()"); + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), QString::fromLatin1("1.23e+2")); + } + QVERIFY(proto.property("toFixed").isFunction()); + { + QJSValue ret = eng.evaluate("new Number(123).toFixed()"); + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), QString::fromLatin1("123")); + } + QVERIFY(proto.property("toPrecision").isFunction()); + { + QJSValue ret = eng.evaluate("new Number(123).toPrecision()"); + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), QString::fromLatin1("123")); + } +} + +void tst_QJSEngine::jsForInStatement_simple() +{ + QJSEngine eng; + { + QJSValue ret = eng.evaluate("o = { }; r = []; for (var p in o) r[r.length] = p; r"); + QStringList lst = qjsvalue_cast<QStringList>(ret); + QVERIFY(lst.isEmpty()); + } + { + QJSValue ret = eng.evaluate("o = { p: 123 }; r = [];" + "for (var p in o) r[r.length] = p; r"); + QStringList lst = qjsvalue_cast<QStringList>(ret); + QCOMPARE(lst.size(), 1); + QCOMPARE(lst.at(0), QString::fromLatin1("p")); + } + { + QJSValue ret = eng.evaluate("o = { p: 123, q: 456 }; r = [];" + "for (var p in o) r[r.length] = p; r"); + QStringList lst = qjsvalue_cast<QStringList>(ret); + QCOMPARE(lst.size(), 2); + QCOMPARE(lst.at(0), QString::fromLatin1("p")); + QCOMPARE(lst.at(1), QString::fromLatin1("q")); + } +} + +void tst_QJSEngine::jsForInStatement_prototypeProperties() +{ + QJSEngine eng; + { + QJSValue ret = eng.evaluate("o = { }; o.__proto__ = { p: 123 }; r = [];" + "for (var p in o) r[r.length] = p; r"); + QStringList lst = qjsvalue_cast<QStringList>(ret); + QCOMPARE(lst.size(), 1); + QCOMPARE(lst.at(0), QString::fromLatin1("p")); + } + { + QJSValue ret = eng.evaluate("o = { p: 123 }; o.__proto__ = { q: 456 }; r = [];" + "for (var p in o) r[r.length] = p; r"); + QStringList lst = qjsvalue_cast<QStringList>(ret); + QCOMPARE(lst.size(), 2); + QCOMPARE(lst.at(0), QString::fromLatin1("p")); + QCOMPARE(lst.at(1), QString::fromLatin1("q")); + } + { + // shadowed property + QJSValue ret = eng.evaluate("o = { p: 123 }; o.__proto__ = { p: 456 }; r = [];" + "for (var p in o) r[r.length] = p; r"); + QStringList lst = qjsvalue_cast<QStringList>(ret); + QCOMPARE(lst.size(), 1); + QCOMPARE(lst.at(0), QString::fromLatin1("p")); + } + +} + +void tst_QJSEngine::jsForInStatement_mutateWhileIterating() +{ + QJSEngine eng; + // deleting property during enumeration + { + QJSValue ret = eng.evaluate("o = { p: 123 }; r = [];" + "for (var p in o) { r[r.length] = p; delete r[p]; } r"); + QStringList lst = qjsvalue_cast<QStringList>(ret); + QCOMPARE(lst.size(), 1); + QCOMPARE(lst.at(0), QString::fromLatin1("p")); + } + { + QJSValue ret = eng.evaluate("o = { p: 123, q: 456 }; r = [];" + "for (var p in o) { r[r.length] = p; delete o.q; } r"); + QStringList lst = qjsvalue_cast<QStringList>(ret); + QCOMPARE(lst.size(), 1); + QCOMPARE(lst.at(0), QString::fromLatin1("p")); + } + + // adding property during enumeration + { + QJSValue ret = eng.evaluate("o = { p: 123 }; r = [];" + "for (var p in o) { r[r.length] = p; o.q = 456; } r"); + QStringList lst = qjsvalue_cast<QStringList>(ret); + QCOMPARE(lst.size(), 1); + QCOMPARE(lst.at(0), QString::fromLatin1("p")); + } + +} + +void tst_QJSEngine::jsForInStatement_arrays() +{ + QJSEngine eng; + { + QJSValue ret = eng.evaluate("a = [123, 456]; r = [];" + "for (var p in a) r[r.length] = p; r"); + QStringList lst = qjsvalue_cast<QStringList>(ret); + QCOMPARE(lst.size(), 2); + QCOMPARE(lst.at(0), QString::fromLatin1("0")); + QCOMPARE(lst.at(1), QString::fromLatin1("1")); + } + { + QJSValue ret = eng.evaluate("a = [123, 456]; a.foo = 'bar'; r = [];" + "for (var p in a) r[r.length] = p; r"); + QStringList lst = qjsvalue_cast<QStringList>(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")); + } + { + QJSValue 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 = qjsvalue_cast<QStringList>(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_QJSEngine::jsForInStatement_nullAndUndefined() +{ + QJSEngine eng; + { + QJSValue ret = eng.evaluate("r = true; for (var p in undefined) r = false; r"); + QVERIFY(ret.isBool()); + QVERIFY(ret.toBool()); + } + { + QJSValue ret = eng.evaluate("r = true; for (var p in null) r = false; r"); + QVERIFY(ret.isBool()); + QVERIFY(ret.toBool()); + } +} + +void tst_QJSEngine::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. + + QJSEngine 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()); + { + QJSValue ret = eng.evaluate("foo('bar')"); + QVERIFY(ret.isFunction()); + QJSValue ret2 = ret.call(QJSValue()); + QCOMPARE(ret2.toString(), QString::fromLatin1("bar")); + QVERIFY(!eng.globalObject().property("bar").isValid()); + QVERIFY(!eng.globalObject().property("baz").isValid()); + } + { + QJSValue ret = eng.evaluate("foo('baz')"); + QVERIFY(ret.isFunction()); + QJSValue ret2 = ret.call(QJSValue()); + QCOMPARE(ret2.toString(), QString::fromLatin1("baz")); + QVERIFY(!eng.globalObject().property("bar").isValid()); + QVERIFY(!eng.globalObject().property("baz").isValid()); + } +} + +void tst_QJSEngine::stringObjects() +{ + // See ECMA-262 Section 15.5, "String Objects". + + QJSEngine eng; + QString str("ciao"); + // in C++ + { + QJSValue obj = QJSValue(&eng, str).toObject(); + QCOMPARE(obj.property("length").toInt32(), str.length()); + QCOMPARE(obj.propertyFlags("length"), QJSValue::PropertyFlags(QJSValue::Undeletable | QJSValue::SkipInEnumeration | QJSValue::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))); + QEXPECT_FAIL("", "FIXME: This is V8 issue 862. ECMA script standard 15.5.5.2 compliance.", Continue); + QCOMPARE(obj.propertyFlags(pname), QJSValue::PropertyFlags(QJSValue::Undeletable | QJSValue::ReadOnly)); + obj.setProperty(pname, QJSValue()); + obj.setProperty(pname, QJSValue(&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()); + + QJSValue 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 + { + QJSValue ret = eng.evaluate("s = new String('ciao'); r = []; for (var p in s) r.push(p); r"); + QVERIFY(ret.isArray()); + QStringList lst = qjsvalue_cast<QStringList>(ret); + QCOMPARE(lst.size(), str.length()); + for (int i = 0; i < str.length(); ++i) + QCOMPARE(lst.at(i), QString::number(i)); + + QJSValue ret2 = eng.evaluate("s[0] = 123; s[0]"); + QVERIFY(ret2.isString()); + QCOMPARE(ret2.toString().length(), 1); + QCOMPARE(ret2.toString().at(0), str.at(0)); + + QJSValue ret3 = eng.evaluate("s[-1] = 123; s[-1]"); + QVERIFY(ret3.isNumber()); + QCOMPARE(ret3.toInt32(), 123); + + QJSValue ret4 = eng.evaluate("s[s.length] = 456; s[s.length]"); + QVERIFY(ret4.isNumber()); + QCOMPARE(ret4.toInt32(), 456); + + QJSValue ret5 = eng.evaluate("delete s[0]"); + QVERIFY(ret5.isBoolean()); + QEXPECT_FAIL("", "FIXME: This is V8 bug, please report it! ECMA script standard 15.5.5.2", Abort); + QVERIFY(!ret5.toBoolean()); + + QJSValue ret6 = eng.evaluate("delete s[-1]"); + QVERIFY(ret6.isBoolean()); + QVERIFY(ret6.toBoolean()); + + QJSValue ret7 = eng.evaluate("delete s[s.length]"); + QVERIFY(ret7.isBoolean()); + QVERIFY(ret7.toBoolean()); + } +} + +void tst_QJSEngine::jsStringPrototypeReplaceBugs() +{ + QJSEngine eng; + // task 212440 + { + QJSValue 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) { + QJSValue 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 + { + QJSValue ret = eng.evaluate("\"foo\".replace(/a/g, function() {})"); + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), QString::fromLatin1("foo")); + } +} + +void tst_QJSEngine::getterSetterThisObject_global() +{ + { + QJSEngine eng; + // read + eng.evaluate("__defineGetter__('x', function() { return this; });"); + { + QJSValue ret = eng.evaluate("x"); + QVERIFY(ret.equals(eng.globalObject())); + } + { + QJSValue ret = eng.evaluate("(function() { return x; })()"); + QVERIFY(ret.equals(eng.globalObject())); + } + { + QJSValue ret = eng.evaluate("with (this) x"); + QVERIFY(ret.equals(eng.globalObject())); + } + { + QJSValue ret = eng.evaluate("with ({}) x"); + QVERIFY(ret.equals(eng.globalObject())); + } + { + QJSValue ret = eng.evaluate("(function() { with ({}) return x; })()"); + QVERIFY(ret.equals(eng.globalObject())); + } + // write + eng.evaluate("__defineSetter__('x', function() { return this; });"); + { + QJSValue ret = eng.evaluate("x = 'foo'"); + // SpiderMonkey says setter return value, JSC says RHS. + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), QString::fromLatin1("foo")); + } + { + QJSValue ret = eng.evaluate("(function() { return x = 'foo'; })()"); + // SpiderMonkey says setter return value, JSC says RHS. + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), QString::fromLatin1("foo")); + } + { + QJSValue ret = eng.evaluate("with (this) x = 'foo'"); + // SpiderMonkey says setter return value, JSC says RHS. + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), QString::fromLatin1("foo")); + } + { + QJSValue ret = eng.evaluate("with ({}) x = 'foo'"); + // SpiderMonkey says setter return value, JSC says RHS. + QVERIFY(ret.isString()); + QCOMPARE(ret.toString(), QString::fromLatin1("foo")); + } + { + QJSValue 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_QJSEngine::getterSetterThisObject_plain() +{ + { + QJSEngine 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_QJSEngine::getterSetterThisObject_prototypeChain() +{ + { + QJSEngine 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")); + } +} + +#if 0 // ###FIXME: no QScriptContext API +void tst_QJSEngine::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(); + } +} +#endif + +void tst_QJSEngine::jsContinueInSwitch() +{ + // This is testing ECMA-262 compliance, not C++ API. + + QJSEngine eng; + // switch - continue + { + QJSValue ret = eng.evaluate("switch (1) { default: continue; }"); + QVERIFY(ret.isError()); + } + // for - switch - case - continue + { + QJSValue 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 + { + QJSValue 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 + { + QJSValue 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 + { + QJSValue ret = eng.evaluate("i = 1; switch (i) { default: switch (i) { case 1: continue; } }"); + QVERIFY(ret.isError()); + } + // for - switch - switch - continue + { + QJSValue 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 + { + QJSValue 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_QJSEngine::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. + QJSEngine 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_QJSEngine::toObject() +{ + QJSEngine eng; + + QVERIFY(!eng.toObject(eng.undefinedValue()).isValid()); + + QVERIFY(!eng.toObject(eng.nullValue()).isValid()); + + QJSValue falskt(false); + { + QJSValue tmp = eng.toObject(falskt); + QVERIFY(tmp.isObject()); + QCOMPARE(tmp.toNumber(), falskt.toNumber()); + } + QVERIFY(falskt.isBool()); + + QJSValue sant(true); + { + QJSValue tmp = eng.toObject(sant); + QVERIFY(tmp.isObject()); + QCOMPARE(tmp.toNumber(), sant.toNumber()); + } + QVERIFY(sant.isBool()); + + QJSValue number(123.0); + { + QJSValue tmp = eng.toObject(number); + QVERIFY(tmp.isObject()); + QCOMPARE(tmp.toNumber(), number.toNumber()); + } + QVERIFY(number.isNumber()); + + QJSValue str = QJSValue(&eng, QString("ciao")); + { + QJSValue tmp = eng.toObject(str); + QVERIFY(tmp.isObject()); + QCOMPARE(tmp.toString(), str.toString()); + } + QVERIFY(str.isString()); + + QJSValue object = eng.newObject(); + { + QJSValue tmp = eng.toObject(object); + QVERIFY(tmp.isObject()); + QVERIFY(tmp.strictlyEquals(object)); + } + + QJSValue qobject = eng.newQObject(this); + QVERIFY(eng.toObject(qobject).strictlyEquals(qobject)); + + QVERIFY(!eng.toObject(QJSValue()).isValid()); + + // v1 constructors + + QJSValue boolValue(&eng, true); + { + QJSValue ret = eng.toObject(boolValue); + QVERIFY(ret.isObject()); + QCOMPARE(ret.toBool(), boolValue.toBool()); + } + QVERIFY(boolValue.isBool()); + + QJSValue numberValue(&eng, 123.0); + { + QJSValue ret = eng.toObject(numberValue); + QVERIFY(ret.isObject()); + QCOMPARE(ret.toNumber(), numberValue.toNumber()); + } + QVERIFY(numberValue.isNumber()); + + QJSValue stringValue(&eng, QString::fromLatin1("foo")); + { + QJSValue ret = eng.toObject(stringValue); + QVERIFY(ret.isObject()); + QCOMPARE(ret.toString(), stringValue.toString()); + } + QVERIFY(stringValue.isString()); +} + +void tst_QJSEngine::jsReservedWords_data() +{ + QTest::addColumn<QString>("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_QJSEngine::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); + { + QJSEngine eng; + QJSValue ret = eng.evaluate(word + " = 123"); + QVERIFY(ret.isError()); + QString str = ret.toString(); + QVERIFY(str.startsWith("SyntaxError") || str.startsWith("ReferenceError")); + } + { + QJSEngine eng; + QJSValue ret = eng.evaluate("var " + word + " = 123"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().startsWith("SyntaxError")); + } + { + QJSEngine eng; + QJSValue ret = eng.evaluate("o = {}; o." + word + " = 123"); + // in the old back-end, in SpiderMonkey and in v8, this is allowed, but not in JSC + QVERIFY(!ret.isError()); + QVERIFY(ret.strictlyEquals(eng.evaluate("o." + word))); + } + { + QJSEngine eng; + QJSValue ret = eng.evaluate("o = { " + word + ": 123 }"); + // in the old back-end, in SpiderMonkey and in v8, this is allowed, but not in JSC + QVERIFY(!ret.isError()); + QVERIFY(ret.property(word).isNumber()); + } + { + // SpiderMonkey allows this, but we don't + QJSEngine eng; + QJSValue ret = eng.evaluate("function " + word + "() {}"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().startsWith("SyntaxError")); + } +} + +void tst_QJSEngine::jsFutureReservedWords_data() +{ + QTest::addColumn<QString>("word"); + QTest::addColumn<bool>("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_QJSEngine::jsFutureReservedWords() +{ + QSKIP("Fails", SkipAll); + // 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); + { + QJSEngine eng; + QJSValue ret = eng.evaluate(word + " = 123"); + QCOMPARE(!ret.isError(), allowed); + } + { + QJSEngine eng; + QJSValue ret = eng.evaluate("var " + word + " = 123"); + QCOMPARE(!ret.isError(), allowed); + } + { + // this should probably be allowed (see task 162567) + QJSEngine eng; + QJSValue ret = eng.evaluate("o = {}; o." + word + " = 123"); + QCOMPARE(ret.isNumber(), allowed); + QCOMPARE(!ret.isError(), allowed); + } + { + // this should probably be allowed (see task 162567) + QJSEngine eng; + QJSValue ret = eng.evaluate("o = { " + word + ": 123 }"); + QCOMPARE(!ret.isError(), allowed); + } +} + +void tst_QJSEngine::jsThrowInsideWithStatement() +{ + // This is testing ECMA-262 compliance, not C++ API. + + // task 209988 + QJSEngine eng; + { + QJSValue ret = eng.evaluate( + "try {" + " o = { bad : \"bug\" };" + " with (o) {" + " throw 123;" + " }" + "} catch (e) {" + " bad;" + "}"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().contains(QString::fromLatin1("ReferenceError"))); + } + { + QJSValue 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(); + QJSValue 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(); + QJSValue ret = eng.evaluate( + "o = { bug : \"no bug\" };" + "with (o) {" + " throw 123;" + "}"); + QVERIFY(ret.isNumber()); + QJSValue ret2 = eng.evaluate("bug"); + QVERIFY(ret2.isError()); + QVERIFY(ret2.toString().contains(QString::fromLatin1("ReferenceError"))); + } +} + +#if 0 // ###FIXME: No QScriptEngineAgent API +class TestAgent : public QScriptEngineAgent +{ +public: + TestAgent(QScriptEngine *engine) : QScriptEngineAgent(engine) {} +}; + +void tst_QJSEngine::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_QJSEngine::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_QJSEngine::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); +} +#endif + +#if 0 // ###FIXME: No QScriptString API +void tst_QJSEngine::reentrancy_stringHandles() +{ + QScriptEngine eng1; + QScriptEngine eng2; + QScriptString s1 = eng1.toStringHandle("foo"); + QScriptString s2 = eng2.toStringHandle("foo"); + QVERIFY(s1 != s2); +} +#endif + +#if 0 // ###FIXME: No processEventsInterval API +void tst_QJSEngine::reentrancy_processEventsInterval() +{ + QScriptEngine eng1; + QScriptEngine eng2; + eng1.setProcessEventsInterval(123); + QCOMPARE(eng2.processEventsInterval(), -1); + eng2.setProcessEventsInterval(456); + QCOMPARE(eng1.processEventsInterval(), 123); +} +#endif + +#if 0 // FIXME: No support for custom types +void tst_QJSEngine::reentrancy_typeConversion() +{ + QScriptEngine eng1; + QScriptEngine eng2; + qScriptRegisterMetaType<Foo>(&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 = eng.fromScriptValue<Foo>(fooVal); + QCOMPARE(foo2.x, 56); + QCOMPARE(foo2.y, 78); + } + { + QScriptValue fooVal = qScriptValueFromValue(&eng2, foo); + QVERIFY(fooVal.isVariant()); + + Foo foo2 = eng.fromScriptValue<Foo>(fooVal); + QCOMPARE(foo2.x, 12); + QCOMPARE(foo2.y, 34); + } + QVERIFY(!eng1.defaultPrototype(qMetaTypeId<Foo>()).isValid()); + QVERIFY(!eng2.defaultPrototype(qMetaTypeId<Foo>()).isValid()); + QScriptValue proto1 = eng1.newObject(); + eng1.setDefaultPrototype(qMetaTypeId<Foo>(), proto1); + QVERIFY(!eng2.defaultPrototype(qMetaTypeId<Foo>()).isValid()); + QScriptValue proto2 = eng2.newObject(); + eng2.setDefaultPrototype(qMetaTypeId<Foo>(), proto2); + QVERIFY(eng2.defaultPrototype(qMetaTypeId<Foo>()).isValid()); + QVERIFY(eng1.defaultPrototype(qMetaTypeId<Foo>()).strictlyEquals(proto1)); +} +#endif + +void tst_QJSEngine::reentrancy_globalObjectProperties() +{ + QJSEngine eng1; + QJSEngine 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_QJSEngine::reentrancy_Array() +{ + // weird bug with JSC backend + { + QJSEngine eng; + QCOMPARE(eng.evaluate("Array()").toString(), QString()); + eng.evaluate("Array.prototype.toString"); + QCOMPARE(eng.evaluate("Array()").toString(), QString()); + } + { + QJSEngine eng; + QCOMPARE(eng.evaluate("Array()").toString(), QString()); + } +} + +void tst_QJSEngine::reentrancy_objectCreation() +{ + QJSEngine eng1; + QJSEngine eng2; + { + QJSValue d1 = eng1.newDate(0); + QJSValue d2 = eng2.newDate(0); + QCOMPARE(d1.toDateTime(), d2.toDateTime()); + QCOMPARE(d2.toDateTime(), d1.toDateTime()); + } + { + QJSValue r1 = eng1.newRegExp("foo", "gim"); + QJSValue r2 = eng2.newRegExp("foo", "gim"); + QCOMPARE(r1.toRegExp(), r2.toRegExp()); + QCOMPARE(r2.toRegExp(), r1.toRegExp()); + } + { + QJSValue o1 = eng1.newQObject(this); + QJSValue o2 = eng2.newQObject(this); + QCOMPARE(o1.toQObject(), o2.toQObject()); + QCOMPARE(o2.toQObject(), o1.toQObject()); + } +#if 0 // ###FIXME: No QScriptEngine::newQMetaObject API + { + QScriptValue mo1 = eng1.newQMetaObject(&staticMetaObject); + QScriptValue mo2 = eng2.newQMetaObject(&staticMetaObject); + QCOMPARE(mo1.toQMetaObject(), mo2.toQMetaObject()); + QCOMPARE(mo2.toQMetaObject(), mo1.toQMetaObject()); + } +#endif +} + +void tst_QJSEngine::jsIncDecNonObjectProperty() +{ + // This is testing ECMA-262 compliance, not C++ API. + + QJSEngine eng; + { + QJSValue ret = eng.evaluate("var a; a.n++"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); + } + { + QJSValue ret = eng.evaluate("var a; a.n--"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); + } + { + QJSValue ret = eng.evaluate("var a = null; a.n++"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); + } + { + QJSValue ret = eng.evaluate("var a = null; a.n--"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); + } + { + QJSValue ret = eng.evaluate("var a; ++a.n"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); + } + { + QJSValue ret = eng.evaluate("var a; --a.n"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); + } + { + QJSValue ret = eng.evaluate("var a; a.n += 1"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); + } + { + QJSValue ret = eng.evaluate("var a; a.n -= 1"); + QVERIFY(ret.isError()); + QVERIFY(ret.toString().contains(QString::fromLatin1("TypeError"))); + } + { + QJSValue ret = eng.evaluate("var a = 'ciao'; a.length++"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 4); + } + { + QJSValue ret = eng.evaluate("var a = 'ciao'; a.length--"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 4); + } + { + QJSValue ret = eng.evaluate("var a = 'ciao'; ++a.length"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 5); + } + { + QJSValue ret = eng.evaluate("var a = 'ciao'; --a.length"); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 3); + } +} + +#if 0 // ###FIXME: no installTranslatorFunctions API +void tst_QJSEngine::installTranslatorFunctions() +{ + QScriptEngine eng; + QScriptValue global = eng.globalObject(); + 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(!global.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(global.property("String").property("prototype").property("arg").isFunction()); + + { + 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')"); + QEXPECT_FAIL("Custom global object", "FIXME: why we expect that String prototype exists?", Abort); + 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_QJSEngine::translateScript_data() +{ + QTest::addColumn<QString>("expression"); + QTest::addColumn<QString>("fileName"); + QTest::addColumn<QString>("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_QJSEngine::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_QJSEngine::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_QJSEngine::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_QJSEngine::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_QJSEngine::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_QJSEngine::translateWithInvalidArgs_data() +{ + QTest::addColumn<QString>("expression"); + QTest::addColumn<QString>("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_QJSEngine::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_QJSEngine::translationContext_data() +{ + QTest::addColumn<QString>("path"); + QTest::addColumn<QString>("text"); + QTest::addColumn<QString>("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_QJSEngine::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_QJSEngine::translateScriptIdBased() +{ + QScriptEngine engine; + + TranslationScope tranScope(":/translations/idtranslatable_la"); + engine.installTranslatorFunctions(); + + QString fileName = QString::fromLatin1("idtranslatable.js"); + + QHash<QString, QString> expectedTranslations; + expectedTranslations["qtn_foo_bar"] = "First string"; + expectedTranslations["qtn_needle"] = "Second string"; + expectedTranslations["qtn_haystack"] = "Third string"; + expectedTranslations["qtn_bar_baz"] = "Fourth string"; + + QHash<QString, QString>::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_QJSEngine::translateScriptUnicode_data() +{ + QTest::addColumn<QString>("expression"); + QTest::addColumn<QString>("fileName"); + QTest::addColumn<QString>("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_QJSEngine::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_QJSEngine::translateScriptUnicodeIdBased_data() +{ + QTest::addColumn<QString>("expression"); + QTest::addColumn<QString>("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_QJSEngine::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_QJSEngine::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"); +} +#endif + +#if 0 // ###FIXME: No QScriptValue::scope API +void tst_QJSEngine::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())); + } +} +#endif + +#if 0 // ###FIXME: No QScriptContext API +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_QJSEngine::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()); + QEXPECT_FAIL("", "QScriptValue::setScope not implemented", Continue); + 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")); + QEXPECT_FAIL("", "QScriptValue::setScope not implemented", Continue); + QCOMPARE(eng.evaluate("c1()").toString(), QString::fromLatin1("1")); + QCOMPARE(eng.evaluate("c2()").toString(), QString::fromLatin1("0")); + QEXPECT_FAIL("", "QScriptValue::setScope not implemented", Continue); + 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()); + } +} +#endif + +#if 0 // ###FIXME: No QScriptProgram API +static QScriptValue createProgram(QScriptContext *ctx, QScriptEngine *eng) +{ + QString code = ctx->argument(0).toString(); + QScriptProgram result(code); + return qScriptValueFromValue(eng, result); +} + +void tst_QJSEngine::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_QJSEngine::evaluateProgram_customScope() +{ + QScriptEngine eng; + { + QScriptProgram program("a"); + QVERIFY(!program.isNull()); + { + QScriptValue ret = eng.evaluate(program); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QString::fromLatin1("ReferenceError: a is not defined")); + } + + 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_QJSEngine::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_QJSEngine::evaluateProgram_executeLater() +{ + QScriptEngine eng; + // Program created in a function call, then executed later + { + QScriptValue fun = eng.newFunction(createProgram); + QScriptProgram program = qscriptvalue_cast<QScriptProgram>( + 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: a is not defined")); + } + eng.globalObject().setProperty("a", 122); + { + QScriptValue ret = eng.evaluate(program); + QVERIFY(!ret.isError()); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 123); + } + } +} + +void tst_QJSEngine::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_QJSEngine::evaluateProgram_empty() +{ + QScriptEngine eng; + { + QScriptProgram program; + QVERIFY(program.isNull()); + QScriptValue ret = eng.evaluate(program); + QVERIFY(!ret.isValid()); + } +} +#endif + +#if 0 // ###FIXME: No ScriptOwnership API +void tst_QJSEngine::collectGarbageAfterConnect() +{ + // QTBUG-6366 + QScriptEngine engine; + QPointer<QWidget> 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); +} +#endif + +#if 0 // ###FIXME: No QScriptContext API +void tst_QJSEngine::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) +{ + if (!ctx->isCalledAsConstructor()) { + qWarning("%s: ctx->isCalledAsConstructor() returned false", Q_FUNC_INFO); + return QScriptValue(); + } + return eng->newQObject(ctx->thisObject(), new QObject, QScriptEngine::ScriptOwnership); +} + +void tst_QJSEngine::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()); +} +#endif + +static QRegExp minimal(QRegExp r) { r.setMinimal(true); return r; } + +void tst_QJSEngine::qRegExpInport_data() +{ + QTest::addColumn<QRegExp>("rx"); + QTest::addColumn<QString>("string"); + QTest::addColumn<QString>("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("<b>(.*)</b>", Qt::CaseSensitive, QRegExp::RegExp2) << "<b>bold</b><i>italic</i><b>bold</b>"; + QTest::newRow("html minimal") << minimal(QRegExp("<b>(.*)</b>", Qt::CaseSensitive, QRegExp::RegExp2)) << "<b>bold</b><i>italic</i><b>bold</b>"; + 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_QJSEngine::qRegExpInport() +{ + QFETCH(QRegExp, rx); + QFETCH(QString, string); + + QJSEngine eng; + QJSValue rexp; + rexp = eng.newRegExp(rx); + + QCOMPARE(rexp.isValid(), true); + QCOMPARE(rexp.isRegExp(), true); + QVERIFY(rexp.isFunction()); + + QJSValue func = eng.evaluate("(function(string, regexp) { return string.match(regexp); })"); + QJSValue result = func.call(QJSValue(), QJSValueList() << 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_QJSEngine::dateRoundtripJSQtJS() +{ + uint secs = QDateTime(QDate(2009, 1, 1)).toUTC().toTime_t(); + QJSEngine eng; + for (int i = 0; i < 8000; ++i) { + QJSValue jsDate = eng.evaluate(QString::fromLatin1("new Date(%0)").arg(secs * 1000.0)); + QDateTime qtDate = jsDate.toDateTime(); + QJSValue jsDate2 = eng.newDate(qtDate); + if (jsDate2.toNumber() != jsDate.toNumber()) + QFAIL(qPrintable(jsDate.toString())); + secs += 2*60*60; + } +} + +void tst_QJSEngine::dateRoundtripQtJSQt() +{ + QDateTime qtDate = QDateTime(QDate(2009, 1, 1)); + QJSEngine eng; + for (int i = 0; i < 8000; ++i) { + QJSValue jsDate = eng.newDate(qtDate); + QDateTime qtDate2 = jsDate.toDateTime(); + if (qtDate2 != qtDate) + QFAIL(qPrintable(qtDate.toString())); + qtDate = qtDate.addSecs(2*60*60); + } +} + +void tst_QJSEngine::dateConversionJSQt() +{ + uint secs = QDateTime(QDate(2009, 1, 1)).toUTC().toTime_t(); + QJSEngine eng; + for (int i = 0; i < 8000; ++i) { + QJSValue 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.remove(jsUTCDateStr.length() - 5, 4); // get rid of milliseconds (".000") + if (qtUTCDateStr != jsUTCDateStr) + QFAIL(qPrintable(jsDate.toString())); + secs += 2*60*60; + } +} + +void tst_QJSEngine::dateConversionQtJS() +{ + QDateTime qtDate = QDateTime(QDate(2009, 1, 1)); + QJSEngine eng; + for (int i = 0; i < 8000; ++i) { + QJSValue jsDate = eng.newDate(qtDate); + QString jsUTCDateStr = jsDate.property("toISOString").call(jsDate).toString(); + jsUTCDateStr.remove(jsUTCDateStr.length() - 5, 4); // get rid of milliseconds (".000") + QString qtUTCDateStr = qtDate.toUTC().toString(Qt::ISODate); + if (jsUTCDateStr != qtUTCDateStr) + QFAIL(qPrintable(qtDate.toString())); + qtDate = qtDate.addSecs(2*60*60); + } +} + +#if 0 // ###FIXME: No QScriptContext API +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_QJSEngine::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); +} +#endif + +#if 0 // ###FIXME: No QSCriptDeclarativeClass API +void tst_QJSEngine::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<QString> 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 + QEXPECT_FAIL("", "activationObject has not been implemented yet", Continue); + 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: noSuchProperty is not defined")); + + // 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_QJSEngine::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)); + QEXPECT_FAIL("", "FIXME: newStaticScopeObject not properly implemented", Abort); + 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<QString> 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(); +} +#endif + +#if 0 // ###FIXME: No QScript MetaObject API +QT_BEGIN_NAMESPACE +Q_SCRIPT_DECLARE_QMETAOBJECT(QStandardItemModel, QObject*) +QT_END_NAMESPACE + +void tst_QJSEngine::scriptValueFromQMetaObject() +{ + QScriptEngine eng; + { + QScriptValue meta = eng.scriptValueFromQMetaObject<QScriptEngine>(); + QVERIFY(meta.isQMetaObject()); + QCOMPARE(meta.toQMetaObject(), &QScriptEngine::staticMetaObject); + // Because of missing Q_SCRIPT_DECLARE_QMETAOBJECT() for QScriptEngine. + QEXPECT_FAIL("", "FIXME: because construct never returns invalid values", Continue); + QVERIFY(!meta.construct().isValid()); + } + { + QScriptValue meta = eng.scriptValueFromQMetaObject<QStandardItemModel>(); + QVERIFY(meta.isQMetaObject()); + QCOMPARE(meta.toQMetaObject(), &QStandardItemModel::staticMetaObject); + QScriptValue obj = meta.construct(QScriptValueList() << eng.newQObject(&eng)); + QVERIFY(obj.isQObject()); + QStandardItemModel *model = qobject_cast<QStandardItemModel*>(obj.toQObject()); + QVERIFY(model != 0); + QCOMPARE(model->parent(), (QObject*)&eng); + } +} +#endif + +QTEST_MAIN(tst_QJSEngine) + +#include "tst_qjsengine.moc" + diff --git a/tests/auto/declarative/qjsvalue/qjsvalue.pro b/tests/auto/declarative/qjsvalue/qjsvalue.pro new file mode 100644 index 0000000000..182196a3ed --- /dev/null +++ b/tests/auto/declarative/qjsvalue/qjsvalue.pro @@ -0,0 +1,10 @@ +load(qttest_p4) +QT += declarative +SOURCES += tst_qjsvalue.cpp +HEADERS += tst_qjsvalue.h + +win32-msvc* { + # With -O2, MSVC takes up to 24 minutes to compile this test! + QMAKE_CXXFLAGS_RELEASE -= -O1 -O2 + QMAKE_CXXFLAGS_RELEASE += -Od +} diff --git a/tests/auto/declarative/qjsvalue/tst_qjsvalue.cpp b/tests/auto/declarative/qjsvalue/tst_qjsvalue.cpp new file mode 100644 index 0000000000..9f9e066003 --- /dev/null +++ b/tests/auto/declarative/qjsvalue/tst_qjsvalue.cpp @@ -0,0 +1,4109 @@ +/**************************************************************************** +** +** 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 "tst_qjsvalue.h" +#include <QtGui/QPushButton> + +//TESTED_CLASS= +//TESTED_FILES= + +QT_BEGIN_NAMESPACE +extern bool qt_script_isJITEnabled(); +QT_END_NAMESPACE + +tst_QJSValue::tst_QJSValue() + : engine(0) +{ +} + +tst_QJSValue::~tst_QJSValue() +{ + if (engine) + delete engine; +} + +void tst_QJSValue::ctor_invalid() +{ + QJSEngine eng; + { + QJSValue v; + QCOMPARE(v.isValid(), false); + QCOMPARE(v.engine(), (QJSEngine *)0); + } +} + +void tst_QJSValue::ctor_undefinedWithEngine() +{ + QJSEngine eng; + { + QJSValue v(&eng, QJSValue::UndefinedValue); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isUndefined(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.engine(), &eng); + } +} + +void tst_QJSValue::ctor_nullWithEngine() +{ + QJSEngine eng; + { + QJSValue v(&eng, QJSValue::NullValue); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isNull(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.engine(), &eng); + } +} + +void tst_QJSValue::ctor_boolWithEngine() +{ + QJSEngine eng; + { + QJSValue v(&eng, false); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isBoolean(), true); + QCOMPARE(v.isBool(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.toBoolean(), false); + QCOMPARE(v.engine(), &eng); + } +} + +void tst_QJSValue::ctor_intWithEngine() +{ + QJSEngine eng; + { + QJSValue v(&eng, int(1)); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isNumber(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.toNumber(), 1.0); + QCOMPARE(v.engine(), &eng); + } +} + +void tst_QJSValue::ctor_int() +{ + { + QJSValue v(int(0x43211234)); + QVERIFY(v.isNumber()); + QCOMPARE(v.toInt32(), 0x43211234); + } + { + QJSValue v(int(1)); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isNumber(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.toNumber(), 1.0); + QCOMPARE(v.engine(), (QJSEngine *)0); + } +} + +void tst_QJSValue::ctor_uintWithEngine() +{ + QJSEngine eng; + { + QJSValue v(&eng, uint(1)); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isNumber(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.toNumber(), 1.0); + QCOMPARE(v.engine(), &eng); + } +} + +void tst_QJSValue::ctor_uint() +{ + { + QJSValue v(uint(0x43211234)); + QVERIFY(v.isNumber()); + QCOMPARE(v.toUInt32(), uint(0x43211234)); + } + { + QJSValue v(uint(1)); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isNumber(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.toNumber(), 1.0); + QCOMPARE(v.engine(), (QJSEngine *)0); + } +} + +void tst_QJSValue::ctor_floatWithEngine() +{ + QJSEngine eng; + { + QJSValue v(&eng, 1.0); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isNumber(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.toNumber(), 1.0); + QCOMPARE(v.engine(), &eng); + } +} + +void tst_QJSValue::ctor_float() +{ + { + QJSValue v(12345678910.5); + QVERIFY(v.isNumber()); + QCOMPARE(v.toNumber(), 12345678910.5); + } + { + QJSValue v(1.0); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isNumber(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.toNumber(), 1.0); + QCOMPARE(v.engine(), (QJSEngine *)0); + } +} + +void tst_QJSValue::ctor_stringWithEngine() +{ + QJSEngine eng; + { + QJSValue v(&eng, QLatin1String("ciao")); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isString(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.toString(), QLatin1String("ciao")); + QCOMPARE(v.engine(), &eng); + } +} + +void tst_QJSValue::ctor_string() +{ + { + QJSValue v(QString("ciao")); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isString(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.toString(), QLatin1String("ciao")); + QCOMPARE(v.engine(), (QJSEngine *)0); + } + { + QJSValue v("ciao"); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isString(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.toString(), QLatin1String("ciao")); + QCOMPARE(v.engine(), (QJSEngine *)0); + } +} + +void tst_QJSValue::ctor_copyAndAssignWithEngine() +{ + QJSEngine eng; + // copy constructor, operator= + { + QJSValue v(&eng, 1.0); + QJSValue v2(v); + QCOMPARE(v2.strictlyEquals(v), true); + QCOMPARE(v2.engine(), &eng); + + QJSValue v3(v); + QCOMPARE(v3.strictlyEquals(v), true); + QCOMPARE(v3.strictlyEquals(v2), true); + QCOMPARE(v3.engine(), &eng); + + QJSValue v4(&eng, 2.0); + QCOMPARE(v4.strictlyEquals(v), false); + v3 = v4; + QCOMPARE(v3.strictlyEquals(v), false); + QCOMPARE(v3.strictlyEquals(v4), true); + + v2 = QJSValue(); + QCOMPARE(v2.strictlyEquals(v), false); + QCOMPARE(v.toNumber(), 1.0); + + QJSValue v5(v); + QCOMPARE(v5.strictlyEquals(v), true); + v = QJSValue(); + QCOMPARE(v5.strictlyEquals(v), false); + QCOMPARE(v5.toNumber(), 1.0); + } +} + +void tst_QJSValue::ctor_undefined() +{ + QJSValue v(QJSValue::UndefinedValue); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isUndefined(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.engine(), (QJSEngine *)0); +} + +void tst_QJSValue::ctor_null() +{ + QJSValue v(QJSValue::NullValue); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isNull(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.engine(), (QJSEngine *)0); +} + +void tst_QJSValue::ctor_bool() +{ + QJSValue v(false); + QCOMPARE(v.isValid(), true); + QCOMPARE(v.isBoolean(), true); + QCOMPARE(v.isBool(), true); + QCOMPARE(v.isObject(), false); + QCOMPARE(v.toBoolean(), false); + QCOMPARE(v.engine(), (QJSEngine *)0); +} + +void tst_QJSValue::ctor_copyAndAssign() +{ + QJSValue v(1.0); + QJSValue v2(v); + QCOMPARE(v2.strictlyEquals(v), true); + QCOMPARE(v2.engine(), (QJSEngine *)0); + + QJSValue v3(v); + QCOMPARE(v3.strictlyEquals(v), true); + QCOMPARE(v3.strictlyEquals(v2), true); + QCOMPARE(v3.engine(), (QJSEngine *)0); + + QJSValue v4(2.0); + QCOMPARE(v4.strictlyEquals(v), false); + v3 = v4; + QCOMPARE(v3.strictlyEquals(v), false); + QCOMPARE(v3.strictlyEquals(v4), true); + + v2 = QJSValue(); + QCOMPARE(v2.strictlyEquals(v), false); + QCOMPARE(v.toNumber(), 1.0); + + QJSValue v5(v); + QCOMPARE(v5.strictlyEquals(v), true); + v = QJSValue(); + QCOMPARE(v5.strictlyEquals(v), false); + QCOMPARE(v5.toNumber(), 1.0); +} + +void tst_QJSValue::ctor_nullEngine() +{ + // 0 engine + QVERIFY(QJSValue(0, QJSValue::UndefinedValue).isUndefined()); + QVERIFY(QJSValue(0, QJSValue::NullValue).isNull()); + QVERIFY(QJSValue(0, false).isBool()); + QVERIFY(QJSValue(0, int(1)).isNumber()); + QVERIFY(QJSValue(0, uint(1)).isNumber()); + QVERIFY(QJSValue(0, 1.0).isNumber()); + QVERIFY(QJSValue(0, QString("ciao")).isString()); +} + +#if 0 // FIXME: No c-style callbacks currently +static QJSValue myFunction(QScriptContext *, QScriptEngine *eng) +{ + return eng->undefinedValue(); +} +#endif + +void tst_QJSValue::toString() +{ + QJSEngine eng; + + QJSValue undefined = eng.undefinedValue(); + QCOMPARE(undefined.toString(), QString("undefined")); + QCOMPARE(qjsvalue_cast<QString>(undefined), QString()); + + QJSValue null = eng.nullValue(); + QCOMPARE(null.toString(), QString("null")); + QCOMPARE(qjsvalue_cast<QString>(null), QString()); + + { + QJSValue falskt = QJSValue(&eng, false); + QCOMPARE(falskt.toString(), QString("false")); + QCOMPARE(qjsvalue_cast<QString>(falskt), QString("false")); + + QJSValue sant = QJSValue(&eng, true); + QCOMPARE(sant.toString(), QString("true")); + QCOMPARE(qjsvalue_cast<QString>(sant), QString("true")); + } + { + QJSValue number = QJSValue(&eng, 123); + QCOMPARE(number.toString(), QString("123")); + QCOMPARE(qjsvalue_cast<QString>(number), QString("123")); + } + { + QJSValue number = QJSValue(&eng, 6.37e-8); + QCOMPARE(number.toString(), QString("6.37e-8")); + } + { + QJSValue number = QJSValue(&eng, -6.37e-8); + QCOMPARE(number.toString(), QString("-6.37e-8")); + + QJSValue str = QJSValue(&eng, QString("ciao")); + QCOMPARE(str.toString(), QString("ciao")); + QCOMPARE(qjsvalue_cast<QString>(str), QString("ciao")); + } + + QJSValue object = eng.newObject(); + QCOMPARE(object.toString(), QString("[object Object]")); + QCOMPARE(qjsvalue_cast<QString>(object), QString("[object Object]")); + + // FIXME: No c-style callbacks currently +#if 0 + QJSValue fun = eng.newFunction(myFunction); + QCOMPARE(fun.toString().simplified(), QString("function () { [native code] }")); + QCOMPARE(qscriptvalue_cast<QString>(fun).simplified(), QString("function () { [native code] }")); +#endif + + // toString() that throws exception + { + QJSValue objectObject = eng.evaluate( + "(function(){" + " o = { };" + " o.toString = function() { throw new Error('toString'); };" + " return o;" + "})()"); + QCOMPARE(objectObject.toString(), QLatin1String("Error: toString")); + QVERIFY(eng.hasUncaughtException()); + QCOMPARE(eng.uncaughtException().toString(), QLatin1String("Error: toString")); + } + { + eng.clearExceptions(); + QJSValue objectObject = eng.evaluate( + "(function(){" + " var f = function() {};" + " f.prototype = Date;" + " return new f;" + "})()"); + QVERIFY(!eng.hasUncaughtException()); + QVERIFY(objectObject.isObject()); + QCOMPARE(objectObject.toString(), QString::fromLatin1("TypeError: Function.prototype.toString is not generic")); + QVERIFY(eng.hasUncaughtException()); + eng.clearExceptions(); + } + + QJSValue inv = QJSValue(); + QCOMPARE(inv.toString(), QString()); + + // V2 constructors + { + QJSValue falskt = QJSValue(false); + QCOMPARE(falskt.toString(), QString("false")); + QCOMPARE(qjsvalue_cast<QString>(falskt), QString("false")); + + QJSValue sant = QJSValue(true); + QCOMPARE(sant.toString(), QString("true")); + QCOMPARE(qjsvalue_cast<QString>(sant), QString("true")); + + QJSValue number = QJSValue(123); + QCOMPARE(number.toString(), QString("123")); + QCOMPARE(qjsvalue_cast<QString>(number), QString("123")); + + QJSValue number2(int(0x43211234)); + QCOMPARE(number2.toString(), QString("1126240820")); + + QJSValue str = QJSValue(QString("ciao")); + QCOMPARE(str.toString(), QString("ciao")); + QCOMPARE(qjsvalue_cast<QString>(str), QString("ciao")); + } + + // variant should use internal valueOf(), then fall back to QVariant::toString(), + // then fall back to "QVariant(typename)" + QJSValue variant = eng.newVariant(123); + QVERIFY(variant.isVariant()); + QCOMPARE(variant.toString(), QString::fromLatin1("123")); + variant = eng.newVariant(QByteArray("hello")); + QVERIFY(variant.isVariant()); + QCOMPARE(variant.toString(), QString::fromLatin1("hello")); + variant = eng.newVariant(QVariant(QPoint(10, 20))); + QVERIFY(variant.isVariant()); + QCOMPARE(variant.toString(), QString::fromLatin1("QVariant(QPoint)")); + variant = eng.newVariant(QUrl()); + QVERIFY(variant.toString().isEmpty()); +} + +void tst_QJSValue::toNumber() +{ + QJSEngine eng; + + QJSValue undefined = eng.undefinedValue(); + QCOMPARE(qIsNaN(undefined.toNumber()), true); + QCOMPARE(qIsNaN(qjsvalue_cast<qreal>(undefined)), true); + + QJSValue null = eng.nullValue(); + QCOMPARE(null.toNumber(), 0.0); + QCOMPARE(qjsvalue_cast<qreal>(null), 0.0); + + { + QJSValue falskt = QJSValue(&eng, false); + QCOMPARE(falskt.toNumber(), 0.0); + QCOMPARE(qjsvalue_cast<qreal>(falskt), 0.0); + + QJSValue sant = QJSValue(&eng, true); + QCOMPARE(sant.toNumber(), 1.0); + QCOMPARE(qjsvalue_cast<qreal>(sant), 1.0); + + QJSValue number = QJSValue(&eng, 123.0); + QCOMPARE(number.toNumber(), 123.0); + QCOMPARE(qjsvalue_cast<qreal>(number), 123.0); + + QJSValue str = QJSValue(&eng, QString("ciao")); + QCOMPARE(qIsNaN(str.toNumber()), true); + QCOMPARE(qIsNaN(qjsvalue_cast<qreal>(str)), true); + + QJSValue str2 = QJSValue(&eng, QString("123")); + QCOMPARE(str2.toNumber(), 123.0); + QCOMPARE(qjsvalue_cast<qreal>(str2), 123.0); + } + + QJSValue object = eng.newObject(); + QCOMPARE(qIsNaN(object.toNumber()), true); + QCOMPARE(qIsNaN(qjsvalue_cast<qreal>(object)), true); + + // FIXME: No c-style callbacks currently +#if 0 + QJSValue fun = eng.newFunction(myFunction); + QCOMPARE(qIsNaN(fun.toNumber()), true); + QCOMPARE(qIsNaN(qscriptvalue_cast<qreal>(fun)), true); +#endif + + QJSValue inv = QJSValue(); + QCOMPARE(inv.toNumber(), 0.0); + QCOMPARE(qjsvalue_cast<qreal>(inv), 0.0); + + // V2 constructors + { + QJSValue falskt = QJSValue(false); + QCOMPARE(falskt.toNumber(), 0.0); + QCOMPARE(qjsvalue_cast<qreal>(falskt), 0.0); + + QJSValue sant = QJSValue(true); + QCOMPARE(sant.toNumber(), 1.0); + QCOMPARE(qjsvalue_cast<qreal>(sant), 1.0); + + QJSValue number = QJSValue(123.0); + QCOMPARE(number.toNumber(), 123.0); + QCOMPARE(qjsvalue_cast<qreal>(number), 123.0); + + QJSValue number2(int(0x43211234)); + QCOMPARE(number2.toNumber(), 1126240820.0); + + QJSValue str = QJSValue(QString("ciao")); + QCOMPARE(qIsNaN(str.toNumber()), true); + QCOMPARE(qIsNaN(qjsvalue_cast<qreal>(str)), true); + + QJSValue str2 = QJSValue(QString("123")); + QCOMPARE(str2.toNumber(), 123.0); + QCOMPARE(qjsvalue_cast<qreal>(str2), 123.0); + } +} + +void tst_QJSValue::toBoolean() // deprecated +{ + QJSEngine eng; + + QJSValue undefined = eng.undefinedValue(); + QCOMPARE(undefined.toBoolean(), false); + QCOMPARE(qjsvalue_cast<bool>(undefined), false); + + QJSValue null = eng.nullValue(); + QCOMPARE(null.toBoolean(), false); + QCOMPARE(qjsvalue_cast<bool>(null), false); + + { + QJSValue falskt = QJSValue(&eng, false); + QCOMPARE(falskt.toBoolean(), false); + QCOMPARE(qjsvalue_cast<bool>(falskt), false); + + QJSValue sant = QJSValue(&eng, true); + QCOMPARE(sant.toBoolean(), true); + QCOMPARE(qjsvalue_cast<bool>(sant), true); + + QJSValue number = QJSValue(&eng, 0.0); + QCOMPARE(number.toBoolean(), false); + QCOMPARE(qjsvalue_cast<bool>(number), false); + + QJSValue number2 = QJSValue(&eng, qSNaN()); + QCOMPARE(number2.toBoolean(), false); + QCOMPARE(qjsvalue_cast<bool>(number2), false); + + QJSValue number3 = QJSValue(&eng, 123.0); + QCOMPARE(number3.toBoolean(), true); + QCOMPARE(qjsvalue_cast<bool>(number3), true); + + QJSValue number4 = QJSValue(&eng, -456.0); + QCOMPARE(number4.toBoolean(), true); + QCOMPARE(qjsvalue_cast<bool>(number4), true); + + QJSValue str = QJSValue(&eng, QString("")); + QCOMPARE(str.toBoolean(), false); + QCOMPARE(qjsvalue_cast<bool>(str), false); + + QJSValue str2 = QJSValue(&eng, QString("123")); + QCOMPARE(str2.toBoolean(), true); + QCOMPARE(qjsvalue_cast<bool>(str2), true); + } + + QJSValue object = eng.newObject(); + QCOMPARE(object.toBoolean(), true); + QCOMPARE(qjsvalue_cast<bool>(object), true); + + // FIXME: No c-style callbacks currently +#if 0 + QJSValue fun = eng.newFunction(myFunction); + QCOMPARE(fun.toBoolean(), true); + QCOMPARE(qscriptvalue_cast<bool>(fun), true); +#endif + + QJSValue inv = QJSValue(); + QCOMPARE(inv.toBoolean(), false); + QCOMPARE(qjsvalue_cast<bool>(inv), false); + + // V2 constructors + { + QJSValue falskt = QJSValue(false); + QCOMPARE(falskt.toBoolean(), false); + QCOMPARE(qjsvalue_cast<bool>(falskt), false); + + QJSValue sant = QJSValue(true); + QCOMPARE(sant.toBoolean(), true); + QCOMPARE(qjsvalue_cast<bool>(sant), true); + + QJSValue number = QJSValue(0.0); + QCOMPARE(number.toBoolean(), false); + QCOMPARE(qjsvalue_cast<bool>(number), false); + + QJSValue number2 = QJSValue(qSNaN()); + QCOMPARE(number2.toBoolean(), false); + QCOMPARE(qjsvalue_cast<bool>(number2), false); + + QJSValue number3 = QJSValue(123.0); + QCOMPARE(number3.toBoolean(), true); + QCOMPARE(qjsvalue_cast<bool>(number3), true); + + QJSValue number4 = QJSValue(-456.0); + QCOMPARE(number4.toBoolean(), true); + QCOMPARE(qjsvalue_cast<bool>(number4), true); + + QJSValue number5 = QJSValue(0x43211234); + QCOMPARE(number5.toBoolean(), true); + + QJSValue str = QJSValue(QString("")); + QCOMPARE(str.toBoolean(), false); + QCOMPARE(qjsvalue_cast<bool>(str), false); + + QJSValue str2 = QJSValue(QString("123")); + QCOMPARE(str2.toBoolean(), true); + QCOMPARE(qjsvalue_cast<bool>(str2), true); + } +} + +void tst_QJSValue::toBool() +{ + QJSEngine eng; + + QJSValue undefined = eng.undefinedValue(); + QCOMPARE(undefined.toBool(), false); + QCOMPARE(qjsvalue_cast<bool>(undefined), false); + + QJSValue null = eng.nullValue(); + QCOMPARE(null.toBool(), false); + QCOMPARE(qjsvalue_cast<bool>(null), false); + + { + QJSValue falskt = QJSValue(&eng, false); + QCOMPARE(falskt.toBool(), false); + QCOMPARE(qjsvalue_cast<bool>(falskt), false); + + QJSValue sant = QJSValue(&eng, true); + QCOMPARE(sant.toBool(), true); + QCOMPARE(qjsvalue_cast<bool>(sant), true); + + QJSValue number = QJSValue(&eng, 0.0); + QCOMPARE(number.toBool(), false); + QCOMPARE(qjsvalue_cast<bool>(number), false); + + QJSValue number2 = QJSValue(&eng, qSNaN()); + QCOMPARE(number2.toBool(), false); + QCOMPARE(qjsvalue_cast<bool>(number2), false); + + QJSValue number3 = QJSValue(&eng, 123.0); + QCOMPARE(number3.toBool(), true); + QCOMPARE(qjsvalue_cast<bool>(number3), true); + + QJSValue number4 = QJSValue(&eng, -456.0); + QCOMPARE(number4.toBool(), true); + QCOMPARE(qjsvalue_cast<bool>(number4), true); + + QJSValue str = QJSValue(&eng, QString("")); + QCOMPARE(str.toBool(), false); + QCOMPARE(qjsvalue_cast<bool>(str), false); + + QJSValue str2 = QJSValue(&eng, QString("123")); + QCOMPARE(str2.toBool(), true); + QCOMPARE(qjsvalue_cast<bool>(str2), true); + } + + QJSValue object = eng.newObject(); + QCOMPARE(object.toBool(), true); + QCOMPARE(qjsvalue_cast<bool>(object), true); + + // FIXME: No c-style callbacks currently +#if 0 + QJSValue fun = eng.newFunction(myFunction); + QCOMPARE(fun.toBool(), true); + QCOMPARE(qscriptvalue_cast<bool>(fun), true); +#endif + + QJSValue inv = QJSValue(); + QCOMPARE(inv.toBool(), false); + QCOMPARE(qjsvalue_cast<bool>(inv), false); + + // V2 constructors + { + QJSValue falskt = QJSValue(false); + QCOMPARE(falskt.toBool(), false); + QCOMPARE(qjsvalue_cast<bool>(falskt), false); + + QJSValue sant = QJSValue(true); + QCOMPARE(sant.toBool(), true); + QCOMPARE(qjsvalue_cast<bool>(sant), true); + + QJSValue number = QJSValue(0.0); + QCOMPARE(number.toBool(), false); + QCOMPARE(qjsvalue_cast<bool>(number), false); + + QJSValue number2 = QJSValue(qSNaN()); + QCOMPARE(number2.toBool(), false); + QCOMPARE(qjsvalue_cast<bool>(number2), false); + + QJSValue number3 = QJSValue(123.0); + QCOMPARE(number3.toBool(), true); + QCOMPARE(qjsvalue_cast<bool>(number3), true); + + QJSValue number4 = QJSValue(-456.0); + QCOMPARE(number4.toBool(), true); + QCOMPARE(qjsvalue_cast<bool>(number4), true); + + QJSValue number5 = QJSValue(0x43211234); + QCOMPARE(number5.toBool(), true); + + QJSValue str = QJSValue(QString("")); + QCOMPARE(str.toBool(), false); + QCOMPARE(qjsvalue_cast<bool>(str), false); + + QJSValue str2 = QJSValue(QString("123")); + QCOMPARE(str2.toBool(), true); + QCOMPARE(qjsvalue_cast<bool>(str2), true); + } +} + +void tst_QJSValue::toInteger() +{ + QJSEngine eng; + + { + QJSValue number = QJSValue(&eng, 123.0); + QCOMPARE(number.toInteger(), 123.0); + + QJSValue number2 = QJSValue(&eng, qSNaN()); + QCOMPARE(number2.toInteger(), 0.0); + + QJSValue number3 = QJSValue(&eng, qInf()); + QCOMPARE(qIsInf(number3.toInteger()), true); + + QJSValue number4 = QJSValue(&eng, 0.5); + QCOMPARE(number4.toInteger(), 0.0); + + QJSValue number5 = QJSValue(&eng, 123.5); + QCOMPARE(number5.toInteger(), 123.0); + + QJSValue number6 = QJSValue(&eng, -456.5); + QCOMPARE(number6.toInteger(), -456.0); + + QJSValue str = QJSValue(&eng, QLatin1String("123.0")); + QCOMPARE(str.toInteger(), 123.0); + + QJSValue str2 = QJSValue(&eng, QLatin1String("NaN")); + QCOMPARE(str2.toInteger(), 0.0); + + QJSValue str3 = QJSValue(&eng, QLatin1String("Infinity")); + QCOMPARE(qIsInf(str3.toInteger()), true); + + QJSValue str4 = QJSValue(&eng, QLatin1String("0.5")); + QCOMPARE(str4.toInteger(), 0.0); + + QJSValue str5 = QJSValue(&eng, QLatin1String("123.5")); + QCOMPARE(str5.toInteger(), 123.0); + + QJSValue str6 = QJSValue(&eng, QLatin1String("-456.5")); + QCOMPARE(str6.toInteger(), -456.0); + } + // V2 constructors + { + QJSValue number = QJSValue(123.0); + QCOMPARE(number.toInteger(), 123.0); + + QJSValue number2 = QJSValue(qSNaN()); + QCOMPARE(number2.toInteger(), 0.0); + + QJSValue number3 = QJSValue(qInf()); + QCOMPARE(qIsInf(number3.toInteger()), true); + + QJSValue number4 = QJSValue(0.5); + QCOMPARE(number4.toInteger(), 0.0); + + QJSValue number5 = QJSValue(123.5); + QCOMPARE(number5.toInteger(), 123.0); + + QJSValue number6 = QJSValue(-456.5); + QCOMPARE(number6.toInteger(), -456.0); + + QJSValue number7 = QJSValue(0x43211234); + QCOMPARE(number7.toInteger(), qreal(0x43211234)); + + QJSValue str = QJSValue("123.0"); + QCOMPARE(str.toInteger(), 123.0); + + QJSValue str2 = QJSValue("NaN"); + QCOMPARE(str2.toInteger(), 0.0); + + QJSValue str3 = QJSValue("Infinity"); + QCOMPARE(qIsInf(str3.toInteger()), true); + + QJSValue str4 = QJSValue("0.5"); + QCOMPARE(str4.toInteger(), 0.0); + + QJSValue str5 = QJSValue("123.5"); + QCOMPARE(str5.toInteger(), 123.0); + + QJSValue str6 = QJSValue("-456.5"); + QCOMPARE(str6.toInteger(), -456.0); + } + + QJSValue inv; + QCOMPARE(inv.toInteger(), 0.0); +} + +void tst_QJSValue::toInt32() +{ + QJSEngine eng; + + { + QJSValue zer0 = QJSValue(&eng, 0.0); + QCOMPARE(zer0.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(zer0), 0); + + QJSValue number = QJSValue(&eng, 123.0); + QCOMPARE(number.toInt32(), 123); + QCOMPARE(qjsvalue_cast<qint32>(number), 123); + + QJSValue number2 = QJSValue(&eng, qSNaN()); + QCOMPARE(number2.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(number2), 0); + + QJSValue number3 = QJSValue(&eng, +qInf()); + QCOMPARE(number3.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(number3), 0); + + QJSValue number3_2 = QJSValue(&eng, -qInf()); + QCOMPARE(number3_2.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(number3_2), 0); + + QJSValue number4 = QJSValue(&eng, 0.5); + QCOMPARE(number4.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(number4), 0); + + QJSValue number5 = QJSValue(&eng, 123.5); + QCOMPARE(number5.toInt32(), 123); + QCOMPARE(qjsvalue_cast<qint32>(number5), 123); + + QJSValue number6 = QJSValue(&eng, -456.5); + QCOMPARE(number6.toInt32(), -456); + QCOMPARE(qjsvalue_cast<qint32>(number6), -456); + + QJSValue str = QJSValue(&eng, QLatin1String("123.0")); + QCOMPARE(str.toInt32(), 123); + QCOMPARE(qjsvalue_cast<qint32>(str), 123); + + QJSValue str2 = QJSValue(&eng, QLatin1String("NaN")); + QCOMPARE(str2.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(str2), 0); + + QJSValue str3 = QJSValue(&eng, QLatin1String("Infinity")); + QCOMPARE(str3.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(str3), 0); + + QJSValue str3_2 = QJSValue(&eng, QLatin1String("-Infinity")); + QCOMPARE(str3_2.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(str3_2), 0); + + QJSValue str4 = QJSValue(&eng, QLatin1String("0.5")); + QCOMPARE(str4.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(str4), 0); + + QJSValue str5 = QJSValue(&eng, QLatin1String("123.5")); + QCOMPARE(str5.toInt32(), 123); + QCOMPARE(qjsvalue_cast<qint32>(str5), 123); + + QJSValue str6 = QJSValue(&eng, QLatin1String("-456.5")); + QCOMPARE(str6.toInt32(), -456); + QCOMPARE(qjsvalue_cast<qint32>(str6), -456); + } + // V2 constructors + { + QJSValue zer0 = QJSValue(0.0); + QCOMPARE(zer0.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(zer0), 0); + + QJSValue number = QJSValue(123.0); + QCOMPARE(number.toInt32(), 123); + QCOMPARE(qjsvalue_cast<qint32>(number), 123); + + QJSValue number2 = QJSValue(qSNaN()); + QCOMPARE(number2.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(number2), 0); + + QJSValue number3 = QJSValue(+qInf()); + QCOMPARE(number3.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(number3), 0); + + QJSValue number3_2 = QJSValue(-qInf()); + QCOMPARE(number3_2.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(number3_2), 0); + + QJSValue number4 = QJSValue(0.5); + QCOMPARE(number4.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(number4), 0); + + QJSValue number5 = QJSValue(123.5); + QCOMPARE(number5.toInt32(), 123); + QCOMPARE(qjsvalue_cast<qint32>(number5), 123); + + QJSValue number6 = QJSValue(-456.5); + QCOMPARE(number6.toInt32(), -456); + QCOMPARE(qjsvalue_cast<qint32>(number6), -456); + + QJSValue number7 = QJSValue(0x43211234); + QCOMPARE(number7.toInt32(), 0x43211234); + + QJSValue str = QJSValue("123.0"); + QCOMPARE(str.toInt32(), 123); + QCOMPARE(qjsvalue_cast<qint32>(str), 123); + + QJSValue str2 = QJSValue("NaN"); + QCOMPARE(str2.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(str2), 0); + + QJSValue str3 = QJSValue("Infinity"); + QCOMPARE(str3.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(str3), 0); + + QJSValue str3_2 = QJSValue("-Infinity"); + QCOMPARE(str3_2.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(str3_2), 0); + + QJSValue str4 = QJSValue("0.5"); + QCOMPARE(str4.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(str4), 0); + + QJSValue str5 = QJSValue("123.5"); + QCOMPARE(str5.toInt32(), 123); + QCOMPARE(qjsvalue_cast<qint32>(str5), 123); + + QJSValue str6 = QJSValue("-456.5"); + QCOMPARE(str6.toInt32(), -456); + QCOMPARE(qjsvalue_cast<qint32>(str6), -456); + } + + QJSValue inv; + QCOMPARE(inv.toInt32(), 0); + QCOMPARE(qjsvalue_cast<qint32>(inv), 0); +} + +void tst_QJSValue::toUInt32() +{ + QJSEngine eng; + + { + QJSValue zer0 = QJSValue(&eng, 0.0); + QCOMPARE(zer0.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(zer0), quint32(0)); + + QJSValue number = QJSValue(&eng, 123.0); + QCOMPARE(number.toUInt32(), quint32(123)); + QCOMPARE(qjsvalue_cast<quint32>(number), quint32(123)); + + QJSValue number2 = QJSValue(&eng, qSNaN()); + QCOMPARE(number2.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(number2), quint32(0)); + + QJSValue number3 = QJSValue(&eng, +qInf()); + QCOMPARE(number3.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(number3), quint32(0)); + + QJSValue number3_2 = QJSValue(&eng, -qInf()); + QCOMPARE(number3_2.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(number3_2), quint32(0)); + + QJSValue number4 = QJSValue(&eng, 0.5); + QCOMPARE(number4.toUInt32(), quint32(0)); + + QJSValue number5 = QJSValue(&eng, 123.5); + QCOMPARE(number5.toUInt32(), quint32(123)); + + QJSValue number6 = QJSValue(&eng, -456.5); + QCOMPARE(number6.toUInt32(), quint32(-456)); + QCOMPARE(qjsvalue_cast<quint32>(number6), quint32(-456)); + + QJSValue str = QJSValue(&eng, QLatin1String("123.0")); + QCOMPARE(str.toUInt32(), quint32(123)); + QCOMPARE(qjsvalue_cast<quint32>(str), quint32(123)); + + QJSValue str2 = QJSValue(&eng, QLatin1String("NaN")); + QCOMPARE(str2.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(str2), quint32(0)); + + QJSValue str3 = QJSValue(&eng, QLatin1String("Infinity")); + QCOMPARE(str3.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(str3), quint32(0)); + + QJSValue str3_2 = QJSValue(&eng, QLatin1String("-Infinity")); + QCOMPARE(str3_2.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(str3_2), quint32(0)); + + QJSValue str4 = QJSValue(&eng, QLatin1String("0.5")); + QCOMPARE(str4.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(str4), quint32(0)); + + QJSValue str5 = QJSValue(&eng, QLatin1String("123.5")); + QCOMPARE(str5.toUInt32(), quint32(123)); + QCOMPARE(qjsvalue_cast<quint32>(str5), quint32(123)); + + QJSValue str6 = QJSValue(&eng, QLatin1String("-456.5")); + QCOMPARE(str6.toUInt32(), quint32(-456)); + QCOMPARE(qjsvalue_cast<quint32>(str6), quint32(-456)); + } + // V2 constructors + { + QJSValue zer0 = QJSValue(0.0); + QCOMPARE(zer0.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(zer0), quint32(0)); + + QJSValue number = QJSValue(123.0); + QCOMPARE(number.toUInt32(), quint32(123)); + QCOMPARE(qjsvalue_cast<quint32>(number), quint32(123)); + + QJSValue number2 = QJSValue(qSNaN()); + QCOMPARE(number2.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(number2), quint32(0)); + + QJSValue number3 = QJSValue(+qInf()); + QCOMPARE(number3.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(number3), quint32(0)); + + QJSValue number3_2 = QJSValue(-qInf()); + QCOMPARE(number3_2.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(number3_2), quint32(0)); + + QJSValue number4 = QJSValue(0.5); + QCOMPARE(number4.toUInt32(), quint32(0)); + + QJSValue number5 = QJSValue(123.5); + QCOMPARE(number5.toUInt32(), quint32(123)); + + QJSValue number6 = QJSValue(-456.5); + QCOMPARE(number6.toUInt32(), quint32(-456)); + QCOMPARE(qjsvalue_cast<quint32>(number6), quint32(-456)); + + QJSValue number7 = QJSValue(0x43211234); + QCOMPARE(number7.toUInt32(), quint32(0x43211234)); + + QJSValue str = QJSValue(QLatin1String("123.0")); + QCOMPARE(str.toUInt32(), quint32(123)); + QCOMPARE(qjsvalue_cast<quint32>(str), quint32(123)); + + QJSValue str2 = QJSValue(QLatin1String("NaN")); + QCOMPARE(str2.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(str2), quint32(0)); + + QJSValue str3 = QJSValue(QLatin1String("Infinity")); + QCOMPARE(str3.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(str3), quint32(0)); + + QJSValue str3_2 = QJSValue(QLatin1String("-Infinity")); + QCOMPARE(str3_2.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(str3_2), quint32(0)); + + QJSValue str4 = QJSValue(QLatin1String("0.5")); + QCOMPARE(str4.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(str4), quint32(0)); + + QJSValue str5 = QJSValue(QLatin1String("123.5")); + QCOMPARE(str5.toUInt32(), quint32(123)); + QCOMPARE(qjsvalue_cast<quint32>(str5), quint32(123)); + + QJSValue str6 = QJSValue(QLatin1String("-456.5")); + QCOMPARE(str6.toUInt32(), quint32(-456)); + QCOMPARE(qjsvalue_cast<quint32>(str6), quint32(-456)); + } + + QJSValue inv; + QCOMPARE(inv.toUInt32(), quint32(0)); + QCOMPARE(qjsvalue_cast<quint32>(inv), quint32(0)); +} + +void tst_QJSValue::toUInt16() +{ + QJSEngine eng; + + { + QJSValue zer0 = QJSValue(&eng, 0.0); + QCOMPARE(zer0.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(zer0), quint16(0)); + + QJSValue number = QJSValue(&eng, 123.0); + QCOMPARE(number.toUInt16(), quint16(123)); + QCOMPARE(qjsvalue_cast<quint16>(number), quint16(123)); + + QJSValue number2 = QJSValue(&eng, qSNaN()); + QCOMPARE(number2.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(number2), quint16(0)); + + QJSValue number3 = QJSValue(&eng, +qInf()); + QCOMPARE(number3.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(number3), quint16(0)); + + QJSValue number3_2 = QJSValue(&eng, -qInf()); + QCOMPARE(number3_2.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(number3_2), quint16(0)); + + QJSValue number4 = QJSValue(&eng, 0.5); + QCOMPARE(number4.toUInt16(), quint16(0)); + + QJSValue number5 = QJSValue(&eng, 123.5); + QCOMPARE(number5.toUInt16(), quint16(123)); + + QJSValue number6 = QJSValue(&eng, -456.5); + QCOMPARE(number6.toUInt16(), quint16(-456)); + QCOMPARE(qjsvalue_cast<quint16>(number6), quint16(-456)); + + QJSValue number7 = QJSValue(&eng, 0x10000); + QCOMPARE(number7.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(number7), quint16(0)); + + QJSValue number8 = QJSValue(&eng, 0x10001); + QCOMPARE(number8.toUInt16(), quint16(1)); + QCOMPARE(qjsvalue_cast<quint16>(number8), quint16(1)); + + QJSValue str = QJSValue(&eng, QLatin1String("123.0")); + QCOMPARE(str.toUInt16(), quint16(123)); + QCOMPARE(qjsvalue_cast<quint16>(str), quint16(123)); + + QJSValue str2 = QJSValue(&eng, QLatin1String("NaN")); + QCOMPARE(str2.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(str2), quint16(0)); + + QJSValue str3 = QJSValue(&eng, QLatin1String("Infinity")); + QCOMPARE(str3.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(str3), quint16(0)); + + QJSValue str3_2 = QJSValue(&eng, QLatin1String("-Infinity")); + QCOMPARE(str3_2.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(str3_2), quint16(0)); + + QJSValue str4 = QJSValue(&eng, QLatin1String("0.5")); + QCOMPARE(str4.toUInt16(), quint16(0)); + + QJSValue str5 = QJSValue(&eng, QLatin1String("123.5")); + QCOMPARE(str5.toUInt16(), quint16(123)); + + QJSValue str6 = QJSValue(&eng, QLatin1String("-456.5")); + QCOMPARE(str6.toUInt16(), quint16(-456)); + QCOMPARE(qjsvalue_cast<quint16>(str6), quint16(-456)); + + QJSValue str7 = QJSValue(&eng, QLatin1String("0x10000")); + QCOMPARE(str7.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(str7), quint16(0)); + + QJSValue str8 = QJSValue(&eng, QLatin1String("0x10001")); + QCOMPARE(str8.toUInt16(), quint16(1)); + QCOMPARE(qjsvalue_cast<quint16>(str8), quint16(1)); + } + // V2 constructors + { + QJSValue zer0 = QJSValue(0.0); + QCOMPARE(zer0.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(zer0), quint16(0)); + + QJSValue number = QJSValue(123.0); + QCOMPARE(number.toUInt16(), quint16(123)); + QCOMPARE(qjsvalue_cast<quint16>(number), quint16(123)); + + QJSValue number2 = QJSValue(qSNaN()); + QCOMPARE(number2.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(number2), quint16(0)); + + QJSValue number3 = QJSValue(+qInf()); + QCOMPARE(number3.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(number3), quint16(0)); + + QJSValue number3_2 = QJSValue(-qInf()); + QCOMPARE(number3_2.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(number3_2), quint16(0)); + + QJSValue number4 = QJSValue(0.5); + QCOMPARE(number4.toUInt16(), quint16(0)); + + QJSValue number5 = QJSValue(123.5); + QCOMPARE(number5.toUInt16(), quint16(123)); + + QJSValue number6 = QJSValue(-456.5); + QCOMPARE(number6.toUInt16(), quint16(-456)); + QCOMPARE(qjsvalue_cast<quint16>(number6), quint16(-456)); + + QJSValue number7 = QJSValue(0x10000); + QCOMPARE(number7.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(number7), quint16(0)); + + QJSValue number8 = QJSValue(0x10001); + QCOMPARE(number8.toUInt16(), quint16(1)); + QCOMPARE(qjsvalue_cast<quint16>(number8), quint16(1)); + + QJSValue str = QJSValue(QLatin1String("123.0")); + QCOMPARE(str.toUInt16(), quint16(123)); + QCOMPARE(qjsvalue_cast<quint16>(str), quint16(123)); + + QJSValue str2 = QJSValue(QLatin1String("NaN")); + QCOMPARE(str2.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(str2), quint16(0)); + + QJSValue str3 = QJSValue(QLatin1String("Infinity")); + QCOMPARE(str3.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(str3), quint16(0)); + + QJSValue str3_2 = QJSValue(QLatin1String("-Infinity")); + QCOMPARE(str3_2.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(str3_2), quint16(0)); + + QJSValue str4 = QJSValue("0.5"); + QCOMPARE(str4.toUInt16(), quint16(0)); + + QJSValue str5 = QJSValue("123.5"); + QCOMPARE(str5.toUInt16(), quint16(123)); + + QJSValue str6 = QJSValue("-456.5"); + QCOMPARE(str6.toUInt16(), quint16(-456)); + QCOMPARE(qjsvalue_cast<quint16>(str6), quint16(-456)); + + QJSValue str7 = QJSValue("0x10000"); + QCOMPARE(str7.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(str7), quint16(0)); + + QJSValue str8 = QJSValue("0x10001"); + QCOMPARE(str8.toUInt16(), quint16(1)); + QCOMPARE(qjsvalue_cast<quint16>(str8), quint16(1)); + } + + QJSValue inv; + QCOMPARE(inv.toUInt16(), quint16(0)); + QCOMPARE(qjsvalue_cast<quint16>(inv), quint16(0)); +} + +#if defined Q_CC_MSVC && _MSC_VER < 1300 +Q_DECLARE_METATYPE(QVariant) +#endif + +void tst_QJSValue::toVariant() +{ + QJSEngine eng; + + QJSValue undefined = eng.undefinedValue(); + QCOMPARE(undefined.toVariant(), QVariant()); + QCOMPARE(qjsvalue_cast<QVariant>(undefined), QVariant()); + + QJSValue null = eng.nullValue(); + QCOMPARE(null.toVariant(), QVariant()); + QCOMPARE(qjsvalue_cast<QVariant>(null), QVariant()); + + { + QJSValue number = QJSValue(&eng, 123.0); + QCOMPARE(number.toVariant(), QVariant(123.0)); + QCOMPARE(qjsvalue_cast<QVariant>(number), QVariant(123.0)); + + QJSValue intNumber = QJSValue(&eng, (qint32)123); + QCOMPARE(intNumber.toVariant().type(), QVariant((qint32)123).type()); + QCOMPARE((qjsvalue_cast<QVariant>(number)).type(), QVariant((qint32)123).type()); + + QJSValue falskt = QJSValue(&eng, false); + QCOMPARE(falskt.toVariant(), QVariant(false)); + QCOMPARE(qjsvalue_cast<QVariant>(falskt), QVariant(false)); + + QJSValue sant = QJSValue(&eng, true); + QCOMPARE(sant.toVariant(), QVariant(true)); + QCOMPARE(qjsvalue_cast<QVariant>(sant), QVariant(true)); + + QJSValue str = QJSValue(&eng, QString("ciao")); + QCOMPARE(str.toVariant(), QVariant(QString("ciao"))); + QCOMPARE(qjsvalue_cast<QVariant>(str), QVariant(QString("ciao"))); + } + + QVariant var(QChar(0x007A)); + QJSValue opaque = eng.newVariant(var); + QVERIFY(opaque.isVariant()); + QCOMPARE(opaque.toVariant(), var); + + QJSValue object = eng.newObject(); + QCOMPARE(object.toVariant(), QVariant(QVariantMap())); + + QJSValue qobject = eng.newQObject(this); + { + QVariant var = qobject.toVariant(); + QCOMPARE(var.userType(), int(QMetaType::QObjectStar)); + QCOMPARE(qVariantValue<QObject*>(var), (QObject *)this); + } + + { + QDateTime dateTime = QDateTime(QDate(1980, 10, 4)); + QJSValue dateObject = eng.newDate(dateTime); + QVariant var = dateObject.toVariant(); + QCOMPARE(var, QVariant(dateTime)); + } + + { + QRegExp rx = QRegExp("[0-9a-z]+", Qt::CaseSensitive, QRegExp::RegExp2); + QJSValue rxObject = eng.newRegExp(rx); + QVariant var = rxObject.toVariant(); + QCOMPARE(var, QVariant(rx)); + } + + QJSValue inv; + QCOMPARE(inv.toVariant(), QVariant()); + QCOMPARE(qjsvalue_cast<QVariant>(inv), QVariant()); + + // V2 constructors + { + QJSValue number = QJSValue(123.0); + QCOMPARE(number.toVariant(), QVariant(123.0)); + QCOMPARE(qjsvalue_cast<QVariant>(number), QVariant(123.0)); + + QJSValue falskt = QJSValue(false); + QCOMPARE(falskt.toVariant(), QVariant(false)); + QCOMPARE(qjsvalue_cast<QVariant>(falskt), QVariant(false)); + + QJSValue sant = QJSValue(true); + QCOMPARE(sant.toVariant(), QVariant(true)); + QCOMPARE(qjsvalue_cast<QVariant>(sant), QVariant(true)); + + QJSValue str = QJSValue(QString("ciao")); + QCOMPARE(str.toVariant(), QVariant(QString("ciao"))); + QCOMPARE(qjsvalue_cast<QVariant>(str), QVariant(QString("ciao"))); + } + +#if 0 // FIXME: No automatic sequence conversion + // array + { + QVariantList listIn; + listIn << 123 << "hello"; + QJSValue array = qScriptValueFromValue(&eng, listIn); + QVERIFY(array.isArray()); + QCOMPARE(array.property("length").toInt32(), 2); + QVariant ret = array.toVariant(); + QCOMPARE(ret.type(), QVariant::List); + QVariantList listOut = ret.toList(); + QCOMPARE(listOut.size(), listIn.size()); + for (int i = 0; i < listIn.size(); ++i) + QVERIFY(listOut.at(i) == listIn.at(i)); + // round-trip conversion + QJSValue array2 = qScriptValueFromValue(&eng, ret); + QVERIFY(array2.isArray()); + QCOMPARE(array2.property("length").toInt32(), array.property("length").toInt32()); + for (int i = 0; i < array.property("length").toInt32(); ++i) + QVERIFY(array2.property(i).strictlyEquals(array.property(i))); + } +#endif +} + +void tst_QJSValue::toQObject_nonQObject_data() +{ + newEngine(); + QTest::addColumn<QJSValue>("value"); + + QTest::newRow("invalid") << QJSValue(); + QTest::newRow("bool(false)") << QJSValue(false); + QTest::newRow("bool(true)") << QJSValue(true); + QTest::newRow("int") << QJSValue(123); + QTest::newRow("string") << QJSValue(QString::fromLatin1("ciao")); + QTest::newRow("undefined") << QJSValue(QJSValue::UndefinedValue); + QTest::newRow("null") << QJSValue(QJSValue::NullValue); + + QTest::newRow("bool bound(false)") << QJSValue(engine, false); + QTest::newRow("bool bound(true)") << QJSValue(engine, true); + QTest::newRow("int bound") << QJSValue(engine, 123); + QTest::newRow("string bound") << QJSValue(engine, QString::fromLatin1("ciao")); + QTest::newRow("undefined bound") << engine->undefinedValue(); + QTest::newRow("null bound") << engine->nullValue(); + QTest::newRow("object") << engine->newObject(); + QTest::newRow("array") << engine->newArray(); + QTest::newRow("date") << engine->newDate(124); + QTest::newRow("variant(12345)") << engine->newVariant(12345); + QTest::newRow("variant((QObject*)0)") << engine->newVariant(qVariantFromValue((QObject*)0)); + QTest::newRow("newQObject(0)") << engine->newQObject(0); +} + + +void tst_QJSValue::toQObject_nonQObject() +{ + QFETCH(QJSValue, value); + QCOMPARE(value.toQObject(), (QObject *)0); + QCOMPARE(qjsvalue_cast<QObject*>(value), (QObject *)0); +} + +// unfortunately, this is necessary in order to do qscriptvalue_cast<QPushButton*>(...) +Q_DECLARE_METATYPE(QPushButton*); + +void tst_QJSValue::toQObject() +{ + QJSEngine eng; + + QJSValue qobject = eng.newQObject(this); + QCOMPARE(qobject.toQObject(), (QObject *)this); + QCOMPARE(qjsvalue_cast<QObject*>(qobject), (QObject *)this); + QCOMPARE(qjsvalue_cast<QWidget*>(qobject), (QWidget *)0); + + QWidget widget; + QJSValue qwidget = eng.newQObject(&widget); + QCOMPARE(qwidget.toQObject(), (QObject *)&widget); + QCOMPARE(qjsvalue_cast<QObject*>(qwidget), (QObject *)&widget); + QCOMPARE(qjsvalue_cast<QWidget*>(qwidget), &widget); + + QPushButton button; + QJSValue qbutton = eng.newQObject(&button); + QCOMPARE(qbutton.toQObject(), (QObject *)&button); + QCOMPARE(qjsvalue_cast<QObject*>(qbutton), (QObject *)&button); + QCOMPARE(qjsvalue_cast<QWidget*>(qbutton), (QWidget *)&button); + QCOMPARE(qjsvalue_cast<QPushButton*>(qbutton), &button); + + // wrapping a QObject* as variant + QJSValue variant = eng.newVariant(qVariantFromValue((QObject*)&button)); + QCOMPARE(variant.toQObject(), (QObject*)&button); + QCOMPARE(qjsvalue_cast<QObject*>(variant), (QObject*)&button); + QCOMPARE(qjsvalue_cast<QWidget*>(variant), (QWidget*)&button); + QCOMPARE(qjsvalue_cast<QPushButton*>(variant), &button); + + QJSValue variant2 = eng.newVariant(qVariantFromValue((QWidget*)&button)); + QCOMPARE(variant2.toQObject(), (QObject*)&button); + QCOMPARE(qjsvalue_cast<QObject*>(variant2), (QObject*)&button); + QCOMPARE(qjsvalue_cast<QWidget*>(variant2), (QWidget*)&button); + QCOMPARE(qjsvalue_cast<QPushButton*>(variant2), &button); + + QJSValue variant3 = eng.newVariant(qVariantFromValue(&button)); + QCOMPARE(variant3.toQObject(), (QObject*)0); + QCOMPARE(qjsvalue_cast<QObject*>(variant3), (QObject*)0); + QCOMPARE(qjsvalue_cast<QWidget*>(variant3), (QWidget*)0); + QCOMPARE(qjsvalue_cast<QPushButton*>(variant3), &button); +} + +void tst_QJSValue::toObject() +{ + QJSEngine eng; + + QJSValue undefined = eng.undefinedValue(); + QCOMPARE(undefined.toObject().isValid(), false); + QVERIFY(undefined.isUndefined()); + + QJSValue null = eng.nullValue(); + QCOMPARE(null.toObject().isValid(), false); + QVERIFY(null.isNull()); + + { + QJSValue falskt = QJSValue(&eng, false); + { + QJSValue tmp = falskt.toObject(); + QCOMPARE(tmp.isObject(), true); + QCOMPARE(tmp.toNumber(), falskt.toNumber()); + } + QVERIFY(falskt.isBool()); + + QJSValue sant = QJSValue(&eng, true); + { + QJSValue tmp = sant.toObject(); + QCOMPARE(tmp.isObject(), true); + QCOMPARE(tmp.toNumber(), sant.toNumber()); + } + QVERIFY(sant.isBool()); + + QJSValue number = QJSValue(&eng, 123.0); + { + QJSValue tmp = number.toObject(); + QCOMPARE(tmp.isObject(), true); + QCOMPARE(tmp.toNumber(), number.toNumber()); + } + QVERIFY(number.isNumber()); + + QJSValue str = QJSValue(&eng, QString("ciao")); + { + QJSValue tmp = str.toObject(); + QCOMPARE(tmp.isObject(), true); + QCOMPARE(tmp.toString(), str.toString()); + } + QVERIFY(str.isString()); + } + + QJSValue object = eng.newObject(); + { + QJSValue tmp = object.toObject(); + QCOMPARE(tmp.isObject(), true); + } + + QJSValue qobject = eng.newQObject(this); + QCOMPARE(qobject.toObject().isValid(), true); + + QJSValue inv; + QCOMPARE(inv.toObject().isValid(), false); + + // V2 constructors: in this case, you have to use QScriptEngine::toObject() + { + QJSValue undefined = QJSValue(QJSValue::UndefinedValue); + QVERIFY(!undefined.toObject().isValid()); + QVERIFY(!eng.toObject(undefined).isValid()); + QVERIFY(undefined.isUndefined()); + + QJSValue null = QJSValue(QJSValue::NullValue); + QVERIFY(!null.toObject().isValid()); + QVERIFY(!eng.toObject(null).isValid()); + QVERIFY(null.isNull()); + + QJSValue falskt = QJSValue(false); + QVERIFY(!falskt.toObject().isValid()); + { + QJSValue tmp = eng.toObject(falskt); + QVERIFY(tmp.isObject()); + QVERIFY(tmp.toBool()); + } + QVERIFY(falskt.isBool()); + + QJSValue sant = QJSValue(true); + QVERIFY(!sant.toObject().isValid()); + { + QJSValue tmp = eng.toObject(sant); + QVERIFY(tmp.isObject()); + QVERIFY(tmp.toBool()); + } + QVERIFY(sant.isBool()); + + QJSValue number = QJSValue(123.0); + QVERIFY(!number.toObject().isValid()); + { + QJSValue tmp = eng.toObject(number); + QVERIFY(tmp.isObject()); + QCOMPARE(tmp.toInt32(), number.toInt32()); + } + QVERIFY(number.isNumber()); + + QJSValue str = QJSValue(QString::fromLatin1("ciao")); + QVERIFY(!str.toObject().isValid()); + { + QJSValue tmp = eng.toObject(str); + QVERIFY(tmp.isObject()); + QCOMPARE(tmp.toString(), QString::fromLatin1("ciao")); + } + QVERIFY(str.isString()); + } +} + +void tst_QJSValue::toDateTime() +{ + QJSEngine eng; + QDateTime dt = eng.evaluate("new Date(0)").toDateTime(); + QVERIFY(dt.isValid()); + QCOMPARE(dt.timeSpec(), Qt::LocalTime); + QCOMPARE(dt.toUTC(), QDateTime(QDate(1970, 1, 1), QTime(0, 0, 0), Qt::UTC)); + + QVERIFY(!eng.evaluate("[]").toDateTime().isValid()); + QVERIFY(!eng.evaluate("{}").toDateTime().isValid()); + QVERIFY(!eng.globalObject().toDateTime().isValid()); + QVERIFY(!QJSValue().toDateTime().isValid()); + QVERIFY(!QJSValue(123).toDateTime().isValid()); + QVERIFY(!QJSValue(false).toDateTime().isValid()); + QVERIFY(!eng.nullValue().toDateTime().isValid()); + QVERIFY(!eng.undefinedValue().toDateTime().isValid()); +} + +void tst_QJSValue::toRegExp() +{ + QJSEngine eng; + { + QRegExp rx = eng.evaluate("/foo/").toRegExp(); + QVERIFY(rx.isValid()); + QCOMPARE(rx.patternSyntax(), QRegExp::RegExp2); + QCOMPARE(rx.pattern(), QString::fromLatin1("foo")); + QCOMPARE(rx.caseSensitivity(), Qt::CaseSensitive); + QVERIFY(!rx.isMinimal()); + } + { + QRegExp rx = eng.evaluate("/bar/gi").toRegExp(); + QVERIFY(rx.isValid()); + QCOMPARE(rx.patternSyntax(), QRegExp::RegExp2); + QCOMPARE(rx.pattern(), QString::fromLatin1("bar")); + QCOMPARE(rx.caseSensitivity(), Qt::CaseInsensitive); + QVERIFY(!rx.isMinimal()); + } + + QVERIFY(eng.evaluate("[]").toRegExp().isEmpty()); + QVERIFY(eng.evaluate("{}").toRegExp().isEmpty()); + QVERIFY(eng.globalObject().toRegExp().isEmpty()); + QVERIFY(QJSValue().toRegExp().isEmpty()); + QVERIFY(QJSValue(123).toRegExp().isEmpty()); + QVERIFY(QJSValue(false).toRegExp().isEmpty()); + QVERIFY(eng.nullValue().toRegExp().isEmpty()); + QVERIFY(eng.undefinedValue().toRegExp().isEmpty()); +} + +void tst_QJSValue::instanceOf_twoEngines() +{ + QJSEngine eng; + QJSValue obj = eng.newObject(); + QJSEngine otherEngine; + QTest::ignoreMessage(QtWarningMsg, "QJSValue::instanceof: cannot perform operation on a value created in a different engine"); + QCOMPARE(obj.instanceOf(otherEngine.globalObject().property("Object")), false); +} + +void tst_QJSValue::instanceOf() +{ + QJSEngine eng; + QJSValue obj = eng.newObject(); + QCOMPARE(obj.instanceOf(eng.evaluate("Object.prototype")), false); + QCOMPARE(obj.instanceOf(eng.evaluate("Array.prototype")), false); + QCOMPARE(obj.instanceOf(eng.evaluate("Function.prototype")), false); + QCOMPARE(obj.instanceOf(eng.evaluate("QObject.prototype")), false); + QCOMPARE(obj.instanceOf(QJSValue(&eng, 123)), false); + QCOMPARE(obj.instanceOf(eng.undefinedValue()), false); + QCOMPARE(obj.instanceOf(eng.nullValue()), false); + QCOMPARE(obj.instanceOf(QJSValue()), false); + + QCOMPARE(obj.instanceOf(eng.evaluate("Object")), true); + QCOMPARE(obj.instanceOf(eng.evaluate("Array")), false); + QCOMPARE(obj.instanceOf(eng.evaluate("Function")), false); + QCOMPARE(obj.instanceOf(eng.evaluate("QObject")), false); + + QJSValue arr = eng.newArray(); + QVERIFY(arr.isArray()); + QCOMPARE(arr.instanceOf(eng.evaluate("Object.prototype")), false); + QCOMPARE(arr.instanceOf(eng.evaluate("Array.prototype")), false); + QCOMPARE(arr.instanceOf(eng.evaluate("Function.prototype")), false); + QCOMPARE(arr.instanceOf(eng.evaluate("QObject.prototype")), false); + QCOMPARE(arr.instanceOf(eng.evaluate("Object")), true); + QCOMPARE(arr.instanceOf(eng.evaluate("Array")), true); + QCOMPARE(arr.instanceOf(eng.evaluate("Function")), false); + QCOMPARE(arr.instanceOf(eng.evaluate("QObject")), false); + + QCOMPARE(QJSValue().instanceOf(arr), false); +} + +void tst_QJSValue::isArray_data() +{ + newEngine(); + + QTest::addColumn<QJSValue>("value"); + QTest::addColumn<bool>("array"); + + QTest::newRow("[]") << engine->evaluate("[]") << true; + QTest::newRow("{}") << engine->evaluate("{}") << false; + QTest::newRow("globalObject") << engine->globalObject() << false; + QTest::newRow("invalid") << QJSValue() << false; + QTest::newRow("number") << QJSValue(123) << false; + QTest::newRow("bool") << QJSValue(false) << false; + QTest::newRow("null") << engine->nullValue() << false; + QTest::newRow("undefined") << engine->undefinedValue() << false; +} + +void tst_QJSValue::isArray() +{ + QFETCH(QJSValue, value); + QFETCH(bool, array); + + QCOMPARE(value.isArray(), array); +} + +void tst_QJSValue::isDate_data() +{ + newEngine(); + + QTest::addColumn<QJSValue>("value"); + QTest::addColumn<bool>("date"); + + QTest::newRow("date") << engine->evaluate("new Date()") << true; + QTest::newRow("[]") << engine->evaluate("[]") << false; + QTest::newRow("{}") << engine->evaluate("{}") << false; + QTest::newRow("globalObject") << engine->globalObject() << false; + QTest::newRow("invalid") << QJSValue() << false; + QTest::newRow("number") << QJSValue(123) << false; + QTest::newRow("bool") << QJSValue(false) << false; + QTest::newRow("null") << engine->nullValue() << false; + QTest::newRow("undefined") << engine->undefinedValue() << false; +} + +void tst_QJSValue::isDate() +{ + QFETCH(QJSValue, value); + QFETCH(bool, date); + + QCOMPARE(value.isDate(), date); +} + +void tst_QJSValue::isError_propertiesOfGlobalObject() +{ + QStringList errors; + errors << "Error" + << "EvalError" + << "RangeError" + << "ReferenceError" + << "SyntaxError" + << "TypeError" + << "URIError"; + QJSEngine eng; + for (int i = 0; i < errors.size(); ++i) { + QJSValue ctor = eng.globalObject().property(errors.at(i)); + QVERIFY(ctor.isFunction()); + QVERIFY(ctor.property("prototype").isError()); + } +} + +void tst_QJSValue::isError_data() +{ + newEngine(); + + QTest::addColumn<QJSValue>("value"); + QTest::addColumn<bool>("error"); + + QTest::newRow("syntax error") << engine->evaluate("%fsdg's") << true; + QTest::newRow("[]") << engine->evaluate("[]") << false; + QTest::newRow("{}") << engine->evaluate("{}") << false; + QTest::newRow("globalObject") << engine->globalObject() << false; + QTest::newRow("invalid") << QJSValue() << false; + QTest::newRow("number") << QJSValue(123) << false; + QTest::newRow("bool") << QJSValue(false) << false; + QTest::newRow("null") << engine->nullValue() << false; + QTest::newRow("undefined") << engine->undefinedValue() << false; + QTest::newRow("newObject") << engine->newObject() << false; + QTest::newRow("new Object") << engine->evaluate("new Object()") << false; +} + +void tst_QJSValue::isError() +{ + QFETCH(QJSValue, value); + QFETCH(bool, error); + + QCOMPARE(value.isError(), error); +} + +void tst_QJSValue::isRegExp_data() +{ + newEngine(); + + QTest::addColumn<QJSValue>("value"); + QTest::addColumn<bool>("regexp"); + + QTest::newRow("/foo/") << engine->evaluate("/foo/") << true; + QTest::newRow("[]") << engine->evaluate("[]") << false; + QTest::newRow("{}") << engine->evaluate("{}") << false; + QTest::newRow("globalObject") << engine->globalObject() << false; + QTest::newRow("invalid") << QJSValue() << false; + QTest::newRow("number") << QJSValue(123) << false; + QTest::newRow("bool") << QJSValue(false) << false; + QTest::newRow("null") << engine->nullValue() << false; + QTest::newRow("undefined") << engine->undefinedValue() << false; +} + +void tst_QJSValue::isRegExp() +{ + QFETCH(QJSValue, value); + QFETCH(bool, regexp); + + QCOMPARE(value.isRegExp(), regexp); +} + +#if 0 // FIXME: No c-style callbacks currently +static QJSValue getter(QScriptContext *ctx, QScriptEngine *) +{ + return ctx->thisObject().property("x"); +} + +static QJSValue setter(QScriptContext *ctx, QScriptEngine *) +{ + ctx->thisObject().setProperty("x", ctx->argument(0)); + return ctx->argument(0); +} + +static QJSValue getterSetter(QScriptContext *ctx, QScriptEngine *) +{ + if (ctx->argumentCount() > 0) + ctx->thisObject().setProperty("x", ctx->argument(0)); + return ctx->thisObject().property("x"); +} + +static QJSValue getterSetterThrowingError(QScriptContext *ctx, QScriptEngine *) +{ + if (ctx->argumentCount() > 0) + return ctx->throwError("set foo"); + else + return ctx->throwError("get foo"); +} + +static QJSValue getSet__proto__(QScriptContext *ctx, QScriptEngine *) +{ + if (ctx->argumentCount() > 0) + ctx->callee().setProperty("value", ctx->argument(0)); + return ctx->callee().property("value"); +} +#endif + +void tst_QJSValue::getSetProperty_HooliganTask162051() +{ + QJSEngine eng; + // task 162051 -- detecting whether the property is an array index or not + QVERIFY(eng.evaluate("a = []; a['00'] = 123; a['00']").strictlyEquals(QJSValue(&eng, 123))); + QVERIFY(eng.evaluate("a.length").strictlyEquals(QJSValue(&eng, 0))); + QVERIFY(eng.evaluate("a.hasOwnProperty('00')").strictlyEquals(QJSValue(&eng, true))); + QVERIFY(eng.evaluate("a.hasOwnProperty('0')").strictlyEquals(QJSValue(&eng, false))); + QVERIFY(eng.evaluate("a[0]").isUndefined()); + QVERIFY(eng.evaluate("a[0.5] = 456; a[0.5]").strictlyEquals(QJSValue(&eng, 456))); + QVERIFY(eng.evaluate("a.length").strictlyEquals(QJSValue(&eng, 0))); + QVERIFY(eng.evaluate("a.hasOwnProperty('0.5')").strictlyEquals(QJSValue(&eng, true))); + QVERIFY(eng.evaluate("a[0]").isUndefined()); + QVERIFY(eng.evaluate("a[0] = 789; a[0]").strictlyEquals(QJSValue(&eng, 789))); + QVERIFY(eng.evaluate("a.length").strictlyEquals(QJSValue(&eng, 1))); +} + +void tst_QJSValue::getSetProperty_HooliganTask183072() +{ + QJSEngine eng; + // task 183072 -- 0x800000000 is not an array index + eng.evaluate("a = []; a[0x800000000] = 123"); + QVERIFY(eng.evaluate("a.length").strictlyEquals(QJSValue(&eng, 0))); + QVERIFY(eng.evaluate("a[0]").isUndefined()); + QVERIFY(eng.evaluate("a[0x800000000]").strictlyEquals(QJSValue(&eng, 123))); +} + +void tst_QJSValue::getSetProperty_propertyRemoval() +{ + // test property removal (setProperty(QJSValue())) + QJSEngine eng; + QJSValue object = eng.newObject(); + QJSValue str = QJSValue(&eng, QLatin1String("bar")); + QJSValue num = QJSValue(&eng, 123.0); + + object.setProperty("foo", num); + QCOMPARE(object.property("foo").strictlyEquals(num), true); + object.setProperty("bar", str); + QCOMPARE(object.property("bar").strictlyEquals(str), true); + object.setProperty("foo", QJSValue()); + QCOMPARE(object.property("foo").isValid(), false); + QCOMPARE(object.property("bar").strictlyEquals(str), true); + object.setProperty("foo", num); + QCOMPARE(object.property("foo").strictlyEquals(num), true); + QCOMPARE(object.property("bar").strictlyEquals(str), true); + object.setProperty("bar", QJSValue()); + QCOMPARE(object.property("bar").isValid(), false); + QCOMPARE(object.property("foo").strictlyEquals(num), true); + object.setProperty("foo", QJSValue()); + object.setProperty("foo", QJSValue()); + + eng.globalObject().setProperty("object3", object); + QCOMPARE(eng.evaluate("object3.hasOwnProperty('foo')") + .strictlyEquals(QJSValue(&eng, false)), true); + object.setProperty("foo", num); + QCOMPARE(eng.evaluate("object3.hasOwnProperty('foo')") + .strictlyEquals(QJSValue(&eng, true)), true); + eng.globalObject().setProperty("object3", QJSValue()); + QCOMPARE(eng.evaluate("this.hasOwnProperty('object3')") + .strictlyEquals(QJSValue(&eng, false)), true); +} + +void tst_QJSValue::getSetProperty_resolveMode() +{ + // test ResolveMode + QJSEngine eng; + QJSValue object = eng.newObject(); + QJSValue prototype = eng.newObject(); + object.setPrototype(prototype); + QJSValue num2 = QJSValue(&eng, 456.0); + prototype.setProperty("propertyInPrototype", num2); + // default is ResolvePrototype + QCOMPARE(object.property("propertyInPrototype") + .strictlyEquals(num2), true); +#if 0 // FIXME: ResolveFlags removed from API + QCOMPARE(object.property("propertyInPrototype", QJSValue::ResolvePrototype) + .strictlyEquals(num2), true); + QCOMPARE(object.property("propertyInPrototype", QJSValue::ResolveLocal) + .isValid(), false); + QCOMPARE(object.property("propertyInPrototype", QJSValue::ResolveScope) + .strictlyEquals(num2), false); + QCOMPARE(object.property("propertyInPrototype", QJSValue::ResolveFull) + .strictlyEquals(num2), true); +#endif +} + +void tst_QJSValue::getSetProperty_twoEngines() +{ + QJSEngine engine; + QJSValue object = engine.newObject(); + + QJSEngine otherEngine; + QJSValue otherNum = QJSValue(&otherEngine, 123); + QTest::ignoreMessage(QtWarningMsg, "QJSValue::setProperty(oof) failed: cannot set value created in a different engine"); + object.setProperty("oof", otherNum); + QCOMPARE(object.property("oof").isValid(), false); +} + + +void tst_QJSValue::getSetProperty_gettersAndSetters() +{ +#if 0 // FIXME: No setters/getters right now + QScriptEngine eng; + QJSValue str = QJSValue(&eng, QLatin1String("bar")); + QJSValue num = QJSValue(&eng, 123.0); + QJSValue object = eng.newObject(); + for (int x = 0; x < 2; ++x) { + object.setProperty("foo", QJSValue()); + // getter() returns this.x + object.setProperty("foo", eng.newFunction(getter), + QJSValue::PropertyGetter | QJSValue::UserRange); + QCOMPARE(object.propertyFlags("foo") & ~QJSValue::UserRange, + QJSValue::PropertyGetter ); + + QEXPECT_FAIL("", "QTBUG-17615: User-range flags are not retained for getter/setter properties", Continue); + QCOMPARE(object.propertyFlags("foo"), + QJSValue::PropertyGetter | QJSValue::UserRange); + object.setProperty("x", num); + QCOMPARE(object.property("foo").strictlyEquals(num), true); + + // setter() sets this.x + object.setProperty("foo", eng.newFunction(setter), + QJSValue::PropertySetter); + QCOMPARE(object.propertyFlags("foo") & ~QJSValue::UserRange, + QJSValue::PropertySetter | QJSValue::PropertyGetter); + + QCOMPARE(object.propertyFlags("foo"), + QJSValue::PropertySetter | QJSValue::PropertyGetter); + object.setProperty("foo", str); + QCOMPARE(object.property("x").strictlyEquals(str), true); + QCOMPARE(object.property("foo").strictlyEquals(str), true); + + // kill the getter + object.setProperty("foo", QJSValue(), QJSValue::PropertyGetter); + QVERIFY(!(object.propertyFlags("foo") & QJSValue::PropertyGetter)); + QVERIFY(object.propertyFlags("foo") & QJSValue::PropertySetter); + QCOMPARE(object.property("foo").isUndefined(), true); + + // setter should still work + object.setProperty("foo", num); + QCOMPARE(object.property("x").strictlyEquals(num), true); + + // kill the setter too + object.setProperty("foo", QJSValue(), QJSValue::PropertySetter); + QVERIFY(!(object.propertyFlags("foo") & QJSValue::PropertySetter)); + // now foo is just a regular property + object.setProperty("foo", str); + QCOMPARE(object.property("x").strictlyEquals(num), true); + QCOMPARE(object.property("foo").strictlyEquals(str), true); + } + + for (int x = 0; x < 2; ++x) { + object.setProperty("foo", QJSValue()); + // setter() sets this.x + object.setProperty("foo", eng.newFunction(setter), QJSValue::PropertySetter); + object.setProperty("foo", str); + QCOMPARE(object.property("x").strictlyEquals(str), true); + QCOMPARE(object.property("foo").isUndefined(), true); + + // getter() returns this.x + object.setProperty("foo", eng.newFunction(getter), QJSValue::PropertyGetter); + object.setProperty("x", num); + QCOMPARE(object.property("foo").strictlyEquals(num), true); + + // kill the setter + object.setProperty("foo", QJSValue(), QJSValue::PropertySetter); + object.setProperty("foo", str); + + // getter should still work + QCOMPARE(object.property("foo").strictlyEquals(num), true); + + // kill the getter too + object.setProperty("foo", QJSValue(), QJSValue::PropertyGetter); + // now foo is just a regular property + object.setProperty("foo", str); + QCOMPARE(object.property("x").strictlyEquals(num), true); + QCOMPARE(object.property("foo").strictlyEquals(str), true); + } + + // use a single function as both getter and setter + object.setProperty("foo", QJSValue()); + object.setProperty("foo", eng.newFunction(getterSetter), + QJSValue::PropertyGetter | QJSValue::PropertySetter); + QCOMPARE(object.propertyFlags("foo"), + QJSValue::PropertyGetter | QJSValue::PropertySetter); + object.setProperty("x", num); + QCOMPARE(object.property("foo").strictlyEquals(num), true); + + // killing the getter will preserve the setter, even though they are the same function + object.setProperty("foo", QJSValue(), QJSValue::PropertyGetter); + QVERIFY(object.propertyFlags("foo") & QJSValue::PropertySetter); + QCOMPARE(object.property("foo").isUndefined(), true); +#endif +} + +void tst_QJSValue::getSetProperty_gettersAndSettersThrowErrorNative() +{ +#if 0 // FIXME: No setters/getters right now + // getter/setter that throws an error + QScriptEngine eng; + QJSValue str = QJSValue(&eng, "bar"); + QJSValue object = eng.newObject(); + + object.setProperty("foo", eng.newFunction(getterSetterThrowingError), + QJSValue::PropertyGetter | QJSValue::PropertySetter); + QVERIFY(!eng.hasUncaughtException()); + QJSValue ret = object.property("foo"); + QVERIFY(ret.isError()); + QVERIFY(eng.hasUncaughtException()); + QVERIFY(ret.strictlyEquals(eng.uncaughtException())); + QCOMPARE(ret.toString(), QLatin1String("Error: get foo")); + eng.evaluate("Object"); // clear exception state... + QVERIFY(!eng.hasUncaughtException()); + object.setProperty("foo", str); + QVERIFY(eng.hasUncaughtException()); + QCOMPARE(eng.uncaughtException().toString(), QLatin1String("Error: set foo")); +#endif +} + +void tst_QJSValue::getSetProperty_gettersAndSettersThrowErrorJS() +{ + // getter/setter that throws an error (from js function) + QJSEngine eng; + QJSValue str = QJSValue(&eng, QLatin1String("bar")); + + eng.evaluate("o = new Object; " + "o.__defineGetter__('foo', function() { throw new Error('get foo') }); " + "o.__defineSetter__('foo', function() { throw new Error('set foo') }); "); + QJSValue object = eng.evaluate("o"); + QVERIFY(!eng.hasUncaughtException()); + QJSValue ret = object.property("foo"); + QVERIFY(ret.isError()); + QVERIFY(eng.hasUncaughtException()); + QVERIFY(ret.strictlyEquals(eng.uncaughtException())); + QCOMPARE(ret.toString(), QLatin1String("Error: get foo")); + eng.evaluate("Object"); // clear exception state... + QVERIFY(!eng.hasUncaughtException()); + object.setProperty("foo", str); + QVERIFY(eng.hasUncaughtException()); + QCOMPARE(eng.uncaughtException().toString(), QLatin1String("Error: set foo")); +} + +void tst_QJSValue::getSetProperty_gettersAndSettersOnNative() +{ +#if 0 // FIXME: No c-style functions right now + // attempt to install getter+setter on built-in (native) property + QScriptEngine eng; + QJSValue object = eng.newObject(); + QVERIFY(object.property("__proto__").strictlyEquals(object.prototype())); + + QJSValue fun = eng.newFunction(getSet__proto__); + fun.setProperty("value", QJSValue(&eng, "boo")); +/* QTest::ignoreMessage(QtWarningMsg, "QJSValue::setProperty() failed: " + "cannot set getter or setter of native property " + "`__proto__'");*/ + object.setProperty("__proto__", fun, + QJSValue::PropertyGetter | QJSValue::PropertySetter + | QJSValue::UserRange); + QVERIFY(object.property("__proto__").strictlyEquals(object.prototype())); + + object.setProperty("__proto__", QJSValue(), + QJSValue::PropertyGetter | QJSValue::PropertySetter); + QVERIFY(object.property("__proto__").strictlyEquals(object.prototype())); +#endif +} + +void tst_QJSValue::getSetProperty_gettersAndSettersOnGlobalObject() +{ +#if 0 // FIXME: No c-style functions right now + // global property that's a getter+setter + QScriptEngine eng; + eng.globalObject().setProperty("globalGetterSetterProperty", eng.newFunction(getterSetter), + QJSValue::PropertyGetter | QJSValue::PropertySetter); + eng.evaluate("globalGetterSetterProperty = 123"); + { + QJSValue ret = eng.evaluate("globalGetterSetterProperty"); + QVERIFY(ret.isNumber()); + QVERIFY(ret.strictlyEquals(QJSValue(&eng, 123))); + } + QCOMPARE(eng.evaluate("typeof globalGetterSetterProperty").toString(), + QString::fromLatin1("number")); + { + QJSValue ret = eng.evaluate("this.globalGetterSetterProperty()"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: Property 'globalGetterSetterProperty' of object #<Object> is not a function")); + } + { + QJSValue ret = eng.evaluate("new this.globalGetterSetterProperty()"); + QVERIFY(ret.isError()); + QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: number is not a function")); + } +#endif +} + +void tst_QJSValue::getSetProperty_gettersAndSettersChange() +{ +#if 0 // FIXME: No setters/getters API right now + // "upgrading" an existing property to become a getter+setter + QScriptEngine eng; + QJSValue object = eng.newObject(); + QJSValue num(&eng, 123); + object.setProperty("foo", num); + object.setProperty("foo", eng.newFunction(getterSetter), + QJSValue::PropertyGetter | QJSValue::PropertySetter); + QVERIFY(!object.property("x").isValid()); + object.setProperty("foo", num); + QVERIFY(object.property("x").equals(num)); + + eng.globalObject().setProperty("object", object); + QJSValue res = eng.evaluate("object.x = 89; var a = object.foo; object.foo = 65; a"); + QCOMPARE(res.toInt32(), 89); + QCOMPARE(object.property("x").toInt32(), 65); + QCOMPARE(object.property("foo").toInt32(), 65); +#endif +} + +void tst_QJSValue::getSetProperty_array() +{ + QJSEngine eng; + QJSValue str = QJSValue(&eng, QLatin1String("bar")); + QJSValue num = QJSValue(&eng, 123.0); + QJSValue array = eng.newArray(); + + QVERIFY(array.isArray()); + array.setProperty(0, num); + QCOMPARE(array.property(0).toNumber(), num.toNumber()); + QCOMPARE(array.property("0").toNumber(), num.toNumber()); + QCOMPARE(array.property("length").toUInt32(), quint32(1)); + array.setProperty(1, str); + QCOMPARE(array.property(1).toString(), str.toString()); + QCOMPARE(array.property("1").toString(), str.toString()); + QCOMPARE(array.property("length").toUInt32(), quint32(2)); + array.setProperty("length", QJSValue(&eng, 1)); + QCOMPARE(array.property("length").toUInt32(), quint32(1)); + QCOMPARE(array.property(1).isValid(), false); +} + +void tst_QJSValue::getSetProperty_gettersAndSettersStupid() +{ +#if 0 // FIXME: No setters/getters API right now + //removing unexisting Setter or Getter should not crash. + QScriptEngine eng; + QJSValue num = QJSValue(&eng, 123.0); + + { + QJSValue object = eng.newObject(); + object.setProperty("foo", QJSValue(), QJSValue::PropertyGetter); + QVERIFY(!object.property("foo").isValid()); + object.setProperty("foo", num); + QCOMPARE(object.property("foo").strictlyEquals(num), true); + } + + { + QJSValue object = eng.newObject(); + object.setProperty("foo", QJSValue(), QJSValue::PropertySetter); + QVERIFY(!object.property("foo").isValid()); + object.setProperty("foo", num); + QCOMPARE(object.property("foo").strictlyEquals(num), true); + } + + { + QJSValue object = eng.globalObject(); + object.setProperty("foo", QJSValue(), QJSValue::PropertySetter); + object.setProperty("foo", QJSValue(), QJSValue::PropertyGetter); + QVERIFY(!object.property("foo").isValid()); + object.setProperty("foo", num); + QCOMPARE(object.property("foo").strictlyEquals(num), true); + } +#endif +} + +void tst_QJSValue::getSetProperty() +{ + QJSEngine eng; + + QJSValue object = eng.newObject(); + + QJSValue str = QJSValue(&eng, QLatin1String("bar")); + object.setProperty("foo", str); + QCOMPARE(object.property("foo").toString(), str.toString()); + + QJSValue num = QJSValue(&eng, 123.0); + object.setProperty("baz", num); + QCOMPARE(object.property("baz").toNumber(), num.toNumber()); + + QJSValue strstr = QJSValue("bar"); + QCOMPARE(strstr.engine(), (QJSEngine *)0); + object.setProperty("foo", strstr); + QCOMPARE(object.property("foo").toString(), strstr.toString()); + QCOMPARE(strstr.engine(), &eng); // the value has been bound to the engine + + QJSValue numnum = QJSValue(123.0); + object.setProperty("baz", numnum); + QCOMPARE(object.property("baz").toNumber(), numnum.toNumber()); + + QJSValue inv; + inv.setProperty("foo", num); + QCOMPARE(inv.property("foo").isValid(), false); + + eng.globalObject().setProperty("object", object); + +#if 0 // FIXME: no setProperty API with flags + // ReadOnly + object.setProperty("readOnlyProperty", num, QJSValue::ReadOnly); + QCOMPARE(object.propertyFlags("readOnlyProperty"), QJSValue::ReadOnly); + QCOMPARE(object.property("readOnlyProperty").strictlyEquals(num), true); + eng.evaluate("object.readOnlyProperty = !object.readOnlyProperty"); + QCOMPARE(object.property("readOnlyProperty").strictlyEquals(num), true); + // should still be part of enumeration + { + QJSValue ret = eng.evaluate( + "found = false;" + "for (var p in object) {" + " if (p == 'readOnlyProperty') {" + " found = true; break;" + " }" + "} found"); + QCOMPARE(ret.strictlyEquals(QJSValue(&eng, true)), true); + } + // should still be deletable + { + QJSValue ret = eng.evaluate("delete object.readOnlyProperty"); + QCOMPARE(ret.strictlyEquals(QJSValue(&eng, true)), true); + QCOMPARE(object.property("readOnlyProperty").isValid(), false); + } + + // Undeletable + object.setProperty("undeletableProperty", num, QJSValue::Undeletable); + QCOMPARE(object.propertyFlags("undeletableProperty"), QJSValue::Undeletable); + QCOMPARE(object.property("undeletableProperty").strictlyEquals(num), true); + { + QJSValue ret = eng.evaluate("delete object.undeletableProperty"); + QCOMPARE(ret.strictlyEquals(QJSValue(&eng, true)), false); + QCOMPARE(object.property("undeletableProperty").strictlyEquals(num), true); + } + // should still be writable + eng.evaluate("object.undeletableProperty = object.undeletableProperty + 1"); + QCOMPARE(object.property("undeletableProperty").toNumber(), num.toNumber() + 1); + // should still be part of enumeration + { + QJSValue ret = eng.evaluate( + "found = false;" + "for (var p in object) {" + " if (p == 'undeletableProperty') {" + " found = true; break;" + " }" + "} found"); + QCOMPARE(ret.strictlyEquals(QJSValue(&eng, true)), true); + } + // should still be deletable from C++ + object.setProperty("undeletableProperty", QJSValue()); + QEXPECT_FAIL("", "QTBUG-17617: With JSC-based back-end, undeletable properties can't be deleted from C++", Continue); + QVERIFY(!object.property("undeletableProperty").isValid()); + QEXPECT_FAIL("", "QTBUG-17617: With JSC-based back-end, undeletable properties can't be deleted from C++", Continue); + QCOMPARE(object.propertyFlags("undeletableProperty"), 0); + + // SkipInEnumeration + object.setProperty("dontEnumProperty", num, QJSValue::SkipInEnumeration); + QCOMPARE(object.propertyFlags("dontEnumProperty"), QJSValue::SkipInEnumeration); + QCOMPARE(object.property("dontEnumProperty").strictlyEquals(num), true); + // should not be part of enumeration + { + QJSValue ret = eng.evaluate( + "found = false;" + "for (var p in object) {" + " if (p == 'dontEnumProperty') {" + " found = true; break;" + " }" + "} found"); + QCOMPARE(ret.strictlyEquals(QJSValue(&eng, false)), true); + } + // should still be writable + eng.evaluate("object.dontEnumProperty = object.dontEnumProperty + 1"); + QCOMPARE(object.property("dontEnumProperty").toNumber(), num.toNumber() + 1); + // should still be deletable + { + QJSValue ret = eng.evaluate("delete object.dontEnumProperty"); + QCOMPARE(ret.strictlyEquals(QJSValue(&eng, true)), true); + QCOMPARE(object.property("dontEnumProperty").isValid(), false); + } + + // change flags + object.setProperty("flagProperty", str); + QCOMPARE(object.propertyFlags("flagProperty"), static_cast<QJSValue::PropertyFlags>(0)); + + QEXPECT_FAIL("", "FIXME: v8 does not support changing flags of existing properties", Continue); + //v8::i::JSObject::SetProperty(LookupResult* result, ... ) does not take in account the attributes + // if the result->isFound() + object.setProperty("flagProperty", str, QJSValue::ReadOnly); + QCOMPARE(object.propertyFlags("flagProperty"), QJSValue::ReadOnly); + + QEXPECT_FAIL("", "FIXME: v8 does not support changing flags of existing properties", Continue); + object.setProperty("flagProperty", str, object.propertyFlags("flagProperty") | QJSValue::SkipInEnumeration); + QCOMPARE(object.propertyFlags("flagProperty"), QJSValue::ReadOnly | QJSValue::SkipInEnumeration); + + QEXPECT_FAIL("", "FIXME: v8 does not support changing flags of existing properties", Continue); + object.setProperty("flagProperty", str, QJSValue::KeepExistingFlags); + QCOMPARE(object.propertyFlags("flagProperty"), QJSValue::ReadOnly | QJSValue::SkipInEnumeration); + + QEXPECT_FAIL("", "FIXME: v8 does not support UserRange", Continue); + object.setProperty("flagProperty", str, QJSValue::UserRange); + QCOMPARE(object.propertyFlags("flagProperty"), QJSValue::UserRange); + + // flags of property in the prototype + { + QJSValue object2 = eng.newObject(); + object2.setPrototype(object); + QCOMPARE(object2.propertyFlags("flagProperty", QJSValue::ResolveLocal), 0); + QEXPECT_FAIL("", "FIXME: v8 does not support UserRange", Continue); + QCOMPARE(object2.propertyFlags("flagProperty"), QJSValue::UserRange); + } + + // using interned strings + QScriptString foo = eng.toStringHandle("foo"); + + object.setProperty(foo, QJSValue()); + QVERIFY(!object.property(foo).isValid()); + + object.setProperty(foo, num); + QVERIFY(object.property(foo).strictlyEquals(num)); + QVERIFY(object.property("foo").strictlyEquals(num)); + QVERIFY(object.propertyFlags(foo) == 0); +#endif + + // Setting index property on non-Array + object.setProperty(13, num); + QVERIFY(object.property(13).equals(num)); +} + +void tst_QJSValue::arrayElementGetterSetter() +{ +#if 0 // FIXME: No c-style functions + QScriptEngine eng; + QJSValue obj = eng.newObject(); + obj.setProperty(1, eng.newFunction(getterSetter), QJSValue::PropertyGetter|QJSValue::PropertySetter); + { + QJSValue num(123); + obj.setProperty("x", num); + QJSValue ret = obj.property(1); + QVERIFY(ret.isValid()); + QVERIFY(ret.equals(num)); + } + { + QJSValue num(456); + obj.setProperty(1, num); + QJSValue ret = obj.property(1); + QVERIFY(ret.isValid()); + QVERIFY(ret.equals(num)); + QVERIFY(ret.equals(obj.property("1"))); + } + QCOMPARE(obj.propertyFlags("1"), QJSValue::PropertyGetter|QJSValue::PropertySetter); + + obj.setProperty(1, QJSValue(), QJSValue::PropertyGetter|QJSValue::PropertySetter); + QVERIFY(obj.propertyFlags("1") == 0); +#endif +} + +void tst_QJSValue::getSetPrototype_cyclicPrototype() +{ + QJSEngine eng; + QJSValue prototype = eng.newObject(); + QJSValue object = eng.newObject(); + object.setPrototype(prototype); + + QJSValue previousPrototype = prototype.prototype(); + QTest::ignoreMessage(QtWarningMsg, "QJSValue::setPrototype() failed: cyclic prototype value"); + prototype.setPrototype(prototype); + QCOMPARE(prototype.prototype().strictlyEquals(previousPrototype), true); + + object.setPrototype(prototype); + QTest::ignoreMessage(QtWarningMsg, "QJSValue::setPrototype() failed: cyclic prototype value"); + prototype.setPrototype(object); + QCOMPARE(prototype.prototype().strictlyEquals(previousPrototype), true); + +} + +void tst_QJSValue::getSetPrototype_evalCyclicPrototype() +{ + QJSEngine eng; + QJSValue ret = eng.evaluate("o = { }; p = { }; o.__proto__ = p; p.__proto__ = o"); + QCOMPARE(eng.hasUncaughtException(), true); + QVERIFY(ret.strictlyEquals(eng.uncaughtException())); + QCOMPARE(ret.isError(), true); + QCOMPARE(ret.toString(), QLatin1String("Error: Cyclic __proto__ value")); +} + +void tst_QJSValue::getSetPrototype_eval() +{ + QJSEngine eng; + QJSValue ret = eng.evaluate("p = { }; p.__proto__ = { }"); + QCOMPARE(eng.hasUncaughtException(), false); + QCOMPARE(ret.isError(), false); +} + +void tst_QJSValue::getSetPrototype_invalidPrototype() +{ + QJSEngine eng; + QJSValue inv; + QJSValue object = eng.newObject(); + QJSValue proto = object.prototype(); + QVERIFY(object.prototype().strictlyEquals(proto)); + inv.setPrototype(object); + QCOMPARE(inv.prototype().isValid(), false); + object.setPrototype(inv); + QVERIFY(object.prototype().strictlyEquals(proto)); +} + +void tst_QJSValue::getSetPrototype_twoEngines() +{ + QJSEngine eng; + QJSValue prototype = eng.newObject(); + QJSValue object = eng.newObject(); + object.setPrototype(prototype); + QJSEngine otherEngine; + QJSValue newPrototype = otherEngine.newObject(); + QTest::ignoreMessage(QtWarningMsg, "QJSValue::setPrototype() failed: cannot set a prototype created in a different engine"); + object.setPrototype(newPrototype); + QCOMPARE(object.prototype().strictlyEquals(prototype), true); + +} + +void tst_QJSValue::getSetPrototype_null() +{ + QJSEngine eng; + QJSValue object = eng.newObject(); + object.setPrototype(QJSValue(QJSValue::NullValue)); + QVERIFY(object.prototype().isNull()); + + QJSValue newProto = eng.newObject(); + object.setPrototype(newProto); + QVERIFY(object.prototype().equals(newProto)); + + object.setPrototype(QJSValue(&eng, QJSValue::NullValue)); + QVERIFY(object.prototype().isNull()); +} + +void tst_QJSValue::getSetPrototype_notObjectOrNull() +{ + QJSEngine eng; + QJSValue object = eng.newObject(); + QJSValue originalProto = object.prototype(); + + // bool + object.setPrototype(true); + QVERIFY(object.prototype().equals(originalProto)); + object.setPrototype(QJSValue(&eng, true)); + QVERIFY(object.prototype().equals(originalProto)); + + // number + object.setPrototype(123); + QVERIFY(object.prototype().equals(originalProto)); + object.setPrototype(QJSValue(&eng, 123)); + QVERIFY(object.prototype().equals(originalProto)); + + // string + object.setPrototype("foo"); + QVERIFY(object.prototype().equals(originalProto)); + object.setPrototype(QJSValue(&eng, QLatin1String("foo"))); + QVERIFY(object.prototype().equals(originalProto)); + + // undefined + object.setPrototype(QJSValue(QJSValue::UndefinedValue)); + QVERIFY(object.prototype().equals(originalProto)); + object.setPrototype(QJSValue(&eng, QJSValue::UndefinedValue)); + QVERIFY(object.prototype().equals(originalProto)); +} + +void tst_QJSValue::getSetPrototype() +{ + QJSEngine eng; + QJSValue prototype = eng.newObject(); + QJSValue object = eng.newObject(); + object.setPrototype(prototype); + QCOMPARE(object.prototype().strictlyEquals(prototype), true); +} + +void tst_QJSValue::getSetScope() +{ +#if 0 // FIXME: No QJSValue::scope + QScriptEngine eng; + + QJSValue object = eng.newObject(); + QCOMPARE(object.scope().isValid(), false); + + QJSValue object2 = eng.newObject(); + object2.setScope(object); + + QEXPECT_FAIL("", "FIXME: scope not implemented yet", Abort); + QCOMPARE(object2.scope().strictlyEquals(object), true); + + object.setProperty("foo", 123); + QVERIFY(!object2.property("foo").isValid()); + { + QJSValue ret = object2.property("foo", QJSValue::ResolveScope); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toInt32(), 123); + } + + QJSValue inv; + inv.setScope(object); + QCOMPARE(inv.scope().isValid(), false); + + QScriptEngine otherEngine; + QJSValue object3 = otherEngine.newObject(); + QTest::ignoreMessage(QtWarningMsg, "QJSValue::setScope() failed: cannot set a scope object created in a different engine"); + object2.setScope(object3); + QCOMPARE(object2.scope().strictlyEquals(object), true); + + object2.setScope(QJSValue()); + QVERIFY(!object2.scope().isValid()); +#endif +} + +void tst_QJSValue::getSetData_objects_data() +{ +#if 0 // FIXME: no setData/data API + newEngine(); + + QTest::addColumn<QJSValue>("object"); + + QTest::newRow("object from evaluate") << engine->evaluate("new Object()"); + QTest::newRow("object from engine") << engine->newObject(); + QTest::newRow("Array") << engine->newArray(); + QTest::newRow("Date") << engine->newDate(12324); + QTest::newRow("QObject") << engine->newQObject(this); + QTest::newRow("RegExp") << engine->newRegExp(QRegExp()); +#endif +} + +void tst_QJSValue::getSetData_objects() +{ +#if 0 // FIXME: no setData/data API + QFETCH(QJSValue, object); + + QVERIFY(!object.data().isValid()); + QJSValue v1(true); + object.setData(v1); + QVERIFY(object.data().strictlyEquals(v1)); + QJSValue v2(123); + object.setData(v2); + QVERIFY(object.data().strictlyEquals(v2)); + QJSValue v3 = engine->newObject(); + object.setData(v3); + QVERIFY(object.data().strictlyEquals(v3)); + object.setData(QJSValue()); + QVERIFY(!object.data().isValid()); +#endif +} + +void tst_QJSValue::getSetData_nonObjects_data() +{ +#if 0 // FIXME: no setData/data API + newEngine(); + + QTest::addColumn<QJSValue>("value"); + + QTest::newRow("undefined (bound)") << engine->undefinedValue(); + QTest::newRow("null (bound)") << engine->nullValue(); + QTest::newRow("string (bound)") << QJSValue(engine, "Pong"); + QTest::newRow("bool (bound)") << QJSValue(engine, false); + + QTest::newRow("undefined") << QJSValue(QJSValue::UndefinedValue); + QTest::newRow("null") << QJSValue(QJSValue::NullValue); + QTest::newRow("string") << QJSValue("Pong"); + QTest::newRow("bool") << QJSValue(true); +#endif +} + +void tst_QJSValue::getSetData_nonObjects() +{ +#if 0 // FIXME: no setData/data API + QFETCH(QJSValue, value); + + QVERIFY(!value.data().isValid()); + QJSValue v1(true); + value.setData(v1); + QVERIFY(!value.data().isValid()); + QJSValue v2(123); + value.setData(v2); + QVERIFY(!value.data().isValid()); + QJSValue v3 = engine->newObject(); + value.setData(v3); + QVERIFY(!value.data().isValid()); + value.setData(QJSValue()); + QVERIFY(!value.data().isValid()); +#endif +} + +void tst_QJSValue::setData_QTBUG15144() +{ +#if 0 // FIXME: no setData/data API + QScriptEngine eng; + QJSValue obj = eng.newObject(); + for (int i = 0; i < 10000; ++i) { + // Create an object with property 'fooN' on it, and immediately kill + // the reference to the object so it and the property name become garbage. + eng.evaluate(QString::fromLatin1("o = {}; o.foo%0 = 10; o = null;").arg(i)); + // Setting the data will cause a JS string to be allocated, which could + // trigger a GC. This should not cause a crash. + obj.setData("foodfight"); + } +#endif +} + +#if 0 // FIXME: no QScriptClass +class TestScriptClass : public QScriptClass +{ +public: + TestScriptClass(QScriptEngine *engine) : QScriptClass(engine) {} +}; + +void tst_QJSValue::getSetScriptClass_emptyClass_data() +{ + newEngine(); + QTest::addColumn<QJSValue>("value"); + + QTest::newRow("invalid") << QJSValue(); + QTest::newRow("number") << QJSValue(123); + QTest::newRow("string") << QJSValue("pong"); + QTest::newRow("bool") << QJSValue(false); + QTest::newRow("null") << QJSValue(QJSValue::NullValue); + QTest::newRow("undefined") << QJSValue(QJSValue::UndefinedValue); + + QTest::newRow("number") << QJSValue(engine, 123); + QTest::newRow("string") << QJSValue(engine, "pong"); + QTest::newRow("bool") << QJSValue(engine, true); + QTest::newRow("null") << QJSValue(engine->nullValue()); + QTest::newRow("undefined") << QJSValue(engine->undefinedValue()); + QTest::newRow("object") << QJSValue(engine->newObject()); + QTest::newRow("date") << QJSValue(engine->evaluate("new Date()")); + QTest::newRow("qobject") << QJSValue(engine->newQObject(this)); +} + +void tst_QJSValue::getSetScriptClass_emptyClass() +{ + QFETCH(QJSValue, value); + QCOMPARE(value.scriptClass(), (QScriptClass*)0); +} + +void tst_QJSValue::getSetScriptClass_JSObjectFromCpp() +{ + QScriptEngine eng; + TestScriptClass testClass(&eng); + // object created in C++ (newObject()) + { + QJSValue obj = eng.newObject(); + obj.setScriptClass(&testClass); + QCOMPARE(obj.scriptClass(), (QScriptClass*)&testClass); + obj.setScriptClass(0); + QCOMPARE(obj.scriptClass(), (QScriptClass*)0); + } +} + +void tst_QJSValue::getSetScriptClass_JSObjectFromJS() +{ + QScriptEngine eng; + TestScriptClass testClass(&eng); + // object created in JS + { + QJSValue obj = eng.evaluate("new Object"); + QVERIFY(!eng.hasUncaughtException()); + QVERIFY(obj.isObject()); + QCOMPARE(obj.scriptClass(), (QScriptClass*)0); + obj.setScriptClass(&testClass); + QCOMPARE(obj.scriptClass(), (QScriptClass*)&testClass); + obj.setScriptClass(0); + QCOMPARE(obj.scriptClass(), (QScriptClass*)0); + } +} + +void tst_QJSValue::getSetScriptClass_QVariant() +{ + QScriptEngine eng; + TestScriptClass testClass(&eng); + // object that already has a(n internal) class + { + QJSValue obj = eng.newVariant(QUrl("http://example.com")); + QVERIFY(obj.isVariant()); + QCOMPARE(obj.scriptClass(), (QScriptClass*)0); + obj.setScriptClass(&testClass); + QCOMPARE(obj.scriptClass(), (QScriptClass*)&testClass); + QVERIFY(obj.isObject()); + QVERIFY(!obj.isVariant()); + QCOMPARE(obj.toVariant(), QVariant(QVariantMap())); + } +} + +void tst_QJSValue::getSetScriptClass_QObject() +{ + QScriptEngine eng; + TestScriptClass testClass(&eng); + { + QJSValue obj = eng.newQObject(this); + QVERIFY(obj.isQObject()); + obj.setScriptClass(&testClass); + QCOMPARE(obj.scriptClass(), (QScriptClass*)&testClass); + QVERIFY(obj.isObject()); + QVERIFY(!obj.isQObject()); + QVERIFY(obj.toQObject() == 0); + } +} +#endif + +#if 0 // FIXME: No c-style callbacks +static QJSValue getArg(QScriptContext *ctx, QScriptEngine *) +{ + return ctx->argument(0); +} + +static QJSValue evaluateArg(QScriptContext *, QScriptEngine *eng) +{ + return eng->evaluate("arguments[0]"); +} + +static QJSValue addArgs(QScriptContext *, QScriptEngine *eng) +{ + return eng->evaluate("arguments[0] + arguments[1]"); +} + +static QJSValue returnInvalidValue(QScriptContext *, QScriptEngine *) +{ + return QJSValue(); +} +#endif + +void tst_QJSValue::call_function() +{ + QJSEngine eng; + QJSValue fun = eng.evaluate("(function() { return 1; })"); + QVERIFY(fun.isFunction()); + QJSValue result = fun.call(); + QVERIFY(result.isNumber()); + QCOMPARE(result.toInt32(), 1); +} + +void tst_QJSValue::call_object() +{ + QJSEngine eng; + QJSValue Object = eng.evaluate("Object"); + QCOMPARE(Object.isFunction(), true); + QJSValue result = Object.call(Object); + QCOMPARE(result.isObject(), true); +} + +void tst_QJSValue::call_newObjects() +{ + QJSEngine eng; + // test that call() doesn't construct new objects + QJSValue Number = eng.evaluate("Number"); + QJSValue Object = eng.evaluate("Object"); + QCOMPARE(Object.isFunction(), true); + QJSValueList args; + args << QJSValue(&eng, 123); + QJSValue result = Number.call(Object, args); + QCOMPARE(result.strictlyEquals(args.at(0)), true); +} + +void tst_QJSValue::call_this() +{ + QJSEngine eng; + // test that correct "this" object is used + QJSValue fun = eng.evaluate("(function() { return this; })"); + QCOMPARE(fun.isFunction(), true); + + QJSValue numberObject = QJSValue(&eng, 123.0).toObject(); + QJSValue result = fun.call(numberObject); + QCOMPARE(result.isObject(), true); + QCOMPARE(result.toNumber(), 123.0); +} + +void tst_QJSValue::call_arguments() +{ + QJSEngine eng; + // test that correct arguments are passed + + QJSValue fun = eng.evaluate("(function() { return arguments[0]; })"); + QCOMPARE(fun.isFunction(), true); + { + QJSValue result = fun.call(eng.undefinedValue()); + QCOMPARE(result.isUndefined(), true); + } + { + QJSValueList args; + args << QJSValue(&eng, 123.0); + QJSValue result = fun.call(eng.undefinedValue(), args); + QCOMPARE(result.isNumber(), true); + QCOMPARE(result.toNumber(), 123.0); + } + // V2 constructors + { + QJSValueList args; + args << QJSValue(123.0); + QJSValue result = fun.call(eng.undefinedValue(), args); + QCOMPARE(result.isNumber(), true); + QCOMPARE(result.toNumber(), 123.0); + } +#if 0 // FIXME: The feature of interpreting a passed array as argument list has been removed from the API + { + QJSValue args = eng.newArray(); + args.setProperty(0, 123); + QJSValue result = fun.call(eng.undefinedValue(), args); + QVERIFY(result.isNumber()); + QCOMPARE(result.toNumber(), 123.0); + } +#endif +} + +void tst_QJSValue::call() +{ + QJSEngine eng; + { + QJSValue fun = eng.evaluate("(function() { return arguments[1]; })"); + QCOMPARE(fun.isFunction(), true); + + { + QJSValueList args; + args << QJSValue(&eng, 123.0) << QJSValue(&eng, 456.0); + QJSValue result = fun.call(eng.undefinedValue(), args); + QCOMPARE(result.isNumber(), true); + QCOMPARE(result.toNumber(), 456.0); + } +#if 0 // FIXME: The feature of interpreting a passed array as argument list has been removed from the API + { + QJSValue args = eng.newArray(); + args.setProperty(0, 123); + args.setProperty(1, 456); + QJSValue result = fun.call(eng.undefinedValue(), args); + QVERIFY(result.isNumber()); + QCOMPARE(result.toNumber(), 456.0); + } +#endif + } + { + QJSValue fun = eng.evaluate("(function() { throw new Error('foo'); })"); + QCOMPARE(fun.isFunction(), true); + QVERIFY(!eng.hasUncaughtException()); + + { + QJSValue result = fun.call(); + QCOMPARE(result.isError(), true); + QCOMPARE(eng.hasUncaughtException(), true); + QVERIFY(result.strictlyEquals(eng.uncaughtException())); + } + } +#if 0 // FIXME: No c-style callbacks + { + eng.clearExceptions(); + QJSValue fun = eng.newFunction(getArg); + { + QJSValueList args; + args << QJSValue(&eng, 123.0); + QJSValue result = fun.call(eng.undefinedValue(), args); + QVERIFY(!eng.hasUncaughtException()); + QCOMPARE(result.isNumber(), true); + QCOMPARE(result.toNumber(), 123.0); + } + // V2 constructors + { + QJSValueList args; + args << QJSValue(123.0); + QJSValue result = fun.call(eng.undefinedValue(), args); + QCOMPARE(result.isNumber(), true); + QCOMPARE(result.toNumber(), 123.0); + } +#if 0 // FIXME: The feature of interpreting a passed array as argument list has been removed from the API + { + QJSValue args = eng.newArray(); + args.setProperty(0, 123); + QJSValue result = fun.call(eng.undefinedValue(), args); + QVERIFY(result.isNumber()); + QCOMPARE(result.toNumber(), 123.0); + } +#endif + } + { + QJSValue fun = eng.newFunction(evaluateArg); + { + QJSValueList args; + args << QJSValue(&eng, 123.0); + QJSValue result = fun.call(eng.undefinedValue(), args); + QVERIFY(!eng.hasUncaughtException()); + QCOMPARE(result.isNumber(), true); + QCOMPARE(result.toNumber(), 123.0); + } + } +#endif +} + +void tst_QJSValue::call_invalidArguments() +{ +#if 0 // FIXME: No c-style callbacks + // test that invalid arguments are handled gracefully + QScriptEngine eng; + { + QJSValue fun = eng.newFunction(getArg); + { + QJSValueList args; + args << QJSValue(); + QJSValue ret = fun.call(QJSValue(), args); + QVERIFY(!eng.hasUncaughtException()); + QCOMPARE(ret.isValid(), true); + QCOMPARE(ret.isUndefined(), true); + } + } + { + QJSValue fun = eng.newFunction(evaluateArg); + { + QJSValueList args; + args << QJSValue(); + QJSValue ret = fun.call(QJSValue(), args); + QCOMPARE(ret.isValid(), true); + QCOMPARE(ret.isUndefined(), true); + } + } + { + QJSValue fun = eng.newFunction(addArgs); + { + QJSValueList args; + args << QJSValue() << QJSValue(); + QJSValue ret = fun.call(QJSValue(), args); + QCOMPARE(ret.isValid(), true); + QCOMPARE(ret.isNumber(), true); + QCOMPARE(qIsNaN(ret.toNumber()), true); + } + } +#endif +} + +void tst_QJSValue::call_invalidReturn() +{ +#if 0 // FIXME: No c-style callbacks + // test that invalid return value is handled gracefully + QScriptEngine eng; + QJSValue fun = eng.newFunction(returnInvalidValue); + eng.globalObject().setProperty("returnInvalidValue", fun); + QJSValue ret = eng.evaluate("returnInvalidValue() + returnInvalidValue()"); + QCOMPARE(ret.isValid(), true); + QCOMPARE(ret.isNumber(), true); + QCOMPARE(qIsNaN(ret.toNumber()), true); +#endif +} + +void tst_QJSValue::call_twoEngines() +{ + QJSEngine eng; + QJSValue object = eng.evaluate("Object"); + QJSEngine otherEngine; + QJSValue fun = otherEngine.evaluate("(function() { return 1; })"); + QVERIFY(fun.isFunction()); + QTest::ignoreMessage(QtWarningMsg, "QJSValue::call() failed: " + "cannot call function with thisObject created in " + "a different engine"); + QCOMPARE(fun.call(object).isValid(), false); + QTest::ignoreMessage(QtWarningMsg, "QJSValue::call() failed: " + "cannot call function with argument created in " + "a different engine"); + QCOMPARE(fun.call(QJSValue(), QJSValueList() << QJSValue(&eng, 123)).isValid(), false); + { + QJSValue fun = eng.evaluate("Object"); + QVERIFY(fun.isFunction()); + QJSEngine eng2; + QJSValue objectInDifferentEngine = eng2.newObject(); + QJSValueList args; + args << objectInDifferentEngine; + QTest::ignoreMessage(QtWarningMsg, "QJSValue::call() failed: cannot call function with argument created in a different engine"); + fun.call(QJSValue(), args); + } +} + +void tst_QJSValue::call_array() +{ +#if 0 // FIXME: The feature of interpreting an array as argument list has been removed from the API + QScriptEngine eng; + QJSValue fun = eng.evaluate("(function() { return arguments; })"); + QVERIFY(fun.isFunction()); + QJSValue array = eng.newArray(3); + array.setProperty(0, QJSValue(&eng, 123.0)); + array.setProperty(1, QJSValue(&eng, 456.0)); + array.setProperty(2, QJSValue(&eng, 789.0)); + // call with single array object as arguments + QJSValue ret = fun.call(QJSValue(), array); + QVERIFY(!eng.hasUncaughtException()); + QCOMPARE(ret.isError(), false); + QCOMPARE(ret.property(0).strictlyEquals(array.property(0)), true); + QCOMPARE(ret.property(1).strictlyEquals(array.property(1)), true); + QCOMPARE(ret.property(2).strictlyEquals(array.property(2)), true); + // call with arguments object as arguments + QJSValue ret2 = fun.call(QJSValue(), ret); + QCOMPARE(ret2.isError(), false); + QCOMPARE(ret2.property(0).strictlyEquals(ret.property(0)), true); + QCOMPARE(ret2.property(1).strictlyEquals(ret.property(1)), true); + QCOMPARE(ret2.property(2).strictlyEquals(ret.property(2)), true); + // call with null as arguments + QJSValue ret3 = fun.call(QJSValue(), eng.nullValue()); + QCOMPARE(ret3.isError(), false); + QCOMPARE(ret3.property("length").isNumber(), true); + QCOMPARE(ret3.property("length").toNumber(), 0.0); + // call with undefined as arguments + QJSValue ret4 = fun.call(QJSValue(), eng.undefinedValue()); + QCOMPARE(ret4.isError(), false); + QCOMPARE(ret4.property("length").isNumber(), true); + QCOMPARE(ret4.property("length").toNumber(), 0.0); + // call with something else as arguments + QJSValue ret5 = fun.call(QJSValue(), QJSValue(&eng, 123.0)); + QCOMPARE(ret5.isError(), true); + // call with a non-array object as arguments + QJSValue ret6 = fun.call(QJSValue(), eng.globalObject()); + QVERIFY(ret6.isError()); + QCOMPARE(ret6.toString(), QString::fromLatin1("TypeError: Arguments must be an array")); +#endif +} + + +void tst_QJSValue::call_nonFunction_data() +{ + newEngine(); + QTest::addColumn<QJSValue>("value"); + + QTest::newRow("invalid") << QJSValue(); + QTest::newRow("bool") << QJSValue(false); + QTest::newRow("int") << QJSValue(123); + QTest::newRow("string") << QJSValue(QString::fromLatin1("ciao")); + QTest::newRow("undefined") << QJSValue(QJSValue::UndefinedValue); + QTest::newRow("null") << QJSValue(QJSValue::NullValue); + + QTest::newRow("bool bound") << QJSValue(engine, false); + QTest::newRow("int bound") << QJSValue(engine, 123); + QTest::newRow("string bound") << QJSValue(engine, QString::fromLatin1("ciao")); + QTest::newRow("undefined bound") << engine->undefinedValue(); + QTest::newRow("null bound") << engine->nullValue(); +} + +void tst_QJSValue::call_nonFunction() +{ + // calling things that are not functions + QFETCH(QJSValue, value); + QVERIFY(!value.call().isValid()); +} + +#if 0 // FIXME: no c-style callbacks +static QJSValue ctorReturningUndefined(QScriptContext *ctx, QScriptEngine *) +{ + ctx->thisObject().setProperty("foo", 123); + return QJSValue(QJSValue::UndefinedValue); +} + +static QJSValue ctorReturningNewObject(QScriptContext *, QScriptEngine *eng) +{ + QJSValue result = eng->newObject(); + result.setProperty("bar", 456); + return result; +} +#endif + +void tst_QJSValue::construct_nonFunction_data() +{ + newEngine(); + QTest::addColumn<QJSValue>("value"); + + QTest::newRow("invalid") << QJSValue(); + QTest::newRow("bool") << QJSValue(false); + QTest::newRow("int") << QJSValue(123); + QTest::newRow("string") << QJSValue(QString::fromLatin1("ciao")); + QTest::newRow("undefined") << QJSValue(QJSValue::UndefinedValue); + QTest::newRow("null") << QJSValue(QJSValue::NullValue); + + QTest::newRow("bool bound") << QJSValue(engine, false); + QTest::newRow("int bound") << QJSValue(engine, 123); + QTest::newRow("string bound") << QJSValue(engine, QString::fromLatin1("ciao")); + QTest::newRow("undefined bound") << engine->undefinedValue(); + QTest::newRow("null bound") << engine->nullValue(); +} + +void tst_QJSValue::construct_nonFunction() +{ + QFETCH(QJSValue, value); + QVERIFY(!value.construct().isValid()); +} + +void tst_QJSValue::construct_simple() +{ + QJSEngine eng; + QJSValue fun = eng.evaluate("(function () { this.foo = 123; })"); + QVERIFY(fun.isFunction()); + QJSValue ret = fun.construct(); + QVERIFY(ret.isObject()); + QVERIFY(ret.instanceOf(fun)); + QCOMPARE(ret.property("foo").toInt32(), 123); +} + +void tst_QJSValue::construct_newObjectJS() +{ + QJSEngine eng; + // returning a different object overrides the default-constructed one + QJSValue fun = eng.evaluate("(function () { return { bar: 456 }; })"); + QVERIFY(fun.isFunction()); + QJSValue ret = fun.construct(); + QVERIFY(ret.isObject()); + QVERIFY(!ret.instanceOf(fun)); + QCOMPARE(ret.property("bar").toInt32(), 456); +} + +#if 0 // FIXME: no c-style callbacks +void tst_QJSValue::construct_undefined() +{ + QScriptEngine eng; + QJSValue fun = eng.newFunction(ctorReturningUndefined); + QJSValue ret = fun.construct(); + QVERIFY(ret.isObject()); + QVERIFY(ret.instanceOf(fun)); + QCOMPARE(ret.property("foo").toInt32(), 123); +} + +void tst_QJSValue::construct_newObjectCpp() +{ + QScriptEngine eng; + QJSValue fun = eng.newFunction(ctorReturningNewObject); + QJSValue ret = fun.construct(); + QVERIFY(ret.isObject()); + QVERIFY(!ret.instanceOf(fun)); + QCOMPARE(ret.property("bar").toInt32(), 456); +} +#endif + +void tst_QJSValue::construct_arg() +{ + QJSEngine eng; + QJSValue Number = eng.evaluate("Number"); + QCOMPARE(Number.isFunction(), true); + QJSValueList args; + args << QJSValue(&eng, 123); + QJSValue ret = Number.construct(args); + QCOMPARE(ret.isObject(), true); + QCOMPARE(ret.toNumber(), args.at(0).toNumber()); +} + +void tst_QJSValue::construct_proto() +{ + QJSEngine eng; + // test that internal prototype is set correctly + QJSValue fun = eng.evaluate("(function() { return this.__proto__; })"); + QCOMPARE(fun.isFunction(), true); + QCOMPARE(fun.property("prototype").isObject(), true); + QJSValue ret = fun.construct(); + QCOMPARE(fun.property("prototype").strictlyEquals(ret), true); +} + +void tst_QJSValue::construct_returnInt() +{ + QJSEngine eng; + // test that we return the new object even if a non-object value is returned from the function + QJSValue fun = eng.evaluate("(function() { return 123; })"); + QCOMPARE(fun.isFunction(), true); + QJSValue ret = fun.construct(); + QCOMPARE(ret.isObject(), true); +} + +void tst_QJSValue::construct_throw() +{ + QJSEngine eng; + QJSValue fun = eng.evaluate("(function() { throw new Error('foo'); })"); + QCOMPARE(fun.isFunction(), true); + QJSValue ret = fun.construct(); + QCOMPARE(ret.isError(), true); + QCOMPARE(eng.hasUncaughtException(), true); + QVERIFY(ret.strictlyEquals(eng.uncaughtException())); +} + +#if 0 // FIXME: The feature of interpreting an array as argument list has been removed from the API +void tst_QJSValue::construct() +{ + QScriptEngine eng; + QJSValue fun = eng.evaluate("(function() { return arguments; })"); + QVERIFY(fun.isFunction()); + QJSValue array = eng.newArray(3); + array.setProperty(0, QJSValue(&eng, 123.0)); + array.setProperty(1, QJSValue(&eng, 456.0)); + array.setProperty(2, QJSValue(&eng, 789.0)); + // construct with single array object as arguments + QJSValue ret = fun.construct(array); + QVERIFY(!eng.hasUncaughtException()); + QVERIFY(ret.isValid()); + QVERIFY(ret.isObject()); + QCOMPARE(ret.property(0).strictlyEquals(array.property(0)), true); + QCOMPARE(ret.property(1).strictlyEquals(array.property(1)), true); + QCOMPARE(ret.property(2).strictlyEquals(array.property(2)), true); + // construct with arguments object as arguments + QJSValue ret2 = fun.construct(ret); + QCOMPARE(ret2.property(0).strictlyEquals(ret.property(0)), true); + QCOMPARE(ret2.property(1).strictlyEquals(ret.property(1)), true); + QCOMPARE(ret2.property(2).strictlyEquals(ret.property(2)), true); + // construct with null as arguments + QJSValue ret3 = fun.construct(eng.nullValue()); + QCOMPARE(ret3.isError(), false); + QCOMPARE(ret3.property("length").isNumber(), true); + QCOMPARE(ret3.property("length").toNumber(), 0.0); + // construct with undefined as arguments + QJSValue ret4 = fun.construct(eng.undefinedValue()); + QCOMPARE(ret4.isError(), false); + QCOMPARE(ret4.property("length").isNumber(), true); + QCOMPARE(ret4.property("length").toNumber(), 0.0); + // construct with something else as arguments + QJSValue ret5 = fun.construct(QJSValue(&eng, 123.0)); + QCOMPARE(ret5.isError(), true); + // construct with a non-array object as arguments + QJSValue ret6 = fun.construct(eng.globalObject()); + QVERIFY(ret6.isError()); + QCOMPARE(ret6.toString(), QString::fromLatin1("TypeError: Arguments must be an array")); +} +#endif + +void tst_QJSValue::construct_twoEngines() +{ + QJSEngine engine; + QJSEngine otherEngine; + QJSValue ctor = engine.evaluate("(function (a, b) { this.foo = 123; })"); + QJSValue arg(&otherEngine, 124567); + QTest::ignoreMessage(QtWarningMsg, "QJSValue::construct() failed: cannot construct function with argument created in a different engine"); + QVERIFY(!ctor.construct(QJSValueList() << arg).isValid()); + QTest::ignoreMessage(QtWarningMsg, "QJSValue::construct() failed: cannot construct function with argument created in a different engine"); + QVERIFY(!ctor.construct(QJSValueList() << arg << otherEngine.newObject()).isValid()); +} + +void tst_QJSValue::construct_constructorThrowsPrimitive() +{ + QJSEngine eng; + QJSValue fun = eng.evaluate("(function() { throw 123; })"); + QVERIFY(fun.isFunction()); + // construct(QJSValueList) + { + QJSValue ret = fun.construct(); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toNumber(), 123.0); + QVERIFY(eng.hasUncaughtException()); + QVERIFY(ret.strictlyEquals(eng.uncaughtException())); + eng.clearExceptions(); + } +#if 0 // FIXME: The feature of interpreting an array as argument list has been removed from the API + // construct(QJSValue) + { + QJSValue ret = fun.construct(eng.newArray()); + QVERIFY(ret.isNumber()); + QCOMPARE(ret.toNumber(), 123.0); + QVERIFY(eng.hasUncaughtException()); + QVERIFY(ret.strictlyEquals(eng.uncaughtException())); + eng.clearExceptions(); + } +#endif +} + +#if 0 // FIXME: No QJSValue::lessThan +void tst_QJSValue::lessThan() +{ + QScriptEngine eng; + + QVERIFY(!QJSValue().lessThan(QJSValue())); + + QJSValue num = QJSValue(&eng, 123); + QCOMPARE(num.lessThan(QJSValue(&eng, 124)), true); + QCOMPARE(num.lessThan(QJSValue(&eng, 122)), false); + QCOMPARE(num.lessThan(QJSValue(&eng, 123)), false); + QCOMPARE(num.lessThan(QJSValue(&eng, "124")), true); + QCOMPARE(num.lessThan(QJSValue(&eng, "122")), false); + QCOMPARE(num.lessThan(QJSValue(&eng, "123")), false); + QCOMPARE(num.lessThan(QJSValue(&eng, qSNaN())), false); + QCOMPARE(num.lessThan(QJSValue(&eng, +qInf())), true); + QCOMPARE(num.lessThan(QJSValue(&eng, -qInf())), false); + QCOMPARE(num.lessThan(num), false); + QCOMPARE(num.lessThan(QJSValue(&eng, 124).toObject()), true); + QCOMPARE(num.lessThan(QJSValue(&eng, 122).toObject()), false); + QCOMPARE(num.lessThan(QJSValue(&eng, 123).toObject()), false); + QCOMPARE(num.lessThan(QJSValue(&eng, "124").toObject()), true); + QCOMPARE(num.lessThan(QJSValue(&eng, "122").toObject()), false); + QCOMPARE(num.lessThan(QJSValue(&eng, "123").toObject()), false); + QCOMPARE(num.lessThan(QJSValue(&eng, qSNaN()).toObject()), false); + QCOMPARE(num.lessThan(QJSValue(&eng, +qInf()).toObject()), true); + QCOMPARE(num.lessThan(QJSValue(&eng, -qInf()).toObject()), false); + QCOMPARE(num.lessThan(num.toObject()), false); + QCOMPARE(num.lessThan(QJSValue()), false); + + QJSValue str = QJSValue(&eng, "123"); + QCOMPARE(str.lessThan(QJSValue(&eng, "124")), true); + QCOMPARE(str.lessThan(QJSValue(&eng, "122")), false); + QCOMPARE(str.lessThan(QJSValue(&eng, "123")), false); + QCOMPARE(str.lessThan(QJSValue(&eng, 124)), true); + QCOMPARE(str.lessThan(QJSValue(&eng, 122)), false); + QCOMPARE(str.lessThan(QJSValue(&eng, 123)), false); + QCOMPARE(str.lessThan(str), false); + QCOMPARE(str.lessThan(QJSValue(&eng, "124").toObject()), true); + QCOMPARE(str.lessThan(QJSValue(&eng, "122").toObject()), false); + QCOMPARE(str.lessThan(QJSValue(&eng, "123").toObject()), false); + QCOMPARE(str.lessThan(QJSValue(&eng, 124).toObject()), true); + QCOMPARE(str.lessThan(QJSValue(&eng, 122).toObject()), false); + QCOMPARE(str.lessThan(QJSValue(&eng, 123).toObject()), false); + QCOMPARE(str.lessThan(str.toObject()), false); + QCOMPARE(str.lessThan(QJSValue()), false); + + // V2 constructors + QJSValue num2 = QJSValue(123); + QCOMPARE(num2.lessThan(QJSValue(124)), true); + QCOMPARE(num2.lessThan(QJSValue(122)), false); + QCOMPARE(num2.lessThan(QJSValue(123)), false); + QCOMPARE(num2.lessThan(QJSValue("124")), true); + QCOMPARE(num2.lessThan(QJSValue("122")), false); + QCOMPARE(num2.lessThan(QJSValue("123")), false); + QCOMPARE(num2.lessThan(QJSValue(qSNaN())), false); + QCOMPARE(num2.lessThan(QJSValue(+qInf())), true); + QCOMPARE(num2.lessThan(QJSValue(-qInf())), false); + QCOMPARE(num2.lessThan(num), false); + QCOMPARE(num2.lessThan(QJSValue()), false); + + QJSValue str2 = QJSValue("123"); + QCOMPARE(str2.lessThan(QJSValue("124")), true); + QCOMPARE(str2.lessThan(QJSValue("122")), false); + QCOMPARE(str2.lessThan(QJSValue("123")), false); + QCOMPARE(str2.lessThan(QJSValue(124)), true); + QCOMPARE(str2.lessThan(QJSValue(122)), false); + QCOMPARE(str2.lessThan(QJSValue(123)), false); + QCOMPARE(str2.lessThan(str), false); + QCOMPARE(str2.lessThan(QJSValue()), false); + + QJSValue obj1 = eng.newObject(); + QJSValue obj2 = eng.newObject(); + QCOMPARE(obj1.lessThan(obj2), false); + QCOMPARE(obj2.lessThan(obj1), false); + QCOMPARE(obj1.lessThan(obj1), false); + QCOMPARE(obj2.lessThan(obj2), false); + + QJSValue date1 = eng.newDate(QDateTime(QDate(2000, 1, 1))); + QJSValue date2 = eng.newDate(QDateTime(QDate(1999, 1, 1))); + QCOMPARE(date1.lessThan(date2), false); + QCOMPARE(date2.lessThan(date1), true); + QCOMPARE(date1.lessThan(date1), false); + QCOMPARE(date2.lessThan(date2), false); + QCOMPARE(date1.lessThan(QJSValue()), false); + + QCOMPARE(QJSValue().lessThan(date2), false); + + QScriptEngine otherEngine; + QTest::ignoreMessage(QtWarningMsg, "QJSValue::lessThan: " + "cannot compare to a value created in " + "a different engine"); + QCOMPARE(date1.lessThan(QJSValue(&otherEngine, 123)), false); +} +#endif + +void tst_QJSValue::equals() +{ + QJSEngine eng; + + QVERIFY(QJSValue().equals(QJSValue())); + + QJSValue num = QJSValue(&eng, 123); + QCOMPARE(num.equals(QJSValue(&eng, 123)), true); + QCOMPARE(num.equals(QJSValue(&eng, 321)), false); + QCOMPARE(num.equals(QJSValue(&eng, QLatin1String("123"))), true); + QCOMPARE(num.equals(QJSValue(&eng, QLatin1String("321"))), false); + QCOMPARE(num.equals(QJSValue(&eng, 123).toObject()), true); + QCOMPARE(num.equals(QJSValue(&eng, 321).toObject()), false); + QCOMPARE(num.equals(QJSValue(&eng, QLatin1String("123")).toObject()), true); + QCOMPARE(num.equals(QJSValue(&eng, QLatin1String("321")).toObject()), false); + QVERIFY(num.toObject().equals(num)); + QCOMPARE(num.equals(QJSValue()), false); + + QJSValue str = QJSValue(&eng, QLatin1String("123")); + QCOMPARE(str.equals(QJSValue(&eng, QLatin1String("123"))), true); + QCOMPARE(str.equals(QJSValue(&eng, QLatin1String("321"))), false); + QCOMPARE(str.equals(QJSValue(&eng, 123)), true); + QCOMPARE(str.equals(QJSValue(&eng, 321)), false); + QCOMPARE(str.equals(QJSValue(&eng, QLatin1String("123")).toObject()), true); + QCOMPARE(str.equals(QJSValue(&eng, QLatin1String("321")).toObject()), false); + QCOMPARE(str.equals(QJSValue(&eng, 123).toObject()), true); + QCOMPARE(str.equals(QJSValue(&eng, 321).toObject()), false); + QVERIFY(str.toObject().equals(str)); + QCOMPARE(str.equals(QJSValue()), false); + + QJSValue num2 = QJSValue(123); + QCOMPARE(num2.equals(QJSValue(123)), true); + QCOMPARE(num2.equals(QJSValue(321)), false); + QCOMPARE(num2.equals(QJSValue("123")), true); + QCOMPARE(num2.equals(QJSValue("321")), false); + QCOMPARE(num2.equals(QJSValue()), false); + + QJSValue str2 = QJSValue("123"); + QCOMPARE(str2.equals(QJSValue("123")), true); + QCOMPARE(str2.equals(QJSValue("321")), false); + QCOMPARE(str2.equals(QJSValue(123)), true); + QCOMPARE(str2.equals(QJSValue(321)), false); + QCOMPARE(str2.equals(QJSValue()), false); + + QJSValue date1 = eng.newDate(QDateTime(QDate(2000, 1, 1))); + QJSValue date2 = eng.newDate(QDateTime(QDate(1999, 1, 1))); + QCOMPARE(date1.equals(date2), false); + QCOMPARE(date1.equals(date1), true); + QCOMPARE(date2.equals(date2), true); + + QJSValue undefined = eng.undefinedValue(); + QJSValue null = eng.nullValue(); + QCOMPARE(undefined.equals(undefined), true); + QCOMPARE(null.equals(null), true); + QCOMPARE(undefined.equals(null), true); + QCOMPARE(null.equals(undefined), true); + QCOMPARE(undefined.equals(QJSValue()), false); + QCOMPARE(null.equals(QJSValue()), false); + QVERIFY(!null.equals(num)); + QVERIFY(!undefined.equals(num)); + + QJSValue sant = QJSValue(&eng, true); + QVERIFY(sant.equals(QJSValue(&eng, 1))); + QVERIFY(sant.equals(QJSValue(&eng, QLatin1String("1")))); + QVERIFY(sant.equals(sant)); + QVERIFY(sant.equals(QJSValue(&eng, 1).toObject())); + QVERIFY(sant.equals(QJSValue(&eng, QLatin1String("1")).toObject())); + QVERIFY(sant.equals(sant.toObject())); + QVERIFY(sant.toObject().equals(sant)); + QVERIFY(!sant.equals(QJSValue(&eng, 0))); + QVERIFY(!sant.equals(undefined)); + QVERIFY(!sant.equals(null)); + + QJSValue falskt = QJSValue(&eng, false); + QVERIFY(falskt.equals(QJSValue(&eng, 0))); + QVERIFY(falskt.equals(QJSValue(&eng, QLatin1String("0")))); + QVERIFY(falskt.equals(falskt)); + QVERIFY(falskt.equals(QJSValue(&eng, 0).toObject())); + QVERIFY(falskt.equals(QJSValue(&eng, QLatin1String("0")).toObject())); + QVERIFY(falskt.equals(falskt.toObject())); + QVERIFY(falskt.toObject().equals(falskt)); + QVERIFY(!falskt.equals(sant)); + QVERIFY(!falskt.equals(undefined)); + QVERIFY(!falskt.equals(null)); + + QJSValue obj1 = eng.newObject(); + QJSValue obj2 = eng.newObject(); + QCOMPARE(obj1.equals(obj2), false); + QCOMPARE(obj2.equals(obj1), false); + QCOMPARE(obj1.equals(obj1), true); + QCOMPARE(obj2.equals(obj2), true); + + QJSValue qobj1 = eng.newQObject(this); + QJSValue qobj2 = eng.newQObject(this); + QJSValue qobj3 = eng.newQObject(0); + + // FIXME: No ScriptOwnership: QJSValue qobj4 = eng.newQObject(new QObject(), QScriptEngine::ScriptOwnership); + QJSValue qobj4 = eng.newQObject(new QObject()); + + QVERIFY(qobj1.equals(qobj2)); // compares the QObject pointers + QVERIFY(!qobj2.equals(qobj4)); // compares the QObject pointers + QVERIFY(!qobj2.equals(obj2)); // compares the QObject pointers + + QJSValue compareFun = eng.evaluate("(function(a, b) { return a == b; })"); + QVERIFY(compareFun.isFunction()); + { + QJSValue ret = compareFun.call(QJSValue(), QJSValueList() << qobj1 << qobj2); + QVERIFY(ret.isBool()); + ret = compareFun.call(QJSValue(), QJSValueList() << qobj1 << qobj3); + QVERIFY(ret.isBool()); + QVERIFY(!ret.toBool()); + ret = compareFun.call(QJSValue(), QJSValueList() << qobj1 << qobj4); + QVERIFY(ret.isBool()); + QVERIFY(!ret.toBool()); + ret = compareFun.call(QJSValue(), QJSValueList() << qobj1 << obj1); + QVERIFY(ret.isBool()); + QVERIFY(!ret.toBool()); + } + + { + QJSValue var1 = eng.newVariant(QVariant(false)); + QJSValue var2 = eng.newVariant(QVariant(false)); + QEXPECT_FAIL("", "FIXME: QVariant comparison does not work with v8", Continue); + QVERIFY(var1.equals(var2)); + { + QJSValue ret = compareFun.call(QJSValue(), QJSValueList() << var1 << var2); + QVERIFY(ret.isBool()); + } + } + { + QJSValue var1 = eng.newVariant(QVariant(false)); + QJSValue var2 = eng.newVariant(QVariant(0)); + // QVariant::operator==() performs type conversion + QEXPECT_FAIL("", "FIXME: QVariant comparison does not work with v8", Continue); + QVERIFY(var1.equals(var2)); + } + { + QJSValue var1 = eng.newVariant(QVariant(QStringList() << "a")); + QJSValue var2 = eng.newVariant(QVariant(QStringList() << "a")); + QEXPECT_FAIL("", "FIXME: QVariant comparison does not work with v8", Continue); + QVERIFY(var1.equals(var2)); + } + { + QJSValue var1 = eng.newVariant(QVariant(QStringList() << "a")); + QJSValue var2 = eng.newVariant(QVariant(QStringList() << "b")); + QVERIFY(!var1.equals(var2)); + } + { + QJSValue var1 = eng.newVariant(QVariant(QPoint(1, 2))); + QJSValue var2 = eng.newVariant(QVariant(QPoint(1, 2))); + QEXPECT_FAIL("", "FIXME: QVariant comparison does not work with v8", Continue); + QVERIFY(var1.equals(var2)); + } + { + QJSValue var1 = eng.newVariant(QVariant(QPoint(1, 2))); + QJSValue var2 = eng.newVariant(QVariant(QPoint(3, 4))); + QVERIFY(!var1.equals(var2)); + } + { + QJSValue var1 = eng.newVariant(QVariant(int(1))); + QJSValue var2 = eng.newVariant(QVariant(double(1))); + // QVariant::operator==() performs type conversion + QEXPECT_FAIL("", "FIXME: QVariant comparison does not work with v8", Continue); + QVERIFY(var1.equals(var2)); + } + { + QJSValue var1 = eng.newVariant(QVariant(QString::fromLatin1("123"))); + QJSValue var2 = eng.newVariant(QVariant(double(123))); + QJSValue var3(QString::fromLatin1("123")); + QJSValue var4(123); + + QVERIFY(var1.equals(var1)); + QEXPECT_FAIL("", "FIXME: QVariant comparison does not work with v8", Continue); + QVERIFY(var1.equals(var2)); + QVERIFY(var1.equals(var3)); + QVERIFY(var1.equals(var4)); + + QEXPECT_FAIL("", "FIXME: QVariant comparison does not work with v8", Continue); + QVERIFY(var2.equals(var1)); + QVERIFY(var2.equals(var2)); + QVERIFY(var2.equals(var3)); + QVERIFY(var2.equals(var4)); + + QVERIFY(var3.equals(var1)); + QVERIFY(var3.equals(var2)); + QVERIFY(var3.equals(var3)); + QVERIFY(var3.equals(var4)); + + QVERIFY(var4.equals(var1)); + QVERIFY(var4.equals(var2)); + QVERIFY(var4.equals(var3)); + QVERIFY(var4.equals(var4)); + } + + QJSEngine otherEngine; + QTest::ignoreMessage(QtWarningMsg, "QJSValue::equals: " + "cannot compare to a value created in " + "a different engine"); + QCOMPARE(date1.equals(QJSValue(&otherEngine, 123)), false); +} + +void tst_QJSValue::strictlyEquals() +{ + QJSEngine eng; + + QVERIFY(QJSValue().strictlyEquals(QJSValue())); + + QJSValue num = QJSValue(&eng, 123); + QCOMPARE(num.strictlyEquals(QJSValue(&eng, 123)), true); + QCOMPARE(num.strictlyEquals(QJSValue(&eng, 321)), false); + QCOMPARE(num.strictlyEquals(QJSValue(&eng, QLatin1String("123"))), false); + QCOMPARE(num.strictlyEquals(QJSValue(&eng, QLatin1String("321"))), false); + QCOMPARE(num.strictlyEquals(QJSValue(&eng, 123).toObject()), false); + QCOMPARE(num.strictlyEquals(QJSValue(&eng, 321).toObject()), false); + QCOMPARE(num.strictlyEquals(QJSValue(&eng, QLatin1String("123")).toObject()), false); + QCOMPARE(num.strictlyEquals(QJSValue(&eng, QLatin1String("321")).toObject()), false); + QVERIFY(!num.toObject().strictlyEquals(num)); + QVERIFY(!num.strictlyEquals(QJSValue())); + QVERIFY(!QJSValue().strictlyEquals(num)); + + QJSValue str = QJSValue(&eng, QLatin1String("123")); + QCOMPARE(str.strictlyEquals(QJSValue(&eng, QLatin1String("123"))), true); + QCOMPARE(str.strictlyEquals(QJSValue(&eng, QLatin1String("321"))), false); + QCOMPARE(str.strictlyEquals(QJSValue(&eng, 123)), false); + QCOMPARE(str.strictlyEquals(QJSValue(&eng, 321)), false); + QCOMPARE(str.strictlyEquals(QJSValue(&eng, QLatin1String("123")).toObject()), false); + QCOMPARE(str.strictlyEquals(QJSValue(&eng, QLatin1String("321")).toObject()), false); + QCOMPARE(str.strictlyEquals(QJSValue(&eng, 123).toObject()), false); + QCOMPARE(str.strictlyEquals(QJSValue(&eng, 321).toObject()), false); + QVERIFY(!str.toObject().strictlyEquals(str)); + QVERIFY(!str.strictlyEquals(QJSValue())); + + QJSValue num2 = QJSValue(123); + QCOMPARE(num2.strictlyEquals(QJSValue(123)), true); + QCOMPARE(num2.strictlyEquals(QJSValue(321)), false); + QCOMPARE(num2.strictlyEquals(QJSValue("123")), false); + QCOMPARE(num2.strictlyEquals(QJSValue("321")), false); + QVERIFY(!num2.strictlyEquals(QJSValue())); + + QJSValue str2 = QJSValue("123"); + QCOMPARE(str2.strictlyEquals(QJSValue("123")), true); + QCOMPARE(str2.strictlyEquals(QJSValue("321")), false); + QCOMPARE(str2.strictlyEquals(QJSValue(123)), false); + QCOMPARE(str2.strictlyEquals(QJSValue(321)), false); + QVERIFY(!str2.strictlyEquals(QJSValue())); + + QJSValue date1 = eng.newDate(QDateTime(QDate(2000, 1, 1))); + QJSValue date2 = eng.newDate(QDateTime(QDate(1999, 1, 1))); + QCOMPARE(date1.strictlyEquals(date2), false); + QCOMPARE(date1.strictlyEquals(date1), true); + QCOMPARE(date2.strictlyEquals(date2), true); + QVERIFY(!date1.strictlyEquals(QJSValue())); + + QJSValue undefined = eng.undefinedValue(); + QJSValue null = eng.nullValue(); + QCOMPARE(undefined.strictlyEquals(undefined), true); + QCOMPARE(null.strictlyEquals(null), true); + QCOMPARE(undefined.strictlyEquals(null), false); + QCOMPARE(null.strictlyEquals(undefined), false); + QVERIFY(!null.strictlyEquals(QJSValue())); + + QJSValue sant = QJSValue(&eng, true); + QVERIFY(!sant.strictlyEquals(QJSValue(&eng, 1))); + QVERIFY(!sant.strictlyEquals(QJSValue(&eng, QLatin1String("1")))); + QVERIFY(sant.strictlyEquals(sant)); + QVERIFY(!sant.strictlyEquals(QJSValue(&eng, 1).toObject())); + QVERIFY(!sant.strictlyEquals(QJSValue(&eng, QLatin1String("1")).toObject())); + QVERIFY(!sant.strictlyEquals(sant.toObject())); + QVERIFY(!sant.toObject().strictlyEquals(sant)); + QVERIFY(!sant.strictlyEquals(QJSValue(&eng, 0))); + QVERIFY(!sant.strictlyEquals(undefined)); + QVERIFY(!sant.strictlyEquals(null)); + QVERIFY(!sant.strictlyEquals(QJSValue())); + + QJSValue falskt = QJSValue(&eng, false); + QVERIFY(!falskt.strictlyEquals(QJSValue(&eng, 0))); + QVERIFY(!falskt.strictlyEquals(QJSValue(&eng, QLatin1String("0")))); + QVERIFY(falskt.strictlyEquals(falskt)); + QVERIFY(!falskt.strictlyEquals(QJSValue(&eng, 0).toObject())); + QVERIFY(!falskt.strictlyEquals(QJSValue(&eng, QLatin1String("0")).toObject())); + QVERIFY(!falskt.strictlyEquals(falskt.toObject())); + QVERIFY(!falskt.toObject().strictlyEquals(falskt)); + QVERIFY(!falskt.strictlyEquals(sant)); + QVERIFY(!falskt.strictlyEquals(undefined)); + QVERIFY(!falskt.strictlyEquals(null)); + QVERIFY(!falskt.strictlyEquals(QJSValue())); + + QVERIFY(!QJSValue(false).strictlyEquals(123)); + QVERIFY(!QJSValue(QJSValue::UndefinedValue).strictlyEquals(123)); + QVERIFY(!QJSValue(QJSValue::NullValue).strictlyEquals(123)); + QVERIFY(!QJSValue(false).strictlyEquals("ciao")); + QVERIFY(!QJSValue(QJSValue::UndefinedValue).strictlyEquals("ciao")); + QVERIFY(!QJSValue(QJSValue::NullValue).strictlyEquals("ciao")); + QVERIFY(QJSValue(&eng, QLatin1String("ciao")).strictlyEquals("ciao")); + QVERIFY(QJSValue("ciao").strictlyEquals(QJSValue(&eng, QLatin1String("ciao")))); + QVERIFY(!QJSValue("ciao").strictlyEquals(123)); + QVERIFY(!QJSValue("ciao").strictlyEquals(QJSValue(&eng, 123))); + QVERIFY(!QJSValue(123).strictlyEquals("ciao")); + QVERIFY(!QJSValue(123).strictlyEquals(QJSValue(&eng, QLatin1String("ciao")))); + QVERIFY(!QJSValue(&eng, 123).strictlyEquals("ciao")); + + QJSValue obj1 = eng.newObject(); + QJSValue obj2 = eng.newObject(); + QCOMPARE(obj1.strictlyEquals(obj2), false); + QCOMPARE(obj2.strictlyEquals(obj1), false); + QCOMPARE(obj1.strictlyEquals(obj1), true); + QCOMPARE(obj2.strictlyEquals(obj2), true); + QVERIFY(!obj1.strictlyEquals(QJSValue())); + + QJSValue qobj1 = eng.newQObject(this); + QJSValue qobj2 = eng.newQObject(this); + QVERIFY(qobj1.strictlyEquals(qobj2)); + + { + QJSValue var1 = eng.newVariant(QVariant(false)); + QJSValue var2 = eng.newVariant(QVariant(false)); + QVERIFY(!var1.strictlyEquals(var2)); + QVERIFY(!var1.strictlyEquals(QJSValue())); + } + { + QJSValue var1 = eng.newVariant(QVariant(false)); + QJSValue var2 = eng.newVariant(QVariant(0)); + QVERIFY(!var1.strictlyEquals(var2)); + } + { + QJSValue var1 = eng.newVariant(QVariant(QStringList() << "a")); + QJSValue var2 = eng.newVariant(QVariant(QStringList() << "a")); + QVERIFY(!var1.strictlyEquals(var2)); + } + { + QJSValue var1 = eng.newVariant(QVariant(QStringList() << "a")); + QJSValue var2 = eng.newVariant(QVariant(QStringList() << "b")); + QVERIFY(!var1.strictlyEquals(var2)); + } + { + QJSValue var1 = eng.newVariant(QVariant(QPoint(1, 2))); + QJSValue var2 = eng.newVariant(QVariant(QPoint(1, 2))); + QVERIFY(!var1.strictlyEquals(var2)); + } + { + QJSValue var1 = eng.newVariant(QVariant(QPoint(1, 2))); + QJSValue var2 = eng.newVariant(QVariant(QPoint(3, 4))); + QVERIFY(!var1.strictlyEquals(var2)); + } + + QJSEngine otherEngine; + QTest::ignoreMessage(QtWarningMsg, "QJSValue::strictlyEquals: " + "cannot compare to a value created in " + "a different engine"); + QCOMPARE(date1.strictlyEquals(QJSValue(&otherEngine, 123)), false); +} + +Q_DECLARE_METATYPE(int*) +Q_DECLARE_METATYPE(double*) +Q_DECLARE_METATYPE(QColor*) +Q_DECLARE_METATYPE(QBrush*) + +void tst_QJSValue::castToPointer() +{ + QJSEngine eng; + { + QJSValue v = eng.newVariant(int(123)); + int *ip = qjsvalue_cast<int*>(v); + QVERIFY(ip != 0); + QCOMPARE(*ip, 123); + QEXPECT_FAIL("", "Pointer magic for variants is currently not supported by QJSEngine", Abort); + *ip = 456; + QCOMPARE(qjsvalue_cast<int>(v), 456); + + double *dp = qjsvalue_cast<double*>(v); + QVERIFY(dp == 0); + + QJSValue v2 = eng.newVariant(qVariantFromValue(ip)); + QCOMPARE(qjsvalue_cast<int*>(v2), ip); + } + { + QColor c(123, 210, 231); + QJSValue v = eng.newVariant(c); + QColor *cp = qjsvalue_cast<QColor*>(v); + QVERIFY(cp != 0); + QCOMPARE(*cp, c); + + QBrush *bp = qjsvalue_cast<QBrush*>(v); + QVERIFY(bp == 0); + + QJSValue v2 = eng.newVariant(qVariantFromValue(cp)); + QCOMPARE(qjsvalue_cast<QColor*>(v2), cp); + } +} + +void tst_QJSValue::prettyPrinter_data() +{ + QTest::addColumn<QString>("function"); + QTest::addColumn<QString>("expected"); + QTest::newRow("function() { }") << QString("function() { }") << QString("function () { }"); + QTest::newRow("function foo() { }") << QString("(function foo() { })") << QString("function foo() { }"); + QTest::newRow("function foo(bar) { }") << QString("(function foo(bar) { })") << QString("function foo(bar) { }"); + QTest::newRow("function foo(bar, baz) { }") << QString("(function foo(bar, baz) { })") << QString("function foo(bar, baz) { }"); + QTest::newRow("this") << QString("function() { this; }") << QString("function () { this; }"); + QTest::newRow("identifier") << QString("function(a) { a; }") << QString("function (a) { a; }"); + QTest::newRow("null") << QString("function() { null; }") << QString("function () { null; }"); + QTest::newRow("true") << QString("function() { true; }") << QString("function () { true; }"); + QTest::newRow("false") << QString("function() { false; }") << QString("function () { false; }"); + QTest::newRow("string") << QString("function() { 'test'; }") << QString("function () { \'test\'; }"); + QTest::newRow("string") << QString("function() { \"test\"; }") << QString("function () { \"test\"; }"); + QTest::newRow("number") << QString("function() { 123; }") << QString("function () { 123; }"); + QTest::newRow("number") << QString("function() { 123.456; }") << QString("function () { 123.456; }"); + QTest::newRow("regexp") << QString("function() { /hello/; }") << QString("function () { /hello/; }"); + QTest::newRow("regexp") << QString("function() { /hello/gim; }") << QString("function () { /hello/gim; }"); + QTest::newRow("array") << QString("function() { []; }") << QString("function () { []; }"); + QTest::newRow("array") << QString("function() { [10]; }") << QString("function () { [10]; }"); + QTest::newRow("array") << QString("function() { [10, 20, 30]; }") << QString("function () { [10, 20, 30]; }"); + QTest::newRow("array") << QString("function() { [10, 20, , 40]; }") << QString("function () { [10, 20, , 40]; }"); + QTest::newRow("array") << QString("function() { [,]; }") << QString("function () { [,]; }"); + QTest::newRow("array") << QString("function() { [, 10]; }") << QString("function () { [, 10]; }"); + QTest::newRow("array") << QString("function() { [, 10, ]; }") << QString("function () { [, 10, ]; }"); + QTest::newRow("array") << QString("function() { [, 10, ,]; }") << QString("function () { [, 10, ,]; }"); + QTest::newRow("array") << QString("function() { [[10], [20]]; }") << QString("function () { [[10], [20]]; }"); + QTest::newRow("member") << QString("function() { a.b; }") << QString("function () { a.b; }"); + QTest::newRow("member") << QString("function() { a.b.c; }") << QString("function () { a.b.c; }"); + QTest::newRow("call") << QString("function() { f(); }") << QString("function () { f(); }"); + QTest::newRow("call") << QString("function() { f(a); }") << QString("function () { f(a); }"); + QTest::newRow("call") << QString("function() { f(a, b); }") << QString("function () { f(a, b); }"); + QTest::newRow("new") << QString("function() { new C(); }") << QString("function () { new C(); }"); + QTest::newRow("new") << QString("function() { new C(a); }") << QString("function () { new C(a); }"); + QTest::newRow("new") << QString("function() { new C(a, b); }") << QString("function () { new C(a, b); }"); + QTest::newRow("++") << QString("function() { a++; }") << QString("function () { a++; }"); + QTest::newRow("++") << QString("function() { ++a; }") << QString("function () { ++a; }"); + QTest::newRow("--") << QString("function() { a--; }") << QString("function () { a--; }"); + QTest::newRow("--") << QString("function() { --a; }") << QString("function () { --a; }"); + QTest::newRow("delete") << QString("function() { delete a; }") << QString("function () { delete a; }"); + QTest::newRow("void") << QString("function() { void a; }") << QString("function () { void a; }"); + QTest::newRow("typeof") << QString("function() { typeof a; }") << QString("function () { typeof a; }"); + QTest::newRow("+") << QString("function() { +a; }") << QString("function () { +a; }"); + QTest::newRow("-") << QString("function() { -a; }") << QString("function () { -a; }"); + QTest::newRow("~") << QString("function() { ~a; }") << QString("function () { ~a; }"); + QTest::newRow("!") << QString("function() { !a; }") << QString("function () { !a; }"); + QTest::newRow("+") << QString("function() { a + b; }") << QString("function () { a + b; }"); + QTest::newRow("&&") << QString("function() { a && b; }") << QString("function () { a && b; }"); + QTest::newRow("&=") << QString("function() { a &= b; }") << QString("function () { a &= b; }"); + QTest::newRow("=") << QString("function() { a = b; }") << QString("function () { a = b; }"); + QTest::newRow("&") << QString("function() { a & b; }") << QString("function () { a & b; }"); + QTest::newRow("|") << QString("function() { a | b; }") << QString("function () { a | b; }"); + QTest::newRow("^") << QString("function() { a ^ b; }") << QString("function () { a ^ b; }"); + QTest::newRow("-=") << QString("function() { a -= b; }") << QString("function () { a -= b; }"); + QTest::newRow("/") << QString("function() { a / b; }") << QString("function () { a / b; }"); + QTest::newRow("/=") << QString("function() { a /= b; }") << QString("function () { a /= b; }"); + QTest::newRow("==") << QString("function() { a == b; }") << QString("function () { a == b; }"); + QTest::newRow(">=") << QString("function() { a >= b; }") << QString("function () { a >= b; }"); + QTest::newRow(">") << QString("function() { a > b; }") << QString("function () { a > b; }"); + QTest::newRow("in") << QString("function() { a in b; }") << QString("function () { a in b; }"); + QTest::newRow("+=") << QString("function() { a += b; }") << QString("function () { a += b; }"); + QTest::newRow("instanceof") << QString("function() { a instanceof b; }") << QString("function () { a instanceof b; }"); + QTest::newRow("<=") << QString("function() { a <= b; }") << QString("function () { a <= b; }"); + QTest::newRow("<<") << QString("function() { a << b; }") << QString("function () { a << b; }"); + QTest::newRow("<<=") << QString("function() { a <<= b; }") << QString("function () { a <<= b; }"); + QTest::newRow("<") << QString("function() { a < b; }") << QString("function () { a < b; }"); + QTest::newRow("%") << QString("function() { a % b; }") << QString("function () { a % b; }"); + QTest::newRow("%=") << QString("function() { a %= b; }") << QString("function () { a %= b; }"); + QTest::newRow("*") << QString("function() { a * b; }") << QString("function () { a * b; }"); + QTest::newRow("*=") << QString("function() { a *= b; }") << QString("function () { a *= b; }"); + QTest::newRow("!=") << QString("function() { a != b; }") << QString("function () { a != b; }"); + QTest::newRow("||") << QString("function() { a || b; }") << QString("function () { a || b; }"); + QTest::newRow("|=") << QString("function() { a |= b; }") << QString("function () { a |= b; }"); + QTest::newRow(">>") << QString("function() { a >> b; }") << QString("function () { a >> b; }"); + QTest::newRow(">>=") << QString("function() { a >>= b; }") << QString("function () { a >>= b; }"); + QTest::newRow("===") << QString("function() { a === b; }") << QString("function () { a === b; }"); + QTest::newRow("!==") << QString("function() { a !== b; }") << QString("function () { a !== b; }"); + QTest::newRow("-") << QString("function() { a - b; }") << QString("function () { a - b; }"); + QTest::newRow(">>>") << QString("function() { a >>> b; }") << QString("function () { a >>> b; }"); + QTest::newRow(">>>=") << QString("function() { a >>>= b; }") << QString("function () { a >>>= b; }"); + QTest::newRow("^=") << QString("function() { a ^= b; }") << QString("function () { a ^= b; }"); + QTest::newRow("? :") << QString("function() { a ? b : c; }") << QString("function () { a ? b : c; }"); + QTest::newRow("a; b; c") << QString("function() { a; b; c; }") << QString("function () { a; b; c; }"); + QTest::newRow("var a;") << QString("function() { var a; }") << QString("function () { var a; }"); + QTest::newRow("var a, b;") << QString("function() { var a, b; }") << QString("function () { var a, b; }"); + QTest::newRow("var a = 10;") << QString("function() { var a = 10; }") << QString("function () { var a = 10; }"); + QTest::newRow("var a, b = 20;") << QString("function() { var a, b = 20; }") << QString("function () { var a, b = 20; }"); + QTest::newRow("var a = 10, b = 20;") << QString("function() { var a = 10, b = 20; }") << QString("function () { var a = 10, b = 20; }"); + QTest::newRow("if") << QString("function() { if (a) b; }") << QString("function () { if (a) b; }"); + QTest::newRow("if") << QString("function() { if (a) { b; c; } }") << QString("function () { if (a) { b; c; } }"); + QTest::newRow("if-else") << QString("function() { if (a) b; else c; }") << QString("function () { if (a) b; else c; }"); + QTest::newRow("if-else") << QString("function() { if (a) { b; c; } else { d; e; } }") << QString("function () { if (a) { b; c; } else { d; e; } }"); + QTest::newRow("do-while") << QString("function() { do { a; } while (b); }") << QString("function () { do { a; } while (b); }"); + QTest::newRow("do-while") << QString("function() { do { a; b; c; } while (d); }") << QString("function () { do { a; b; c; } while (d); }"); + QTest::newRow("while") << QString("function() { while (a) { b; } }") << QString("function () { while (a) { b; } }"); + QTest::newRow("while") << QString("function() { while (a) { b; c; } }") << QString("function () { while (a) { b; c; } }"); + QTest::newRow("for") << QString("function() { for (a; b; c) { } }") << QString("function () { for (a; b; c) { } }"); + QTest::newRow("for") << QString("function() { for (; a; b) { } }") << QString("function () { for (; a; b) { } }"); + QTest::newRow("for") << QString("function() { for (; ; a) { } }") << QString("function () { for (; ; a) { } }"); + QTest::newRow("for") << QString("function() { for (; ; ) { } }") << QString("function () { for (; ; ) { } }"); + QTest::newRow("for") << QString("function() { for (var a; b; c) { } }") << QString("function () { for (var a; b; c) { } }"); + QTest::newRow("for") << QString("function() { for (var a, b, c; d; e) { } }") << QString("function () { for (var a, b, c; d; e) { } }"); + QTest::newRow("continue") << QString("function() { for (; ; ) { continue; } }") << QString("function () { for (; ; ) { continue; } }"); + QTest::newRow("break") << QString("function() { for (; ; ) { break; } }") << QString("function () { for (; ; ) { break; } }"); + QTest::newRow("return") << QString("function() { return; }") << QString("function () { return; }"); + QTest::newRow("return") << QString("function() { return 10; }") << QString("function () { return 10; }"); + QTest::newRow("with") << QString("function() { with (a) { b; } }") << QString("function () { with (a) { b; } }"); + QTest::newRow("with") << QString("function() { with (a) { b; c; } }") << QString("function () { with (a) { b; c; } }"); + QTest::newRow("switch") << QString("function() { switch (a) { } }") << QString("function () { switch (a) { } }"); + QTest::newRow("switch") << QString("function() { switch (a) { case 1: ; } }") << QString("function () { switch (a) { case 1: ; } }"); + QTest::newRow("switch") << QString("function() { switch (a) { case 1: b; break; } }") << QString("function () { switch (a) { case 1: b; break; } }"); + QTest::newRow("switch") << QString("function() { switch (a) { case 1: b; break; case 2: break; } }") << QString("function () { switch (a) { case 1: b; break; case 2: break; } }"); + QTest::newRow("switch") << QString("function() { switch (a) { case 1: case 2: ; } }") << QString("function () { switch (a) { case 1: case 2: ; } }"); + QTest::newRow("switch") << QString("function() { switch (a) { case 1: default: ; } }") << QString("function () { switch (a) { case 1: default: ; } }"); + QTest::newRow("switch") << QString("function() { switch (a) { case 1: default: ; case 3: ; } }") << QString("function () { switch (a) { case 1: default: ; case 3: ; } }"); + QTest::newRow("label") << QString("function() { a: b; }") << QString("function () { a: b; }"); + QTest::newRow("throw") << QString("function() { throw a; }") << QString("function () { throw a; }"); + QTest::newRow("try-catch") << QString("function() { try { a; } catch (e) { b; } }") << QString("function () { try { a; } catch (e) { b; } }"); + QTest::newRow("try-finally") << QString("function() { try { a; } finally { b; } }") << QString("function () { try { a; } finally { b; } }"); + QTest::newRow("try-catch-finally") << QString("function() { try { a; } catch (e) { b; } finally { c; } }") << QString("function () { try { a; } catch (e) { b; } finally { c; } }"); + QTest::newRow("a + b + c + d") << QString("function() { a + b + c + d; }") << QString("function () { a + b + c + d; }"); + QTest::newRow("a + b - c") << QString("function() { a + b - c; }") << QString("function () { a + b - c; }"); + QTest::newRow("a + -b") << QString("function() { a + -b; }") << QString("function () { a + -b; }"); + QTest::newRow("a + ~b") << QString("function() { a + ~b; }") << QString("function () { a + ~b; }"); + QTest::newRow("a + !b") << QString("function() { a + !b; }") << QString("function () { a + !b; }"); + QTest::newRow("a + +b") << QString("function() { a + +b; }") << QString("function () { a + +b; }"); + QTest::newRow("(a + b) - c") << QString("function() { (a + b) - c; }") << QString("function () { (a + b) - c; }"); + QTest::newRow("(a - b + c") << QString("function() { a - b + c; }") << QString("function () { a - b + c; }"); + QTest::newRow("(a - (b + c)") << QString("function() { a - (b + c); }") << QString("function () { a - (b + c); }"); + QTest::newRow("a + -(b + c)") << QString("function() { a + -(b + c); }") << QString("function () { a + -(b + c); }"); + QTest::newRow("a + ~(b + c)") << QString("function() { a + ~(b + c); }") << QString("function () { a + ~(b + c); }"); + QTest::newRow("a + !(b + c)") << QString("function() { a + !(b + c); }") << QString("function () { a + !(b + c); }"); + QTest::newRow("a + +(b + c)") << QString("function() { a + +(b + c); }") << QString("function () { a + +(b + c); }"); + QTest::newRow("a + b * c") << QString("function() { a + b * c; }") << QString("function () { a + b * c; }"); + QTest::newRow("(a + b) * c") << QString("function() { (a + b) * c; }") << QString("function () { (a + b) * c; }"); + QTest::newRow("(a + b) * (c + d)") << QString("function() { (a + b) * (c + d); }") << QString("function () { (a + b) * (c + d); }"); + QTest::newRow("a + (b * c)") << QString("function() { a + (b * c); }") << QString("function () { a + (b * c); }"); + QTest::newRow("a + (b / c)") << QString("function() { a + (b / c); }") << QString("function () { a + (b / c); }"); + QTest::newRow("(a / b) * c") << QString("function() { (a / b) * c; }") << QString("function () { (a / b) * c; }"); + QTest::newRow("a / (b * c)") << QString("function() { a / (b * c); }") << QString("function () { a / (b * c); }"); + QTest::newRow("a / (b % c)") << QString("function() { a / (b % c); }") << QString("function () { a / (b % c); }"); + QTest::newRow("a && b || c") << QString("function() { a && b || c; }") << QString("function () { a && b || c; }"); + QTest::newRow("a && (b || c)") << QString("function() { a && (b || c); }") << QString("function () { a && (b || c); }"); + QTest::newRow("a & b | c") << QString("function() { a & b | c; }") << QString("function () { a & b | c; }"); + QTest::newRow("a & (b | c)") << QString("function() { a & (b | c); }") << QString("function () { a & (b | c); }"); + QTest::newRow("a & b | c ^ d") << QString("function() { a & b | c ^ d; }") << QString("function () { a & b | c ^ d; }"); + QTest::newRow("a & (b | c ^ d)") << QString("function() { a & (b | c ^ d); }") << QString("function () { a & (b | c ^ d); }"); + QTest::newRow("(a & b | c) ^ d") << QString("function() { (a & b | c) ^ d; }") << QString("function () { (a & b | c) ^ d; }"); + QTest::newRow("a << b + c") << QString("function() { a << b + c; }") << QString("function () { a << b + c; }"); + QTest::newRow("(a << b) + c") << QString("function() { (a << b) + c; }") << QString("function () { (a << b) + c; }"); + QTest::newRow("a >> b + c") << QString("function() { a >> b + c; }") << QString("function () { a >> b + c; }"); + QTest::newRow("(a >> b) + c") << QString("function() { (a >> b) + c; }") << QString("function () { (a >> b) + c; }"); + QTest::newRow("a >>> b + c") << QString("function() { a >>> b + c; }") << QString("function () { a >>> b + c; }"); + QTest::newRow("(a >>> b) + c") << QString("function() { (a >>> b) + c; }") << QString("function () { (a >>> b) + c; }"); + QTest::newRow("a == b || c != d") << QString("function() { a == b || c != d; }") << QString("function () { a == b || c != d; }"); + QTest::newRow("a == (b || c != d)") << QString("function() { a == (b || c != d); }") << QString("function () { a == (b || c != d); }"); + QTest::newRow("a === b || c !== d") << QString("function() { a === b || c !== d; }") << QString("function () { a === b || c !== d; }"); + QTest::newRow("a === (b || c !== d)") << QString("function() { a === (b || c !== d); }") << QString("function () { a === (b || c !== d); }"); + QTest::newRow("a &= b + c") << QString("function() { a &= b + c; }") << QString("function () { a &= b + c; }"); + QTest::newRow("debugger") << QString("function() { debugger; }") << QString("function () { debugger; }"); +} + +void tst_QJSValue::prettyPrinter() +{ + QFETCH(QString, function); + QFETCH(QString, expected); + QJSEngine eng; + QJSValue val = eng.evaluate("(" + function + ")"); + QVERIFY(val.isFunction()); + QString actual = val.toString(); + int count = qMin(actual.size(), expected.size()); +// qDebug() << actual << expected; + for (int i = 0; i < count; ++i) { +// qDebug() << i << actual.at(i) << expected.at(i); + QCOMPARE(actual.at(i), expected.at(i)); + } + QCOMPARE(actual.size(), expected.size()); +} + +void tst_QJSValue::engineDeleted() +{ + QJSEngine *eng = new QJSEngine; + QJSValue v1(eng, 123); + QVERIFY(v1.isNumber()); + QJSValue v2(eng, QString("ciao")); + QVERIFY(v2.isString()); + QJSValue v3 = eng->newObject(); + QVERIFY(v3.isObject()); + QJSValue v4 = eng->newQObject(this); + QVERIFY(v4.isQObject()); + QJSValue v5 = "Hello"; + QVERIFY(v2.isString()); + + delete eng; + + QVERIFY(!v1.isValid()); + QVERIFY(v1.engine() == 0); + QVERIFY(!v2.isValid()); + QVERIFY(v2.engine() == 0); + QVERIFY(!v3.isValid()); + QVERIFY(v3.engine() == 0); + QVERIFY(!v4.isValid()); + QVERIFY(v4.engine() == 0); + QVERIFY(v5.isValid()); + QVERIFY(v5.engine() == 0); + + QVERIFY(!v3.property("foo").isValid()); +} + +void tst_QJSValue::valueOfWithClosure() +{ + QJSEngine eng; + // valueOf() + { + QJSValue obj = eng.evaluate("o = {}; (function(foo) { o.valueOf = function() { return foo; } })(123); o"); + QVERIFY(obj.isObject()); + QCOMPARE(obj.toInt32(), 123); + } + // toString() + { + QJSValue obj = eng.evaluate("o = {}; (function(foo) { o.toString = function() { return foo; } })('ciao'); o"); + QVERIFY(obj.isObject()); + QCOMPARE(obj.toString(), QString::fromLatin1("ciao")); + } +} + +#if 0 // FIXME: no objectId() +void tst_QJSValue::objectId() +{ + QCOMPARE(QJSValue().objectId(), (qint64)-1); + QCOMPARE(QJSValue(QJSValue::UndefinedValue).objectId(), (qint64)-1); + QCOMPARE(QJSValue(QJSValue::NullValue).objectId(), (qint64)-1); + QCOMPARE(QJSValue(false).objectId(), (qint64)-1); + QCOMPARE(QJSValue(123).objectId(), (qint64)-1); + QCOMPARE(QJSValue(uint(123)).objectId(), (qint64)-1); + QCOMPARE(QJSValue(123.5).objectId(), (qint64)-1); + QCOMPARE(QJSValue("ciao").objectId(), (qint64)-1); + + QScriptEngine eng; + QJSValue o1 = eng.newObject(); + QVERIFY(o1.objectId() != -1); + QJSValue o2 = eng.newObject(); + QVERIFY(o2.objectId() != -1); + QVERIFY(o1.objectId() != o2.objectId()); + + QVERIFY(eng.objectById(o1.objectId()).strictlyEquals(o1)); + QVERIFY(eng.objectById(o2.objectId()).strictlyEquals(o2)); + + qint64 globalObjectId = -1; + { + QJSValue global = eng.globalObject(); + globalObjectId = global.objectId(); + QVERIFY(globalObjectId != -1); + QVERIFY(eng.objectById(globalObjectId).strictlyEquals(global)); + } + QJSValue obj = eng.objectById(globalObjectId); + QVERIFY(obj.isObject()); + QVERIFY(obj.strictlyEquals(eng.globalObject())); +} +#endif + +void tst_QJSValue::nestedObjectToVariant_data() +{ + QTest::addColumn<QString>("program"); + QTest::addColumn<QVariant>("expected"); + + // Array literals + QTest::newRow("[[]]") + << QString::fromLatin1("[[]]") + << QVariant(QVariantList() << (QVariant(QVariantList()))); + QTest::newRow("[[123]]") + << QString::fromLatin1("[[123]]") + << QVariant(QVariantList() << (QVariant(QVariantList() << 123))); + QTest::newRow("[[], 123]") + << QString::fromLatin1("[[], 123]") + << QVariant(QVariantList() << QVariant(QVariantList()) << 123); + + // Cyclic arrays + QTest::newRow("var a=[]; a.push(a)") + << QString::fromLatin1("var a=[]; a.push(a); a") + << QVariant(QVariantList() << QVariant(QVariantList())); + QTest::newRow("var a=[]; a.push(123, a)") + << QString::fromLatin1("var a=[]; a.push(123, a); a") + << QVariant(QVariantList() << 123 << QVariant(QVariantList())); + QTest::newRow("var a=[]; var b=[]; a.push(b); b.push(a)") + << QString::fromLatin1("var a=[]; var b=[]; a.push(b); b.push(a); a") + << QVariant(QVariantList() << QVariant(QVariantList() << QVariant(QVariantList()))); + QTest::newRow("var a=[]; var b=[]; a.push(123, b); b.push(456, a)") + << QString::fromLatin1("var a=[]; var b=[]; a.push(123, b); b.push(456, a); a") + << QVariant(QVariantList() << 123 << QVariant(QVariantList() << 456 << QVariant(QVariantList()))); + + // Object literals + { + QVariantMap m; + m["a"] = QVariantMap(); + QTest::newRow("{ a:{} }") + << QString::fromLatin1("({ a:{} })") + << QVariant(m); + } + { + QVariantMap m, m2; + m2["b"] = 10; + m2["c"] = 20; + m["a"] = m2; + QTest::newRow("{ a:{b:10, c:20} }") + << QString::fromLatin1("({ a:{b:10, c:20} })") + << QVariant(m); + } + { + QVariantMap m; + m["a"] = 10; + m["b"] = QVariantList() << 20 << 30; + QTest::newRow("{ a:10, b:[20, 30]}") + << QString::fromLatin1("({ a:10, b:[20,30]})") + << QVariant(m); + } + + // Cyclic objects + { + QVariantMap m; + m["p"] = QVariantMap(); + QTest::newRow("var o={}; o.p=o") + << QString::fromLatin1("var o={}; o.p=o; o") + << QVariant(m); + } + { + QVariantMap m; + m["p"] = 123; + m["q"] = QVariantMap(); + QTest::newRow("var o={}; o.p=123; o.q=o") + << QString::fromLatin1("var o={}; o.p=123; o.q=o; o") + << QVariant(m); + } +} + +void tst_QJSValue::nestedObjectToVariant() +{ + QJSEngine eng; + QFETCH(QString, program); + QFETCH(QVariant, expected); + QJSValue o = eng.evaluate(program); + QVERIFY(!o.isError()); + QVERIFY(o.isObject()); + QCOMPARE(o.toVariant(), expected); +} + +void tst_QJSValue::propertyFlags_data() +{ + QTest::addColumn<QString>("program"); + QTest::addColumn<uint>("expected"); + + QTest::newRow("nothing") << "" << 0u; +#if 0 // FIXME: No getter/setter API + QTest::newRow("getter") << "o.__defineGetter__('prop', function() { return 'blah' } );\n" << uint(QJSValue::PropertyGetter); + QTest::newRow("setter") << "o.__defineSetter__('prop', function(a) { this.setted_prop2 = a; } );\n" << uint(QJSValue::PropertySetter); + QTest::newRow("getterSetter") << "o.__defineGetter__('prop', function() { return 'ploup' } );\n" + "o.__defineSetter__('prop', function(a) { this.setted_prop3 = a; } );\n" << uint(QJSValue::PropertySetter|QJSValue::PropertyGetter); +#endif + QTest::newRow("nothing2") << "o.prop = 'nothing'" << 0u; +} + +void tst_QJSValue::propertyFlags() +{ + QFETCH(QString, program); + QFETCH(uint, expected); + QJSEngine eng; + eng.evaluate("o = new Object;"); + eng.evaluate(program); + QJSValue o = eng.evaluate("o"); + + QCOMPARE(uint(o.propertyFlags("prop")), expected); +} + + +QTEST_MAIN(tst_QJSValue) diff --git a/tests/auto/declarative/qjsvalue/tst_qjsvalue.h b/tests/auto/declarative/qjsvalue/tst_qjsvalue.h new file mode 100644 index 0000000000..b605066aef --- /dev/null +++ b/tests/auto/declarative/qjsvalue/tst_qjsvalue.h @@ -0,0 +1,205 @@ +/**************************************************************************** +** +** 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$ +** +****************************************************************************/ + +#ifndef TST_QJSVALUE_H +#define TST_QJSVALUE_H + +#include <QtCore/qobject.h> +#include <QtCore/qnumeric.h> +#include <qjsengine.h> +#include <qjsvalue.h> +#include <QtTest/QtTest> + +Q_DECLARE_METATYPE(QVariant) +Q_DECLARE_METATYPE(QJSValue) + +class tst_QJSValue : public QObject +{ + Q_OBJECT + +public: + tst_QJSValue(); + virtual ~tst_QJSValue(); + +private slots: + void toObject(); + + void ctor_invalid(); + void ctor_undefinedWithEngine(); + void ctor_undefined(); + void ctor_nullWithEngine(); + void ctor_null(); + void ctor_boolWithEngine(); + void ctor_bool(); + void ctor_intWithEngine(); + void ctor_int(); + void ctor_uintWithEngine(); + void ctor_uint(); + void ctor_floatWithEngine(); + void ctor_float(); + void ctor_stringWithEngine(); + void ctor_string(); + void ctor_copyAndAssignWithEngine(); + void ctor_copyAndAssign(); + void ctor_nullEngine(); + + void toString(); + void toNumber(); + void toBoolean(); + void toBool(); + void toInteger(); + void toInt32(); + void toUInt32(); + void toUInt16(); + void toVariant(); + void toQObject_nonQObject_data(); + void toQObject_nonQObject(); + void toQObject(); + void toDateTime(); + void toRegExp(); + void instanceOf_twoEngines(); + void instanceOf(); + void isArray_data(); + void isArray(); + void isDate(); + void isDate_data(); + void isError_propertiesOfGlobalObject(); + void isError_data(); + void isError(); + void isRegExp_data(); + void isRegExp(); + +#if 0 // FIXME: No QScriptValue::lessThan + void lessThan(); +#endif + void equals(); + void strictlyEquals(); + + void getSetPrototype_cyclicPrototype(); + void getSetPrototype_evalCyclicPrototype(); + void getSetPrototype_eval(); + void getSetPrototype_invalidPrototype(); + void getSetPrototype_twoEngines(); + void getSetPrototype_null(); + void getSetPrototype_notObjectOrNull(); + void getSetPrototype(); + void getSetScope(); + void getSetProperty_HooliganTask162051(); + void getSetProperty_HooliganTask183072(); + void getSetProperty_propertyRemoval(); + void getSetProperty_resolveMode(); + void getSetProperty_twoEngines(); + void getSetProperty_gettersAndSetters(); + void getSetProperty_gettersAndSettersThrowErrorNative(); + void getSetProperty_gettersAndSettersThrowErrorJS(); + void getSetProperty_gettersAndSettersOnNative(); + void getSetProperty_gettersAndSettersOnGlobalObject(); + void getSetProperty_gettersAndSettersChange(); + void getSetProperty_gettersAndSettersStupid(); + void getSetProperty_array(); + void getSetProperty(); + void arrayElementGetterSetter(); + void getSetData_objects_data(); + void getSetData_objects(); + void getSetData_nonObjects_data(); + void getSetData_nonObjects(); + void setData_QTBUG15144(); +#if 0 // FIXME: no QScriptClass + void getSetScriptClass_emptyClass_data(); + void getSetScriptClass_emptyClass(); + void getSetScriptClass_JSObjectFromCpp(); + void getSetScriptClass_JSObjectFromJS(); + void getSetScriptClass_QVariant(); + void getSetScriptClass_QObject(); +#endif + void call_function(); + void call_object(); + void call_newObjects(); + void call_this(); + void call_arguments(); + void call(); + void call_invalidArguments(); + void call_invalidReturn(); + void call_twoEngines(); + void call_array(); + void call_nonFunction_data(); + void call_nonFunction(); + void construct_nonFunction_data(); + void construct_nonFunction(); + void construct_simple(); + void construct_newObjectJS(); +#if 0 // FIXME: no c-style callbacks + void construct_undefined(); + void construct_newObjectCpp(); +#endif + void construct_arg(); + void construct_proto(); + void construct_returnInt(); + void construct_throw(); +#if 0 // FIXME: The feature of interpreting an array as argument list has been removed from the API + void construct(); +#endif + void construct_twoEngines(); + void construct_constructorThrowsPrimitive(); + void castToPointer(); + void prettyPrinter_data(); + void prettyPrinter(); + void engineDeleted(); + void valueOfWithClosure(); +#if 0 // FIXME: no objectId() + void objectId(); +#endif + void nestedObjectToVariant_data(); + void nestedObjectToVariant(); + void propertyFlags_data(); + void propertyFlags(); + +private: + void newEngine() + { + if (engine) + delete engine; + engine = new QJSEngine(); + } + QJSEngine *engine; +}; + +#endif diff --git a/tests/auto/declarative/qjsvalueiterator/qjsvalueiterator.pro b/tests/auto/declarative/qjsvalueiterator/qjsvalueiterator.pro new file mode 100644 index 0000000000..e5137fcdf1 --- /dev/null +++ b/tests/auto/declarative/qjsvalueiterator/qjsvalueiterator.pro @@ -0,0 +1,5 @@ +load(qttest_p4) +QT = core declarative +SOURCES += tst_qjsvalueiterator.cpp + + diff --git a/tests/auto/declarative/qjsvalueiterator/tst_qjsvalueiterator.cpp b/tests/auto/declarative/qjsvalueiterator/tst_qjsvalueiterator.cpp new file mode 100644 index 0000000000..1cd5952c54 --- /dev/null +++ b/tests/auto/declarative/qjsvalueiterator/tst_qjsvalueiterator.cpp @@ -0,0 +1,527 @@ +/**************************************************************************** +** +** 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 <QtTest/QtTest> + +#include <QJSEngine> +#include <QJSValue> +#include <QJSValueIterator> + +//TESTED_CLASS= +//TESTED_FILES= + +Q_DECLARE_METATYPE(QJSValue); + +class tst_QJSValueIterator : public QObject +{ + Q_OBJECT + +public: + tst_QJSValueIterator(); + virtual ~tst_QJSValueIterator(); + +private slots: + void iterateForward_data(); + void iterateForward(); + void iterateArray_data(); + void iterateArray(); + void iterateString(); +#if 0 + void iterateGetterSetter(); +#endif + void assignObjectToIterator(); + void iterateNonObject(); + void iterateOverObjectFromDeletedEngine(); +}; + +tst_QJSValueIterator::tst_QJSValueIterator() +{ +} + +tst_QJSValueIterator::~tst_QJSValueIterator() +{ +} + +void tst_QJSValueIterator::iterateForward_data() +{ + QTest::addColumn<QStringList>("propertyNames"); + QTest::addColumn<QStringList>("propertyValues"); + + QTest::newRow("no properties") + << QStringList() << QStringList(); + QTest::newRow("foo=bar") + << (QStringList() << "foo") + << (QStringList() << "bar"); + QTest::newRow("foo=bar, baz=123") + << (QStringList() << "foo" << "baz") + << (QStringList() << "bar" << "123"); + QTest::newRow("foo=bar, baz=123, rab=oof") + << (QStringList() << "foo" << "baz" << "rab") + << (QStringList() << "bar" << "123" << "oof"); +} + +void tst_QJSValueIterator::iterateForward() +{ + QFETCH(QStringList, propertyNames); + QFETCH(QStringList, propertyValues); + QMap<QString, QString> pmap; + QVERIFY(propertyNames.size() == propertyValues.size()); + + QJSEngine engine; + QJSValue object = engine.newObject(); + for (int i = 0; i < propertyNames.size(); ++i) { + QString name = propertyNames.at(i); + QString value = propertyValues.at(i); + pmap.insert(name, value); + object.setProperty(name, QJSValue(&engine, value)); + } + QJSValue otherObject = engine.newObject(); + otherObject.setProperty("foo", QJSValue(&engine, 123456)); + otherObject.setProperty("protoProperty", QJSValue(&engine, 654321)); + object.setPrototype(otherObject); // should not affect iterator + + QStringList lst; + QJSValueIterator it(object); + while (!pmap.isEmpty()) { + QCOMPARE(it.hasNext(), true); + QCOMPARE(it.hasNext(), true); + it.next(); + QString name = it.name(); + QCOMPARE(pmap.contains(name), true); + QCOMPARE(it.name(), name); + QCOMPARE(it.value().strictlyEquals(QJSValue(&engine, pmap.value(name))), true); + pmap.remove(name); + lst.append(name); + } + + QCOMPARE(it.hasNext(), false); + QCOMPARE(it.hasNext(), false); + + it = object; + for (int i = 0; i < lst.count(); ++i) { + QCOMPARE(it.hasNext(), true); + it.next(); + QCOMPARE(it.name(), lst.at(i)); + } +} + +void tst_QJSValueIterator::iterateArray_data() +{ + QTest::addColumn<QStringList>("propertyNames"); + QTest::addColumn<QStringList>("propertyValues"); + + QTest::newRow("no elements") << QStringList() << QStringList(); + + QTest::newRow("0=foo, 1=barr") + << (QStringList() << "0" << "1") + << (QStringList() << "foo" << "bar"); + + + QTest::newRow("0=foo, 3=barr") + << (QStringList() << "0" << "1" << "2" << "3") + << (QStringList() << "foo" << "" << "" << "bar"); +} + +void tst_QJSValueIterator::iterateArray() +{ + QFETCH(QStringList, propertyNames); + QFETCH(QStringList, propertyValues); + + QJSEngine engine; + QJSValue array = engine.newArray(); + + // Fill the array + for (int i = 0; i < propertyNames.size(); ++i) { + array.setProperty(propertyNames.at(i), propertyValues.at(i)); + } + + // Iterate thru array properties. Note that the QJSValueIterator doesn't guarantee + // any order on the iteration! + int length = array.property("length").toInt32(); + QCOMPARE(length, propertyNames.size()); + + bool iteratedThruLength = false; + QHash<QString, QJSValue> arrayProperties; + QJSValueIterator it(array); + + // Iterate forward + while (it.hasNext()) { + it.next(); + + const QString name = it.name(); + if (name == QString::fromLatin1("length")) { + QVERIFY(it.value().isNumber()); + QCOMPARE(it.value().toInt32(), length); + QVERIFY2(!iteratedThruLength, "'length' appeared more than once during iteration."); + iteratedThruLength = true; + continue; + } + + // Storing the properties we iterate in a hash to compare with test data. + QVERIFY2(!arrayProperties.contains(name), "property appeared more than once during iteration."); + arrayProperties.insert(name, it.value()); + QVERIFY(it.value().strictlyEquals(array.property(name))); + } + + // Verify properties + QVERIFY(iteratedThruLength); + QCOMPARE(arrayProperties.size(), propertyNames.size()); + for (int i = 0; i < propertyNames.size(); ++i) { + QVERIFY(arrayProperties.contains(propertyNames.at(i))); + QCOMPARE(arrayProperties.value(propertyNames.at(i)).toString(), propertyValues.at(i)); + } + +#if 0 + + // Iterate backwards + arrayProperties.clear(); + iteratedThruLength = false; + it.toBack(); + + while (it.hasPrevious()) { + it.previous(); + + const QString name = it.name(); + if (name == QString::fromLatin1("length")) { + QVERIFY(it.value().isNumber()); + QCOMPARE(it.value().toInt32(), length); + QCOMPARE(it.flags(), QScriptValue::SkipInEnumeration | QScriptValue::Undeletable); + QVERIFY2(!iteratedThruLength, "'length' appeared more than once during iteration."); + iteratedThruLength = true; + continue; + } + + // Storing the properties we iterate in a hash to compare with test data. + QVERIFY2(!arrayProperties.contains(name), "property appeared more than once during iteration."); + arrayProperties.insert(name, it.value()); + QCOMPARE(it.flags(), array.propertyFlags(name)); + QVERIFY(it.value().strictlyEquals(array.property(name))); + } + + // Verify properties + QVERIFY(iteratedThruLength); + QCOMPARE(arrayProperties.size(), propertyNames.size()); + for (int i = 0; i < propertyNames.size(); ++i) { + QVERIFY(arrayProperties.contains(propertyNames.at(i))); + QCOMPARE(arrayProperties.value(propertyNames.at(i)).toString(), propertyValues.at(i)); + } + + // ### Do we still need this test? + // Forward test again but as object + arrayProperties.clear(); + iteratedThruLength = false; + QJSValue arrayObject = engine.toObject(array); + QJSValueIterator it2(arrayObject); + + while (it2.hasNext()) { + it2.next(); + + const QString name = it2.name(); + if (name == QString::fromLatin1("length")) { + QVERIFY(it2.value().isNumber()); + QCOMPARE(it2.value().toInt32(), length); + QCOMPARE(it2.flags(), QScriptValue::SkipInEnumeration | QScriptValue::Undeletable); + QVERIFY2(!iteratedThruLength, "'length' appeared more than once during iteration."); + iteratedThruLength = true; + continue; + } + + // Storing the properties we iterate in a hash to compare with test data. + QVERIFY2(!arrayProperties.contains(name), "property appeared more than once during iteration."); + arrayProperties.insert(name, it2.value()); + QCOMPARE(it2.flags(), arrayObject.propertyFlags(name)); + QVERIFY(it2.value().strictlyEquals(arrayObject.property(name))); + } + + // Verify properties + QVERIFY(iteratedThruLength); + QCOMPARE(arrayProperties.size(), propertyNames.size()); + for (int i = 0; i < propertyNames.size(); ++i) { + QVERIFY(arrayProperties.contains(propertyNames.at(i))); + QCOMPARE(arrayProperties.value(propertyNames.at(i)).toString(), propertyValues.at(i)); + } +#endif +} + +void tst_QJSValueIterator::iterateString() +{ + QJSEngine engine; + QJSValue str = QJSValue(&engine, QString::fromLatin1("ciao")); + QVERIFY(str.isString()); + QJSValue obj = str.toObject(); + QVERIFY(obj.property("length").isNumber()); + int length = obj.property("length").toInt32(); + QCOMPARE(length, 4); + + QJSValueIterator it(obj); + QHash<QString, QJSValue> stringProperties; + bool iteratedThruLength = false; + + while (it.hasNext()) { + it.next(); + const QString name = it.name(); + + if (name == QString::fromLatin1("length")) { + QVERIFY(it.value().isNumber()); + QCOMPARE(it.value().toInt32(), length); + QVERIFY2(!iteratedThruLength, "'length' appeared more than once during iteration."); + iteratedThruLength = true; + continue; + } + + QVERIFY2(!stringProperties.contains(name), "property appeared more than once during iteration."); + stringProperties.insert(name, it.value()); + QVERIFY(it.value().strictlyEquals(obj.property(name))); + } + + QVERIFY(iteratedThruLength); + QCOMPARE(stringProperties.size(), length); +#if 0 + // And going backwards + iteratedThruLength = false; + stringProperties.clear(); + it.toBack(); + + while (it.hasPrevious()) { + it.previous(); + const QString name = it.name(); + + if (name == QString::fromLatin1("length")) { + QVERIFY(it.value().isNumber()); + QCOMPARE(it.value().toInt32(), length); + QVERIFY2(!iteratedThruLength, "'length' appeared more than once during iteration."); + iteratedThruLength = true; + continue; + } + + QVERIFY2(!stringProperties.contains(name), "property appeared more than once during iteration."); + stringProperties.insert(name, it.value()); + QVERIFY(it.value().strictlyEquals(obj.property(name))); + } +#endif +} + +#if 0 // FIXME what we should to keep from here? +static QJSValue myGetterSetter(QScriptContext *ctx, QJSEngine *) +{ + if (ctx->argumentCount() == 1) + ctx->thisObject().setProperty("bar", ctx->argument(0)); + return ctx->thisObject().property("bar"); +} + +static QJSValue myGetter(QScriptContext *ctx, QJSEngine *) +{ + return ctx->thisObject().property("bar"); +} + +static QJSValue mySetter(QScriptContext *ctx, QJSEngine *) +{ + ctx->thisObject().setProperty("bar", ctx->argument(0)); + return ctx->argument(0); +} + +void tst_QJSValueIterator::iterateGetterSetter() +{ + // unified getter/setter function + { + QJSEngine eng; + QJSValue obj = eng.newObject(); + obj.setProperty("foo", eng.newFunction(myGetterSetter), + QScriptValue::PropertyGetter | QScriptValue::PropertySetter); + QJSValue val(&eng, 123); + obj.setProperty("foo", val); + QVERIFY(obj.property("bar").strictlyEquals(val)); + QVERIFY(obj.property("foo").strictlyEquals(val)); + + QJSValueIterator it(obj); + QVERIFY(it.hasNext()); + it.next(); + QCOMPARE(it.name(), QString::fromLatin1("foo")); + QCOMPARE(it.flags(), QScriptValue::PropertyFlags(QScriptValue::PropertyGetter | QScriptValue::PropertySetter)); + QVERIFY(it.value().strictlyEquals(val)); + QJSValue val2(&eng, 456); + it.setValue(val2); + QVERIFY(obj.property("bar").strictlyEquals(val2)); + QVERIFY(obj.property("foo").strictlyEquals(val2)); + + QVERIFY(it.hasNext()); + it.next(); + QCOMPARE(it.name(), QString::fromLatin1("bar")); + QVERIFY(!it.hasNext()); + + QVERIFY(it.hasPrevious()); + it.previous(); + QCOMPARE(it.name(), QString::fromLatin1("bar")); + QVERIFY(it.hasPrevious()); + it.previous(); + QCOMPARE(it.name(), QString::fromLatin1("foo")); + QCOMPARE(it.flags(), QScriptValue::PropertyFlags(QScriptValue::PropertyGetter | QScriptValue::PropertySetter)); + QVERIFY(it.value().strictlyEquals(val2)); + it.setValue(val); + QVERIFY(obj.property("bar").strictlyEquals(val)); + QVERIFY(obj.property("foo").strictlyEquals(val)); + } + // separate getter/setter function + for (int x = 0; x < 2; ++x) { + QJSEngine eng; + QJSValue obj = eng.newObject(); + if (x == 0) { + obj.setProperty("foo", eng.newFunction(myGetter), QScriptValue::PropertyGetter); + obj.setProperty("foo", eng.newFunction(mySetter), QScriptValue::PropertySetter); + } else { + obj.setProperty("foo", eng.newFunction(mySetter), QScriptValue::PropertySetter); + obj.setProperty("foo", eng.newFunction(myGetter), QScriptValue::PropertyGetter); + } + QJSValue val(&eng, 123); + obj.setProperty("foo", val); + QVERIFY(obj.property("bar").strictlyEquals(val)); + QVERIFY(obj.property("foo").strictlyEquals(val)); + + QJSValueIterator it(obj); + QVERIFY(it.hasNext()); + it.next(); + QCOMPARE(it.name(), QString::fromLatin1("foo")); + QVERIFY(it.value().strictlyEquals(val)); + QJSValue val2(&eng, 456); + it.setValue(val2); + QVERIFY(obj.property("bar").strictlyEquals(val2)); + QVERIFY(obj.property("foo").strictlyEquals(val2)); + + QVERIFY(it.hasNext()); + it.next(); + QCOMPARE(it.name(), QString::fromLatin1("bar")); + QVERIFY(!it.hasNext()); + + QVERIFY(it.hasPrevious()); + it.previous(); + QCOMPARE(it.name(), QString::fromLatin1("bar")); + QVERIFY(it.hasPrevious()); + it.previous(); + QCOMPARE(it.name(), QString::fromLatin1("foo")); + QVERIFY(it.value().strictlyEquals(val2)); + it.setValue(val); + QVERIFY(obj.property("bar").strictlyEquals(val)); + QVERIFY(obj.property("foo").strictlyEquals(val)); + } +} +#endif + +void tst_QJSValueIterator::assignObjectToIterator() +{ + QJSEngine eng; + QJSValue obj1 = eng.newObject(); + obj1.setProperty("foo", 123); + QJSValue obj2 = eng.newObject(); + obj2.setProperty("bar", 456); + + QJSValueIterator it(obj1); + QVERIFY(it.hasNext()); + it.next(); + it = obj2; + QVERIFY(it.hasNext()); + it.next(); + QCOMPARE(it.name(), QString::fromLatin1("bar")); + + it = obj1; + QVERIFY(it.hasNext()); + it.next(); + QCOMPARE(it.name(), QString::fromLatin1("foo")); + + it = obj2; + QVERIFY(it.hasNext()); + it.next(); + QCOMPARE(it.name(), QString::fromLatin1("bar")); + + it = obj2; + QVERIFY(it.hasNext()); + it.next(); + QCOMPARE(it.name(), QString::fromLatin1("bar")); +} + +void tst_QJSValueIterator::iterateNonObject() +{ + QJSValueIterator it(123); + QVERIFY(!it.hasNext()); + it.next(); + it.name(); + it.value(); + QJSValue num(5); + it = num; + QVERIFY(!it.hasNext()); +} + +void tst_QJSValueIterator::iterateOverObjectFromDeletedEngine() +{ + QJSEngine *engine = new QJSEngine; + QJSValue objet = engine->newObject(); + + // populate object with properties + QHash<QString, int> properties; + properties.insert("foo",1235); + properties.insert("oof",5321); + properties.insert("ofo",3521); + QHash<QString, int>::const_iterator i = properties.constBegin(); + for (; i != properties.constEnd(); ++i) { + objet.setProperty(i.key(), i.value()); + } + + // start iterating + QJSValueIterator it(objet); + it.next(); + QVERIFY(properties.contains(it.name())); + + delete engine; + + QVERIFY(!objet.isValid()); + QVERIFY(it.name().isEmpty()); + QVERIFY(!it.value().isValid()); + + QVERIFY(!it.hasNext()); + it.next(); + + QVERIFY(it.name().isEmpty()); + QVERIFY(!it.value().isValid()); + +} + +QTEST_MAIN(tst_QJSValueIterator) +#include "tst_qjsvalueiterator.moc" diff --git a/tests/auto/declarative/qsganimatedimage/qsganimatedimage.pro b/tests/auto/declarative/qsganimatedimage/qsganimatedimage.pro index c1a3f00aff..5da2ba95b9 100644 --- a/tests/auto/declarative/qsganimatedimage/qsganimatedimage.pro +++ b/tests/auto/declarative/qsganimatedimage/qsganimatedimage.pro @@ -15,4 +15,3 @@ symbian: { CONFIG += parallel_test QT += core-private gui-private declarative-private -QT += script-private diff --git a/tests/auto/declarative/qsgborderimage/qsgborderimage.pro b/tests/auto/declarative/qsgborderimage/qsgborderimage.pro index f75405bf43..db7fe77e1d 100644 --- a/tests/auto/declarative/qsgborderimage/qsgborderimage.pro +++ b/tests/auto/declarative/qsgborderimage/qsgborderimage.pro @@ -16,4 +16,3 @@ symbian: { CONFIG += parallel_test QT += core-private gui-private declarative-private -QT += script-private diff --git a/tests/auto/declarative/qsgflickable/qsgflickable.pro b/tests/auto/declarative/qsgflickable/qsgflickable.pro index 70956f3755..d5e5767e90 100644 --- a/tests/auto/declarative/qsgflickable/qsgflickable.pro +++ b/tests/auto/declarative/qsgflickable/qsgflickable.pro @@ -15,4 +15,3 @@ symbian: { CONFIG += parallel_test QT += core-private gui-private declarative-private -QT += script-private diff --git a/tests/auto/declarative/qsgflipable/qsgflipable.pro b/tests/auto/declarative/qsgflipable/qsgflipable.pro index 6cd52ec85f..c3998c1f9c 100644 --- a/tests/auto/declarative/qsgflipable/qsgflipable.pro +++ b/tests/auto/declarative/qsgflipable/qsgflipable.pro @@ -15,4 +15,3 @@ symbian: { CONFIG += parallel_test QT += core-private gui-private declarative-private -QT += script-private diff --git a/tests/auto/declarative/qsggridview/qsggridview.pro b/tests/auto/declarative/qsggridview/qsggridview.pro index 963df7a9b7..a8b3484f0d 100644 --- a/tests/auto/declarative/qsggridview/qsggridview.pro +++ b/tests/auto/declarative/qsggridview/qsggridview.pro @@ -15,5 +15,4 @@ symbian: { CONFIG += parallel_test QT += core-private gui-private declarative-private -QT += script-private QT += opengl-private diff --git a/tests/auto/declarative/qsgitem2/qsgitem.pro b/tests/auto/declarative/qsgitem2/qsgitem.pro index 9226b4178d..afab61dec3 100644 --- a/tests/auto/declarative/qsgitem2/qsgitem.pro +++ b/tests/auto/declarative/qsgitem2/qsgitem.pro @@ -15,5 +15,4 @@ symbian: { CONFIG += parallel_test QT += core-private gui-private declarative-private -QT += script-private opengl-private QT += opengl-private diff --git a/tests/auto/declarative/qsglistview/qsglistview.pro b/tests/auto/declarative/qsglistview/qsglistview.pro index 8650d75210..9b31bcb7bf 100644 --- a/tests/auto/declarative/qsglistview/qsglistview.pro +++ b/tests/auto/declarative/qsglistview/qsglistview.pro @@ -15,5 +15,4 @@ symbian: { CONFIG += parallel_test QT += core-private gui-private declarative-private -QT += script-private QT += opengl-private diff --git a/tests/auto/declarative/qsgpathview/qsgpathview.pro b/tests/auto/declarative/qsgpathview/qsgpathview.pro index 70279757a5..eb188666bb 100644 --- a/tests/auto/declarative/qsgpathview/qsgpathview.pro +++ b/tests/auto/declarative/qsgpathview/qsgpathview.pro @@ -15,4 +15,3 @@ symbian: { CONFIG += parallel_test QT += core-private gui-private declarative-private -QT += script-private diff --git a/tests/auto/declarative/qsgpositioners/qsgpositioners.pro b/tests/auto/declarative/qsgpositioners/qsgpositioners.pro index 9602c721c2..bf8110ffd4 100644 --- a/tests/auto/declarative/qsgpositioners/qsgpositioners.pro +++ b/tests/auto/declarative/qsgpositioners/qsgpositioners.pro @@ -14,5 +14,4 @@ symbian: { CONFIG += parallel_test QT += core-private gui-private declarative-private -QT += script-private QT += opengl-private diff --git a/tests/auto/declarative/qsgtext/qsgtext.pro b/tests/auto/declarative/qsgtext/qsgtext.pro index 99aac1982f..5254d1ebeb 100644 --- a/tests/auto/declarative/qsgtext/qsgtext.pro +++ b/tests/auto/declarative/qsgtext/qsgtext.pro @@ -20,5 +20,4 @@ symbian: { CONFIG += parallel_test QT += core-private gui-private declarative-private -QT += script-private QT += opengl-private diff --git a/tests/auto/declarative/qsgtextedit/qsgtextedit.pro b/tests/auto/declarative/qsgtextedit/qsgtextedit.pro index be8d98ba01..fea4b71369 100644 --- a/tests/auto/declarative/qsgtextedit/qsgtextedit.pro +++ b/tests/auto/declarative/qsgtextedit/qsgtextedit.pro @@ -13,5 +13,4 @@ symbian: { DEFINES += SRCDIR=\\\"$$PWD\\\" } QT += core-private gui-private declarative-private -QT += script-private QT += opengl-private diff --git a/tests/auto/declarative/qsgtextinput/qsgtextinput.pro b/tests/auto/declarative/qsgtextinput/qsgtextinput.pro index d3d03e7db1..56a811fa6d 100644 --- a/tests/auto/declarative/qsgtextinput/qsgtextinput.pro +++ b/tests/auto/declarative/qsgtextinput/qsgtextinput.pro @@ -13,5 +13,4 @@ symbian: { } QT += core-private gui-private declarative-private -QT += script-private QT += opengl-private diff --git a/tests/auto/declarative/qsgvisualdatamodel/qsgvisualdatamodel.pro b/tests/auto/declarative/qsgvisualdatamodel/qsgvisualdatamodel.pro index 7b961b6298..8f433c1208 100644 --- a/tests/auto/declarative/qsgvisualdatamodel/qsgvisualdatamodel.pro +++ b/tests/auto/declarative/qsgvisualdatamodel/qsgvisualdatamodel.pro @@ -15,4 +15,3 @@ symbian: { CONFIG += parallel_test QT += core-private gui-private declarative-private -QT += script-private |