Merge commit 'qt/master'

Conflicts:
	configure.exe
	examples/examples.pro
	qmake/Makefile.unix
	qmake/Makefile.win32
	qmake/Makefile.win32-g++
	qmake/Makefile.win32-g++-sh
	qmake/qmake.pro
	src/script/api/qscriptable.h
	src/script/api/qscriptclasspropertyiterator.h
	src/script/api/qscriptcontext.h
	src/script/api/qscriptengineagent.cpp
	src/script/api/qscriptstring.cpp
	src/script/api/qscriptstring.h
	src/script/api/qscriptvalueiterator.cpp
	src/script/api/qscriptvalueiterator.h
	src/script/qscriptclass.cpp
	src/script/qscriptcontext.cpp
	src/script/qscriptengine.cpp
	src/script/qscriptengine_p.cpp
	src/script/qscriptvalue.cpp
	src/script/qscriptvalue_p.h
	src/script/qscriptvalueimplfwd_p.h
	src/script/script.pro
	src/src.pro
	tests/auto/auto.pro
	tests/auto/qscriptv8testsuite/tst_qscriptv8testsuite.cpp
	tools/configure/configureapp.cpp

32 files changed, 2369 insertions, 1081 deletions

diff --git a/tests/auto/auto.pro b/tests/auto/auto.pro
index d8d5a0eb4a..76dca512df 100644
--- a/tests/auto/auto.pro
+++ b/tests/auto/auto.pro
@@ -253,19 +253,6 @@ SUBDIRS += \
            qresourceengine \
            qringbuffer \
            qscopedpointer \
-           qscriptable \
-           qscriptclass \
-           qscriptcontext \
-           qscriptcontextinfo \
-           qscriptengine \
-           qscriptengineagent \
-           qscriptextqobject \
-           qscriptjstestsuite \
-           qscriptv8testsuite \
-           qscriptstring \
-           qscriptvalue \
-           qscriptvalueiterator \
-           qscriptenginedebugger \
            qscrollarea \
            qsemaphore \
            qsharedpointer \
@@ -474,6 +461,21 @@ unix:!embedded:contains(QT_CONFIG, dbus):SUBDIRS += \
            qdbusthreading \
            qdbusxmlparser
 
+contains(QT_CONFIG, script): SUBDIRS += \
+           qscriptable \
+           qscriptclass \
+           qscriptcontext \
+           qscriptcontextinfo \
+           qscriptengine \
+           qscriptengineagent \
+           qscriptextqobject \
+           qscriptjstestsuite \
+           qscriptv8testsuite \
+           qscriptstring \
+           qscriptvalue \
+           qscriptvalueiterator \
+           qscriptenginedebugger
+
 contains(QT_CONFIG, webkit): SUBDIRS += \
            qwebframe \
            qwebpage \
diff --git a/tests/auto/moc/moc.pro b/tests/auto/moc/moc.pro
index f96b4e2367..a89ff07e78 100644
--- a/tests/auto/moc/moc.pro
+++ b/tests/auto/moc/moc.pro
@@ -20,7 +20,8 @@ HEADERS += using-namespaces.h no-keywords.h task87883.h c-comments.h backslash-n
 if(*-g++*|*-icc*):!irix-*:!win32-*: HEADERS += os9-newlines.h win-newlines.h
 SOURCES += tst_moc.cpp
 
-QT += sql network svg script
+QT += sql network svg
+contains(QT_CONFIG, script): QT += script
 contains(QT_CONFIG, qt3support): QT += qt3support
 contains(QT_CONFIG, dbus){
     DEFINES += WITH_DBUS
diff --git a/tests/auto/moc/no-keywords.h b/tests/auto/moc/no-keywords.h
index f062dffa5b..a7d76e77e4 100644
--- a/tests/auto/moc/no-keywords.h
+++ b/tests/auto/moc/no-keywords.h
@@ -58,7 +58,9 @@
 #if defined(WITH_DBUS)
 #include <QtDBus>
 #endif
+#ifdef QT_SCRIPT_LIB
 #include <QtScript>
+#endif
 
 #undef signals
 #undef slots
diff --git a/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp b/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp
index bfd346b895..d3d511abb5 100644
--- a/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp
+++ b/tests/auto/qgraphicstransform/tst_qgraphicstransform.cpp
@@ -84,60 +84,131 @@ void tst_QGraphicsTransform::cleanup()
 {
 }
 
+static QTransform transform2D(const QGraphicsTransform& t)
+{
+    QMatrix4x4 m;
+    t.applyTo(&m);
+    return m.toTransform();
+}
 
 void tst_QGraphicsTransform::scale()
 {
     QGraphicsScale scale;
-    scale.setOrigin(QPointF(10, 10));
 
-    QTransform t;
+    // check initial conditions
+    QCOMPARE(scale.xScale(), qreal(1));
+    QCOMPARE(scale.yScale(), qreal(1));
+    QCOMPARE(scale.zScale(), qreal(1));
+    QCOMPARE(scale.origin(), QVector3D(0, 0, 0));
+
+    scale.setOrigin(QVector3D(10, 10, 0));
+
+    QCOMPARE(scale.xScale(), qreal(1));
+    QCOMPARE(scale.yScale(), qreal(1));
+    QCOMPARE(scale.zScale(), qreal(1));
+    QCOMPARE(scale.origin(), QVector3D(10, 10, 0));
+
+    QMatrix4x4 t;
     scale.applyTo(&t);
 
-    QCOMPARE(t, QTransform());
-    QCOMPARE(scale.transform(), QTransform());
+    QCOMPARE(t, QMatrix4x4());
+    QCOMPARE(transform2D(scale), QTransform());
 
     scale.setXScale(10);
-    scale.setOrigin(QPointF(0, 0));
+    scale.setOrigin(QVector3D(0, 0, 0));
+
+    QCOMPARE(scale.xScale(), qreal(10));
+    QCOMPARE(scale.yScale(), qreal(1));
+    QCOMPARE(scale.zScale(), qreal(1));
+    QCOMPARE(scale.origin(), QVector3D(0, 0, 0));
 
     QTransform res;
     res.scale(10, 1);
 
-    QCOMPARE(scale.transform(), res);
-    QCOMPARE(scale.transform().map(QPointF(10, 10)), QPointF(100, 10));
+    QCOMPARE(transform2D(scale), res);
+    QCOMPARE(transform2D(scale).map(QPointF(10, 10)), QPointF(100, 10));
+
+    scale.setOrigin(QVector3D(10, 10, 0));
+    QCOMPARE(transform2D(scale).map(QPointF(10, 10)), QPointF(10, 10));
+    QCOMPARE(transform2D(scale).map(QPointF(11, 10)), QPointF(20, 10));
+
+    scale.setYScale(2);
+    scale.setZScale(4.5);
+    scale.setOrigin(QVector3D(1, 2, 3));
+
+    QCOMPARE(scale.xScale(), qreal(10));
+    QCOMPARE(scale.yScale(), qreal(2));
+    QCOMPARE(scale.zScale(), qreal(4.5));
+    QCOMPARE(scale.origin(), QVector3D(1, 2, 3));
+
+    QMatrix4x4 t2;
+    scale.applyTo(&t2);
 
-    scale.setOrigin(QPointF(10, 10));
-    QCOMPARE(scale.transform().map(QPointF(10, 10)), QPointF(10, 10));
-    QCOMPARE(scale.transform().map(QPointF(11, 10)), QPointF(20, 10));
+    QCOMPARE(t2.map(QVector3D(4, 5, 6)), QVector3D(31, 8, 16.5));
+
+    // Because the origin has a non-zero z, mapping (4, 5) in 2D
+    // will introduce a projective component into the result.
+    QTransform t3 = t2.toTransform();
+    QCOMPARE(t3.map(QPointF(4, 5)), QPointF(31 / t3.m33(), 8 / t3.m33()));
+}
+
+// QMatrix4x4 uses float internally, whereas QTransform uses qreal.
+// This can lead to issues with qFuzzyCompare() where it uses double
+// precision to compare values that have no more than float precision
+// after conversion from QMatrix4x4 to QTransform.  The following
+// definitions correct for the difference.
+static inline bool fuzzyCompare(qreal p1, qreal p2)
+{
+    return (qAbs(p1 - p2) <= 0.00001f * qMin(qAbs(p1), qAbs(p2)));
+}
+static bool fuzzyCompare(const QTransform& t1, const QTransform& t2)
+{
+    return fuzzyCompare(t1.m11(), t2.m11()) &&
+           fuzzyCompare(t1.m12(), t2.m12()) &&
+           fuzzyCompare(t1.m13(), t2.m13()) &&
+           fuzzyCompare(t1.m21(), t2.m21()) &&
+           fuzzyCompare(t1.m22(), t2.m22()) &&
+           fuzzyCompare(t1.m23(), t2.m23()) &&
+           fuzzyCompare(t1.m31(), t2.m31()) &&
+           fuzzyCompare(t1.m32(), t2.m32()) &&
+           fuzzyCompare(t1.m33(), t2.m33());
 }
 
 void tst_QGraphicsTransform::rotation()
 {
     QGraphicsRotation rotation;
-    QCOMPARE(rotation.axis().x(), (qreal)0);
-    QCOMPARE(rotation.axis().y(), (qreal)0);
-    QCOMPARE(rotation.axis().z(), (qreal)1);
+    QCOMPARE(rotation.axis(), QVector3D(0, 0, 1));
+    QCOMPARE(rotation.origin(), QVector3D(0, 0, 0));
     QCOMPARE(rotation.angle(), (qreal)0);
 
-    rotation.setOrigin(QPointF(10, 10));
+    rotation.setOrigin(QVector3D(10, 10, 0));
+
+    QCOMPARE(rotation.axis(), QVector3D(0, 0, 1));
+    QCOMPARE(rotation.origin(), QVector3D(10, 10, 0));
+    QCOMPARE(rotation.angle(), (qreal)0);
 
-    QTransform t;
+    QMatrix4x4 t;
     rotation.applyTo(&t);
 
-    QCOMPARE(t, QTransform());
-    QCOMPARE(rotation.transform(), QTransform());
+    QCOMPARE(t, QMatrix4x4());
+    QCOMPARE(transform2D(rotation), QTransform());
 
     rotation.setAngle(40);
-    rotation.setOrigin(QPointF(0, 0));
+    rotation.setOrigin(QVector3D(0, 0, 0));
+
+    QCOMPARE(rotation.axis(), QVector3D(0, 0, 1));
+    QCOMPARE(rotation.origin(), QVector3D(0, 0, 0));
+    QCOMPARE(rotation.angle(), (qreal)40);
 
     QTransform res;
     res.rotate(40);
 
-    QCOMPARE(rotation.transform(), res);
+    QVERIFY(fuzzyCompare(transform2D(rotation), res));
 
-    rotation.setOrigin(QPointF(10, 10));
+    rotation.setOrigin(QVector3D(10, 10, 0));
     rotation.setAngle(90);
-    QCOMPARE(rotation.transform().map(QPointF(10, 10)), QPointF(10, 10));
-    QCOMPARE(rotation.transform().map(QPointF(20, 10)), QPointF(10, 20));
+    QCOMPARE(transform2D(rotation).map(QPointF(10, 10)), QPointF(10, 10));
+    QCOMPARE(transform2D(rotation).map(QPointF(20, 10)), QPointF(10, 20));
 }
 
 Q_DECLARE_METATYPE(Qt::Axis);
@@ -161,38 +232,44 @@ void tst_QGraphicsTransform::rotation3d()
     QGraphicsRotation rotation;
     rotation.setAxis(axis);
 
-    QTransform t;
+    QMatrix4x4 t;
     rotation.applyTo(&t);
 
     QVERIFY(t.isIdentity());
-    QVERIFY(rotation.transform().isIdentity());
+    QVERIFY(transform2D(rotation).isIdentity());
 
     rotation.setAngle(angle);
 
+    // QGraphicsRotation uses a correct mathematical rotation in 3D.
+    // QTransform's Qt::YAxis rotation is inverted from the mathematical
+    // version of rotation.  We correct for that here.
     QTransform expected;
-    expected.rotate(angle, axis);
+    if (axis == Qt::YAxis && angle != 180.)
+        expected.rotate(-angle, axis);
+    else
+        expected.rotate(angle, axis);
 
-    QVERIFY(qFuzzyCompare(rotation.transform(), expected));
+    QVERIFY(fuzzyCompare(transform2D(rotation), expected));
 
     //now let's check that a null vector will not change the transform
     rotation.setAxis(QVector3D(0, 0, 0));
-    rotation.setOrigin(QPointF(10, 10));
+    rotation.setOrigin(QVector3D(10, 10, 0));
 
-    t.reset();
+    t.setIdentity();
     rotation.applyTo(&t);
 
     QVERIFY(t.isIdentity());
-    QVERIFY(rotation.transform().isIdentity());
+    QVERIFY(transform2D(rotation).isIdentity());
 
     rotation.setAngle(angle);
 
     QVERIFY(t.isIdentity());
-    QVERIFY(rotation.transform().isIdentity());
+    QVERIFY(transform2D(rotation).isIdentity());
 
-    rotation.setOrigin(QPointF(0, 0));
+    rotation.setOrigin(QVector3D(0, 0, 0));
 
     QVERIFY(t.isIdentity());
-    QVERIFY(rotation.transform().isIdentity());
+    QVERIFY(transform2D(rotation).isIdentity());
 }
 
 
diff --git a/tests/auto/qscriptable/tst_qscriptable.cpp b/tests/auto/qscriptable/tst_qscriptable.cpp
index ecfcc8ba4c..af647fd000 100644
--- a/tests/auto/qscriptable/tst_qscriptable.cpp
+++ b/tests/auto/qscriptable/tst_qscriptable.cpp
@@ -332,6 +332,7 @@ void tst_QScriptable::thisObject()
     {
         QVERIFY(!m_scriptable.oofThisObject().isValid());
         m_engine.evaluate("o.oof = 123");
+        QEXPECT_FAIL("", "Setter doesn't get called when it's in the prototype", Continue);
         QVERIFY(m_scriptable.oofThisObject().strictlyEquals(m_engine.evaluate("o")));
     }
     {
diff --git a/tests/auto/qscriptclass/tst_qscriptclass.cpp b/tests/auto/qscriptclass/tst_qscriptclass.cpp
index c83cdaf9a6..11c7f56522 100644
--- a/tests/auto/qscriptclass/tst_qscriptclass.cpp
+++ b/tests/auto/qscriptclass/tst_qscriptclass.cpp
@@ -149,6 +149,9 @@ public:
     QScriptString lastPropertyFlagsName() const;
     uint lastPropertyFlagsId() const;
 
+    QScriptClass::Extension lastExtensionType() const;
+    QVariant lastExtensionArgument() const;
+
     void clearReceivedArgs();
 
     void setIterationEnabled(bool enable);
@@ -182,6 +185,9 @@ private:
     QScriptString m_lastPropertyFlagsName;
     uint m_lastPropertyFlagsId;
 
+    QScriptClass::Extension m_lastExtensionType;
+    QVariant m_lastExtensionArgument;
+
     QScriptValue m_prototype;
     bool m_iterationEnabled;
     CallableMode m_callableMode;
@@ -333,6 +339,8 @@ bool TestClass::supportsExtension(Extension extension) const
 QVariant TestClass::extension(Extension extension,
                               const QVariant &argument)
 {
+    m_lastExtensionType = extension;
+    m_lastExtensionArgument = argument;
     if (extension == Callable) {
         Q_ASSERT(m_callableMode != NotCallable);
         QScriptContext *ctx = qvariant_cast<QScriptContext*>(argument);
@@ -354,7 +362,6 @@ QVariant TestClass::extension(Extension extension,
     } else if (extension == HasInstance) {
         Q_ASSERT(m_hasInstance);
         QScriptValueList args = qvariant_cast<QScriptValueList>(argument);
-        Q_ASSERT(args.size() == 2);
         QScriptValue obj = args.at(0);
         QScriptValue value = args.at(1);
         return value.property("foo").equals(obj.property("foo"));
@@ -427,6 +434,16 @@ uint TestClass::lastPropertyFlagsId() const
     return m_lastPropertyFlagsId;
 }
 
+QScriptClass::Extension TestClass::lastExtensionType() const
+{
+    return m_lastExtensionType;
+}
+
+QVariant TestClass::lastExtensionArgument() const
+{
+    return m_lastExtensionArgument;
+}
+
 void TestClass::clearReceivedArgs()
 {
     m_lastQueryPropertyObject = QScriptValue();
@@ -445,6 +462,9 @@ void TestClass::clearReceivedArgs()
     m_lastPropertyFlagsObject = QScriptValue();
     m_lastPropertyFlagsName = QScriptString();
     m_lastPropertyFlagsId = uint(-1);
+
+    m_lastExtensionType = static_cast<QScriptClass::Extension>(-1);
+    m_lastExtensionArgument = QVariant();
 }
 
 void TestClass::setIterationEnabled(bool enable)
@@ -558,6 +578,7 @@ void tst_QScriptClass::newInstance()
     QScriptValue obj1 = eng.newObject(&cls);
     QVERIFY(!obj1.data().isValid());
     QVERIFY(obj1.prototype().strictlyEquals(cls.prototype()));
+    QEXPECT_FAIL("", "classname is not implemented", Continue);
     QCOMPARE(obj1.toString(), QString::fromLatin1("[object TestClass]"));
     QCOMPARE(obj1.scriptClass(), (QScriptClass*)&cls);
 
@@ -586,7 +607,9 @@ void tst_QScriptClass::newInstance()
     QVERIFY(arr.isArray());
     QCOMPARE(arr.scriptClass(), (QScriptClass*)0);
     arr.setScriptClass(&cls);
+    QEXPECT_FAIL("", "Changing class of arbitrary script object is not allowed (it's OK)", Continue);
     QCOMPARE(arr.scriptClass(), (QScriptClass*)&cls);
+    QEXPECT_FAIL("", "Changing class of arbitrary script object is not allowed (it's OK)", Continue);
     QVERIFY(!arr.isArray());
     QVERIFY(arr.isObject());
 }
@@ -626,10 +649,12 @@ void tst_QScriptClass::getAndSetProperty()
             QVERIFY(cls.lastQueryPropertyName() == s);
             QVERIFY(!cls.lastPropertyObject().isValid());
             QVERIFY(!cls.lastSetPropertyObject().isValid());
-            // ### ideally, we should only test for HandlesWriteAccess in this case
-            QVERIFY(cls.lastQueryPropertyFlags() == (QScriptClass::HandlesReadAccess | QScriptClass::HandlesWriteAccess));
+            QVERIFY(cls.lastQueryPropertyFlags() == QScriptClass::HandlesWriteAccess);
 
             // re-read property
+            // When a QScriptClass doesn't want to handle a property write,
+            // that property becomes a normal property and the QScriptClass
+            // shall not be queried about it again.
             cls.clearReceivedArgs();
             QVERIFY(o.property(s).strictlyEquals(num));
             QVERIFY(!cls.lastQueryPropertyObject().isValid());
@@ -720,6 +745,7 @@ void tst_QScriptClass::enumerate()
     for (int x = 0; x < 2; ++x) {
         QVERIFY(it.hasNext());
         it.next();
+        QEXPECT_FAIL("", "", Abort);
         QVERIFY(it.scriptName() == foo);
         QVERIFY(it.hasNext());
         it.next();
@@ -746,6 +772,11 @@ void tst_QScriptClass::extension()
         cls.setCallableMode(TestClass::NotCallable);
         QVERIFY(!cls.supportsExtension(QScriptClass::Callable));
         QVERIFY(!cls.supportsExtension(QScriptClass::HasInstance));
+        QScriptValue obj = eng.newObject(&cls);
+        QVERIFY(!obj.call().isValid());
+        QCOMPARE((int)cls.lastExtensionType(), -1);
+        QVERIFY(!obj.instanceOf(obj));
+        QCOMPARE((int)cls.lastExtensionType(), -1);
     }
     // Callable
     {
@@ -757,21 +788,31 @@ void tst_QScriptClass::extension()
         obj.setProperty("one", QScriptValue(&eng, 1));
         obj.setProperty("two", QScriptValue(&eng, 2));
         obj.setProperty("three", QScriptValue(&eng, 3));
+        cls.clearReceivedArgs();
         {
             QScriptValueList args;
             args << QScriptValue(&eng, 4) << QScriptValue(&eng, 5);
             QScriptValue ret = obj.call(obj, args);
+            QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
+            QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
+            QVERIFY(ret.isNumber());
             QCOMPARE(ret.toNumber(), qsreal(15));
         }
 
         cls.setCallableMode(TestClass::CallableReturnsArgument);
+        cls.clearReceivedArgs();
         {
             QScriptValue ret = obj.call(obj, QScriptValueList() << 123);
+            QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
+            QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
             QVERIFY(ret.isNumber());
             QCOMPARE(ret.toInt32(), 123);
         }
+        cls.clearReceivedArgs();
         {
             QScriptValue ret = obj.call(obj, QScriptValueList() << true);
+            QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
+            QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
             QVERIFY(ret.isBoolean());
             QCOMPARE(ret.toBoolean(), true);
         }
@@ -796,6 +837,15 @@ void tst_QScriptClass::extension()
             QScriptValue ret = obj.call(obj);
             QVERIFY(ret.isUndefined());
         }
+
+        // construct()
+        cls.clearReceivedArgs();
+        {
+            QScriptValue ret = obj.construct();
+            QCOMPARE(cls.lastExtensionType(), QScriptClass::Callable);
+            QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptContext*>());
+            QVERIFY(ret.isObject());
+        }
     }
     // HasInstance
     {
@@ -810,8 +860,15 @@ void tst_QScriptClass::extension()
 
         eng.globalObject().setProperty("HasInstanceTester", obj);
         eng.globalObject().setProperty("hasInstanceValue", plain);
+        cls.clearReceivedArgs();
         {
             QScriptValue ret = eng.evaluate("hasInstanceValue instanceof HasInstanceTester");
+            QCOMPARE(cls.lastExtensionType(), QScriptClass::HasInstance);
+            QCOMPARE(cls.lastExtensionArgument().userType(), qMetaTypeId<QScriptValueList>());
+            QScriptValueList lst = qvariant_cast<QScriptValueList>(cls.lastExtensionArgument());
+            QCOMPARE(lst.size(), 2);
+            QVERIFY(lst.at(0).strictlyEquals(obj));
+            QVERIFY(lst.at(1).strictlyEquals(plain));
             QVERIFY(ret.isBoolean());
             QVERIFY(!ret.toBoolean());
         }
diff --git a/tests/auto/qscriptcontext/tst_qscriptcontext.cpp b/tests/auto/qscriptcontext/tst_qscriptcontext.cpp
index a4050276fd..a0c56edd0b 100644
--- a/tests/auto/qscriptcontext/tst_qscriptcontext.cpp
+++ b/tests/auto/qscriptcontext/tst_qscriptcontext.cpp
@@ -68,12 +68,17 @@ private slots:
     void evaluateInFunction();
     void pushAndPopContext();
     void lineNumber();
+    void backtrace_data();
     void backtrace();
     void scopeChain();
     void pushAndPopScope();
     void getSetActivationObject();
     void inheritActivationAndThisObject();
     void toString();
+    void calledAsConstructor();
+    void argumentsObjectInNative();
+    void jsActivationObject();
+    void qobjectAsActivationObject();
 };
 
 tst_QScriptContext::tst_QScriptContext()
@@ -150,7 +155,6 @@ void tst_QScriptContext::arguments()
         QVERIFY(args.isObject());
         QCOMPARE(args.property("length").toInt32(), 0);
     }
-
     {
         QScriptValue fun = eng.newFunction(get_arguments);
         eng.globalObject().setProperty("get_arguments", fun);
@@ -198,6 +202,7 @@ void tst_QScriptContext::arguments()
             QCOMPARE(fun.isFunction(), true);
             QScriptValue result = eng.evaluate(prefix+"get_argumentsObject()");
             QCOMPARE(result.isArray(), false);
+            QVERIFY(result.isObject());
             QCOMPARE(result.property("length").toUInt32(), quint32(0));
             QCOMPARE(result.propertyFlags("length"), QScriptValue::SkipInEnumeration);
             QCOMPARE(result.property("callee").strictlyEquals(fun), true);
@@ -208,14 +213,25 @@ void tst_QScriptContext::arguments()
             QScriptValue replacedLength(&eng, 456);
             result.setProperty("length", replacedLength);
             QVERIFY(result.property("length").equals(replacedLength));
+            result.setProperty("callee", QScriptValue());
+            QVERIFY(!result.property("callee").isValid());
+            result.setProperty("length", QScriptValue());
+            QVERIFY(!result.property("length").isValid());
         }
 
         {
             QScriptValue result = eng.evaluate(prefix+"get_argumentsObject(123)");
+            eng.evaluate("function nestedArg(x,y,z) { var w = get_argumentsObject('ABC' , x+y+z); return w; }");
+            QScriptValue result2 = eng.evaluate("nestedArg(1, 'a', 2)");
             QCOMPARE(result.isArray(), false);
+            QVERIFY(result.isObject());
             QCOMPARE(result.property("length").toUInt32(), quint32(1));
             QCOMPARE(result.property("0").isNumber(), true);
             QCOMPARE(result.property("0").toNumber(), 123.0);
+            QVERIFY(result2.isObject());
+            QCOMPARE(result2.property("length").toUInt32(), quint32(2));
+            QCOMPARE(result2.property("0").toString(), QString::fromLatin1("ABC"));
+            QCOMPARE(result2.property("1").toString(), QString::fromLatin1("1a2"));
         }
 
         {
@@ -229,6 +245,28 @@ void tst_QScriptContext::arguments()
             QCOMPARE(result.property("2").toBoolean(), true);
             QCOMPARE(result.property("3").isUndefined(), true);
         }
+
+        // arguments object returned from script
+        {
+            QScriptValue result = eng.evaluate("(function() { return arguments; })(123)");
+            QCOMPARE(result.isArray(), false);
+            QVERIFY(result.isObject());
+            QCOMPARE(result.property("length").toUInt32(), quint32(1));
+            QCOMPARE(result.property("0").isNumber(), true);
+            QCOMPARE(result.property("0").toNumber(), 123.0);
+        }
+
+        {
+            QScriptValue result = eng.evaluate("(function() { return arguments; })('ciao', null, true, undefined)");
+            QCOMPARE(result.isArray(), false);
+            QCOMPARE(result.property("length").toUInt32(), quint32(4));
+            QCOMPARE(result.property("0").isString(), true);
+            QCOMPARE(result.property("0").toString(), QString("ciao"));
+            QCOMPARE(result.property("1").isNull(), true);
+            QCOMPARE(result.property("2").isBoolean(), true);
+            QCOMPARE(result.property("2").toBoolean(), true);
+            QCOMPARE(result.property("3").isUndefined(), true);
+        }
     }
 }
 
@@ -272,6 +310,7 @@ void tst_QScriptContext::thisObject()
 
 void tst_QScriptContext::returnValue()
 {
+    QSKIP("Internal function not implemented in JSC-based back-end", SkipAll);
     QScriptEngine eng;
     eng.evaluate("123");
     QCOMPARE(eng.currentContext()->returnValue().toNumber(), 123.0);
@@ -433,6 +472,7 @@ void tst_QScriptContext::pushAndPopContext()
     QCOMPARE(topLevel->engine(), &eng);
 
     QScriptContext *ctx = eng.pushContext();
+    QVERIFY(ctx != 0);
     QCOMPARE(ctx->parentContext(), topLevel);
     QCOMPARE(eng.currentContext(), ctx);
     QCOMPARE(ctx->engine(), &eng);
@@ -445,6 +485,9 @@ void tst_QScriptContext::pushAndPopContext()
     QCOMPARE(ctx->activationObject().isObject(), true);
     QCOMPARE(ctx->callee().isValid(), false);
     QCOMPARE(ctx->thisObject().strictlyEquals(eng.globalObject()), true);
+    QCOMPARE(ctx->scopeChain().size(), 2);
+    QVERIFY(ctx->scopeChain().at(0).equals(ctx->activationObject()));
+    QVERIFY(ctx->scopeChain().at(1).equals(eng.globalObject()));
 
     QScriptContext *ctx2 = eng.pushContext();
     QCOMPARE(ctx2->parentContext(), ctx);
@@ -456,6 +499,7 @@ void tst_QScriptContext::pushAndPopContext()
     QCOMPARE(eng.currentContext(), topLevel);
 
     // popping the top-level context is not allowed
+    QTest::ignoreMessage(QtWarningMsg, "QScriptEngine::popContext() doesn't match with pushContext()");
     eng.popContext();
     QCOMPARE(eng.currentContext(), topLevel);
 
@@ -497,7 +541,7 @@ void tst_QScriptContext::lineNumber()
     QScriptValue result = eng.evaluate("try { eval(\"foo = 123;\\n this[is{a{syntax|error@#$%@#% \"); } catch (e) { e.lineNumber; }", "foo.qs", 123);
     QVERIFY(!eng.hasUncaughtException());
     QVERIFY(result.isNumber());
-    QCOMPARE(result.toInt32(), 124);
+    QCOMPARE(result.toInt32(), 2);
 
     result = eng.evaluate("foo = 123;\n bar = 42\n0 = 0");
     QVERIFY(eng.hasUncaughtException());
@@ -510,26 +554,152 @@ static QScriptValue getBacktrace(QScriptContext *ctx, QScriptEngine *eng)
     return qScriptValueFromValue(eng, ctx->backtrace());
 }
 
+static QScriptValue custom_eval(QScriptContext *ctx, QScriptEngine *eng)
+{
+    return eng->evaluate(ctx->argumentsObject().property(0).toString(), ctx->argumentsObject().property(1).toString());
+}
+
+void tst_QScriptContext::backtrace_data()
+{
+    QTest::addColumn<QString>("code");
+    QTest::addColumn<QStringList>("expectedbacktrace");
+
+    {
+        QString source(
+                 "function foo() {\n"
+                 "  return bt(123);\n"
+                 "}\n"
+                 "foo('hello', { })\n"
+                 "var r = 0;");
+
+        QStringList expected;
+        expected << "<native>(123) at -1"
+                 << "foo('hello', [object Object]) at testfile:2"
+                 << "<global>() at testfile:4";
+
+
+        QTest::newRow("simple") << source << expected;
+    }
+
+    {
+        QStringList expected;
+        QString source = QString(
+            "function foo(arg1 , arg2) {\n"
+            "  return eval(\"%1\");\n"
+            "}\n"
+            "foo('hello', 456)\n"
+            "var a = 0;"
+           ).arg("\\n \\n bt('hey'); \\n");
+
+           expected << "<native>('hey') at -1"
+                    << "<eval>() at 3"
+                    //### line number should be 2 but the line number information is not kept for eval call
+                    << "foo(arg1 = 'hello', arg2 = 456) at testfile:-1"
+                    << "<global>() at testfile:4";
+
+            QTest::newRow("eval") << source << expected;
+    }
+
+    {
+        QString eval_code(
+                "function bar(a) {\\n"
+                "  return bt('m');\\n"
+                "}\\n"
+                "bar('b'); \\n");
+        QString source = QString(
+                "function foo() {\n"
+                "  return custom_eval(\"%1\", 'eval.js');\n"
+                "}\n"
+                "foo()"
+            ).arg(eval_code);
+
+        QStringList expected;
+        expected << "<native>('m') at -1"
+                 << "bar(a = 'b') at eval.js:2"
+                 << "<eval>() at eval.js:4"
+                 << QString("<native>('%1', 'eval.js') at -1").arg(eval_code.replace("\\n", "\n"))
+                 << "foo() at testfile:2"
+                 << "<global>() at testfile:4";
+
+        QTest::newRow("custom_eval") << source << expected;
+    }
+    {
+        QString f("function (a) {\n return bt(a); \n  }");
+        QString source = QString(
+                "function foo(f) {\n"
+                "  return f('b');\n"
+                "}\n"
+                "foo(%1)"
+            ).arg(f);
+
+        QStringList expected;
+        expected << "<native>('b') at -1"
+                 << "<anonymous>(a = 'b') at testfile:5"
+                 << QString("foo(f = %1) at testfile:2").arg(f)
+                 << "<global>() at testfile:6";
+
+        QTest::newRow("closure") << source << expected;
+    }
+
+    {
+        QStringList expected;
+        QString source = QString(
+            "var o = new Object;\n"
+            "o.foo = function plop() {\n"
+            "  return eval(\"%1\");\n"
+            "}\n"
+            "o.foo('hello', 456)\n"
+           ).arg("\\n \\n bt('hey'); \\n");
+
+           expected << "<native>('hey') at -1"
+                    << "<eval>() at 3"
+                    //### line number should be 3 but the line number information is not kept for eval call
+                    << "plop('hello', 456) at testfile:-1"
+                    << "<global>() at testfile:5";
+
+            QTest::newRow("eval in member") << source << expected;
+    }
+
+    {
+        QString source(
+                 "function foo(a) {\n"
+                 "  return bt(123);\n"
+                 "}\n"
+                 "function bar() {\n"
+                 "  var v = foo('arg', 4);\n"
+                 "  return v;\n"
+                 "}\n"
+                 "bar('hello', { });\n");
+
+        QStringList expected;
+        expected << "<native>(123) at -1"
+                 << "foo(a = 'arg', 4) at testfile:2"
+                 << "bar('hello', [object Object]) at testfile:5"
+                 << "<global>() at testfile:8";
+
+
+        QTest::newRow("two function") << source << expected;
+    }
+
+
+}
+
+
 void tst_QScriptContext::backtrace()
 {
+    QFETCH(QString, code);
+    QFETCH(QStringList, expectedbacktrace);
+
     QScriptEngine eng;
     eng.globalObject().setProperty("bt", eng.newFunction(getBacktrace));
+    eng.globalObject().setProperty("custom_eval", eng.newFunction(custom_eval));
 
     QString fileName = "testfile";
-    QStringList expected;
-    expected << "<native>(123)@:-1"
-             << "foo(hello,[object Object])@testfile:2"
-             << "<global>()@testfile:4";
-
-    QScriptValue ret = eng.evaluate(
-        "function foo() {\n"
-        "  return bt(123);\n"
-        "}\n"
-        "foo('hello', { })", fileName);
-
+    QScriptValue ret = eng.evaluate(code, fileName);
+    QVERIFY(!eng.hasUncaughtException());
     QVERIFY(ret.isArray());
     QStringList slist = qscriptvalue_cast<QStringList>(ret);
-    QCOMPARE(slist, expected);
+    QCOMPARE(slist, expectedbacktrace);
 }
 
 static QScriptValue getScopeChain(QScriptContext *ctx, QScriptEngine *eng)
@@ -542,7 +712,8 @@ void tst_QScriptContext::scopeChain()
     QScriptEngine eng;
     {
         QScriptValueList ret = eng.currentContext()->scopeChain();
-        QCOMPARE(ret.size(), 0); // we aren't evaluating code
+        QCOMPARE(ret.size(), 1);
+        QVERIFY(ret.at(0).strictlyEquals(eng.globalObject()));
     }
     {
         eng.globalObject().setProperty("getScopeChain", eng.newFunction(getScopeChain));
@@ -553,6 +724,7 @@ void tst_QScriptContext::scopeChain()
     {
         eng.evaluate("function foo() { function bar() { return getScopeChain(); } return bar() }");
         QScriptValueList ret = qscriptvalue_cast<QScriptValueList>(eng.evaluate("foo()"));
+        QEXPECT_FAIL("", "Number of items in returned scope chain is incorrect", Abort);
         QCOMPARE(ret.size(), 3);
         QVERIFY(ret.at(2).strictlyEquals(eng.globalObject()));
         QCOMPARE(ret.at(1).toString(), QString::fromLatin1("activation"));
@@ -583,15 +755,23 @@ void tst_QScriptContext::pushAndPopScope()
 {
     QScriptEngine eng;
     QScriptContext *ctx = eng.currentContext();
-    QVERIFY(ctx->scopeChain().isEmpty());
+    QCOMPARE(ctx->scopeChain().size(), 1);
+    QVERIFY(ctx->scopeChain().at(0).strictlyEquals(eng.globalObject()));
+
+    QVERIFY(ctx->popScope().strictlyEquals(eng.globalObject()));
+    ctx->pushScope(eng.globalObject());
+    QCOMPARE(ctx->scopeChain().size(), 1);
+    QVERIFY(ctx->scopeChain().at(0).strictlyEquals(eng.globalObject()));
 
     QScriptValue obj = eng.newObject();
     ctx->pushScope(obj);
-    QCOMPARE(ctx->scopeChain().size(), 1);
+    QCOMPARE(ctx->scopeChain().size(), 2);
     QVERIFY(ctx->scopeChain().at(0).strictlyEquals(obj));
+    QVERIFY(ctx->scopeChain().at(1).strictlyEquals(eng.globalObject()));
 
     QVERIFY(ctx->popScope().strictlyEquals(obj));
-    QVERIFY(ctx->scopeChain().isEmpty());
+    QCOMPARE(ctx->scopeChain().size(), 1);
+    QVERIFY(ctx->scopeChain().at(0).strictlyEquals(eng.globalObject()));
 
     {
         QScriptValue ret = eng.evaluate("x");
@@ -632,21 +812,16 @@ void tst_QScriptContext::pushAndPopScope()
     QVERIFY(ctx->popScope().strictlyEquals(eng.globalObject()));
     QVERIFY(ctx->scopeChain().isEmpty());
 
+    // Used to work with old back-end, doesn't with new one because JSC requires that the last object in
+    // a scope chain is the Global Object.
+    QTest::ignoreMessage(QtWarningMsg, "QScriptContext::pushScope() failed: initial object in scope chain has to be the Global Object");
     ctx->pushScope(obj);
-    QCOMPARE(ctx->scopeChain().size(), 1);
-    QVERIFY(ctx->scopeChain().at(0).strictlyEquals(obj));
-    QVERIFY(!obj.property("foo").isValid());
-    eng.evaluate("function foo() {}");
-    // function declarations should always end up in the activation object (ECMA-262, chapter 13)
-    QVERIFY(!obj.property("foo").isValid());
-    QVERIFY(ctx->activationObject().property("foo").isFunction());
+    QCOMPARE(ctx->scopeChain().size(), 0);
 
     QScriptEngine eng2;
     QScriptValue obj2 = eng2.newObject();
     QTest::ignoreMessage(QtWarningMsg, "QScriptContext::pushScope() failed: cannot push an object created in a different engine");
     ctx->pushScope(obj2);
-
-    QVERIFY(ctx->popScope().strictlyEquals(obj));
     QVERIFY(ctx->scopeChain().isEmpty());
 
     QVERIFY(!ctx->popScope().isValid());
@@ -670,23 +845,32 @@ void tst_QScriptContext::getSetActivationObject()
     QScriptValue obj = eng.newObject();
     ctx->setActivationObject(obj);
     QVERIFY(ctx->activationObject().equals(obj));
+    QCOMPARE(ctx->scopeChain().size(), 1);
+    QVERIFY(ctx->scopeChain().at(0).equals(obj));
 
     {
         QScriptEngine eng2;
         QScriptValue obj2 = eng2.newObject();
         QTest::ignoreMessage(QtWarningMsg, "QScriptContext::setActivationObject() failed: cannot set an object created in a different engine");
+        QScriptValue was = ctx->activationObject();
         ctx->setActivationObject(obj2);
-        QVERIFY(ctx->activationObject().equals(obj));
+        QVERIFY(ctx->activationObject().equals(was));
     }
 
     ctx->setActivationObject(eng.globalObject());
+    QVERIFY(ctx->activationObject().equals(eng.globalObject()));
     QScriptValue fun = eng.newFunction(get_activationObject);
     eng.globalObject().setProperty("get_activationObject", fun);
     {
         QScriptValue ret = eng.evaluate("get_activationObject(1, 2, 3)");
         QVERIFY(ret.isObject());
-        QVERIFY(ret.property("arguments").isObject());
-        QCOMPARE(ret.property("arguments").property("length").toInt32(), 3);
+        QScriptValue arguments = ret.property("arguments");
+        QEXPECT_FAIL("", "Getting arguments property of activation object doesn't work", Abort);
+        QVERIFY(arguments.isObject());
+        QCOMPARE(arguments.property("length").toInt32(), 3);
+        QCOMPARE(arguments.property("0").toInt32(), 1);
+        QCOMPARE(arguments.property("1").toInt32(), 1);
+        QCOMPARE(arguments.property("2").toInt32(), 1);
     }
 }
 
@@ -732,7 +916,164 @@ void tst_QScriptContext::toString()
                                     "    return parentContextToString();\n"
                                     "}; foo(1, 2, 3)", "script.qs");
     QVERIFY(ret.isString());
-    QCOMPARE(ret.toString(), QString::fromLatin1("foo (first=1, second=2, third=3) at script.qs:2"));
+    QCOMPARE(ret.toString(), QString::fromLatin1("foo(first = 1, second = 2, third = 3) at script.qs:2"));
+}
+
+static QScriptValue storeCalledAsConstructor(QScriptContext *ctx, QScriptEngine *eng)
+{
+    ctx->callee().setProperty("calledAsConstructor", ctx->isCalledAsConstructor());
+    return eng->undefinedValue();
+}
+
+static QScriptValue storeCalledAsConstructorV2(QScriptContext *ctx, QScriptEngine *eng, void *)
+{
+    ctx->callee().setProperty("calledAsConstructor", ctx->isCalledAsConstructor());
+    return eng->undefinedValue();
+}
+
+static QScriptValue storeCalledAsConstructorV3(QScriptContext *ctx, QScriptEngine *eng)
+{
+    ctx->callee().setProperty("calledAsConstructor", ctx->parentContext()->isCalledAsConstructor());
+    return eng->undefinedValue();
+}
+
+void tst_QScriptContext::calledAsConstructor()
+{
+    QScriptEngine eng;
+    QScriptValue fun1 = eng.newFunction(storeCalledAsConstructor);
+    {
+        fun1.call();
+        QVERIFY(!fun1.property("calledAsConstructor").toBool());
+        fun1.construct();
+        QVERIFY(fun1.property("calledAsConstructor").toBool());
+    }
+    {
+        QScriptValue fun = eng.newFunction(storeCalledAsConstructorV2, (void*)0);
+        fun.call();
+        QVERIFY(!fun.property("calledAsConstructor").toBool());
+        fun.construct();
+        QVERIFY(fun.property("calledAsConstructor").toBool());
+    }
+    {
+        eng.globalObject().setProperty("fun1", fun1);
+        eng.evaluate("fun1();");
+        QVERIFY(!fun1.property("calledAsConstructor").toBool());
+        eng.evaluate("new fun1();");
+        QVERIFY(fun1.property("calledAsConstructor").toBool());
+    }
+    {
+        QScriptValue fun3 = eng.newFunction(storeCalledAsConstructorV3);
+        eng.globalObject().setProperty("fun3", fun3);
+        eng.evaluate("function test() { fun3() }");
+        eng.evaluate("test();");
+        QVERIFY(!fun3.property("calledAsConstructor").toBool());
+        eng.evaluate("new test();");
+        QVERIFY(fun3.property("calledAsConstructor").toBool());
+    }
+
+}
+
+static QScriptValue argumentsObjectInNative_test1(QScriptContext *ctx, QScriptEngine *eng)
+{
+#define VERIFY(statement) \
+    do {\
+        if (!QTest::qVerify((statement), #statement, "", __FILE__, __LINE__))\
+            return QString::fromLatin1("Failed "  #statement);\
+    } while (0)
+
+    QScriptValue obj = ctx->argumentsObject();
+    VERIFY(obj.isObject());
+    VERIFY(obj.property(0).toUInt32() == 123);
+    VERIFY(obj.property(1).toString() == QString::fromLatin1("456"));
+
+    obj.setProperty(0, "abc");
+    VERIFY(eng->evaluate("arguments[0]").toString() == QString::fromLatin1("abc") );
+
+    return QString::fromLatin1("success");
+#undef VERIFY
+}
+
+void tst_QScriptContext::argumentsObjectInNative()
+{
+    {
+        QScriptEngine eng;
+        QScriptValue fun = eng.newFunction(argumentsObjectInNative_test1);
+        QScriptValueList args;
+        args << QScriptValue(&eng, 123.0);
+        args << QScriptValue(&eng, QString::fromLatin1("456"));
+        QScriptValue result = fun.call(eng.undefinedValue(), args);
+        QVERIFY(!eng.hasUncaughtException());
+        QCOMPARE(result.toString(), QString::fromLatin1("success"));
+    }
+    {
+        QScriptEngine eng;
+        QScriptValue fun = eng.newFunction(argumentsObjectInNative_test1);
+        eng.globalObject().setProperty("func", fun);
+        QScriptValue result = eng.evaluate("func(123.0 , 456);");
+        QVERIFY(!eng.hasUncaughtException());
+        QCOMPARE(result.toString(), QString::fromLatin1("success"));
+    }
+}
+
+static QScriptValue get_jsActivationObject(QScriptContext *ctx, QScriptEngine *)
+{
+    return ctx->parentContext()->parentContext()->activationObject();
+}
+
+void tst_QScriptContext::jsActivationObject()
+{
+    QScriptEngine eng;
+    eng.globalObject().setProperty("get_jsActivationObject", eng.newFunction(get_jsActivationObject));
+    eng.evaluate("function f1() { var w = get_jsActivationObject('arg1');  return w; }");
+    eng.evaluate("function f2(x,y,z) { var v1 = 42;\n"
+                        //   "function foo() {};\n" //this would avoid JSC to optimize
+                        "var v2 = f1(); return v2; }");
+    eng.evaluate("function f3() { var v1 = 'nothing'; return f2(1,2,3); }");
+    QScriptValue result1 = eng.evaluate("f2('hello', 'useless', 'world')");
+    QScriptValue result2 = eng.evaluate("f3()");
+    QVERIFY(result1.isObject());
+    QEXPECT_FAIL("", "JSC optimize away the activation object", Abort);
+    QCOMPARE(result1.property("v1").toInt32() , 42);
+    QCOMPARE(result1.property("arguments").property(1).toString() , QString::fromLatin1("useless"));
+    QVERIFY(result2.isObject());
+    QCOMPARE(result2.property("v1").toInt32() , 42);
+    QCOMPARE(result2.property("arguments").property(1).toString() , QString::fromLatin1("2"));
+}
+
+void tst_QScriptContext::qobjectAsActivationObject()
+{
+    QScriptEngine eng;
+    QObject object;
+    QScriptValue scriptObject = eng.newQObject(&object);
+    QScriptContext *ctx = eng.pushContext();
+    ctx->setActivationObject(scriptObject);
+    QVERIFY(ctx->activationObject().equals(scriptObject));
+
+    QVERIFY(!scriptObject.property("foo").isValid());
+    eng.evaluate("function foo() { return 123; }");
+    {
+        QScriptValue val = scriptObject.property("foo");
+        QVERIFY(val.isValid());
+        QVERIFY(val.isFunction());
+    }
+    QVERIFY(!eng.globalObject().property("foo").isValid());
+
+    QVERIFY(!scriptObject.property("bar").isValid());
+    eng.evaluate("var bar = 123");
+    {
+        QScriptValue val = scriptObject.property("bar");
+        QVERIFY(val.isValid());
+        QVERIFY(val.isNumber());
+        QCOMPARE(val.toInt32(), 123);
+    }
+    QVERIFY(!eng.globalObject().property("bar").isValid());
+
+    {
+        QScriptValue val = eng.evaluate("delete foo");
+        QVERIFY(val.isBool());
+        QVERIFY(val.toBool());
+        QVERIFY(!scriptObject.property("foo").isValid());
+    }
 }
 
 QTEST_MAIN(tst_QScriptContext)
diff --git a/tests/auto/qscriptcontextinfo/tst_qscriptcontextinfo.cpp b/tests/auto/qscriptcontextinfo/tst_qscriptcontextinfo.cpp
index 5d26424694..874e70d106 100644
--- a/tests/auto/qscriptcontextinfo/tst_qscriptcontextinfo.cpp
+++ b/tests/auto/qscriptcontextinfo/tst_qscriptcontextinfo.cpp
@@ -91,8 +91,6 @@ private slots:
     void scriptFunction();
     void qtFunction();
     void qtPropertyFunction();
-    void builtinFunctionNames_data();
-    void builtinFunctionNames();
     void nullContext();
     void streaming();
     void assignmentAndComparison();
@@ -152,6 +150,7 @@ void tst_QScriptContextInfo::nativeFunction()
         QVERIFY(info.scriptId() != -1);
         QCOMPARE(info.fileName(), fileName);
         QCOMPARE(info.lineNumber(), lineNumber);
+        QEXPECT_FAIL("", "columnNumber doesn't work", Continue);
         QCOMPARE(info.columnNumber(), 1);
         QCOMPARE(info.functionName(), QString());
         QCOMPARE(info.functionEndLineNumber(), -1);
@@ -183,6 +182,7 @@ void tst_QScriptContextInfo::scriptFunction()
         QVERIFY(info.scriptId() != -1);
         QCOMPARE(info.fileName(), fileName);
         QCOMPARE(info.lineNumber(), lineNumber + 1);
+        QEXPECT_FAIL("", "columnNumber doesn't work", Continue);
         QCOMPARE(info.columnNumber(), 2);
         QCOMPARE(info.functionName(), QString::fromLatin1("bar"));
         QCOMPARE(info.functionStartLineNumber(), lineNumber);
@@ -201,6 +201,7 @@ void tst_QScriptContextInfo::scriptFunction()
         QVERIFY(info.scriptId() != -1);
         QCOMPARE(info.fileName(), fileName);
         QCOMPARE(info.lineNumber(), lineNumber + 3);
+        QEXPECT_FAIL("", "columnNumber doesn't work", Continue);
         QCOMPARE(info.columnNumber(), 1);
         QCOMPARE(info.functionName(), QString());
         QCOMPARE(info.functionEndLineNumber(), -1);
@@ -216,7 +217,7 @@ void tst_QScriptContextInfo::qtFunction()
     eng.globalObject().setProperty("getContextInfoList", eng.newFunction(getContextInfoList));
     eng.globalObject().setProperty("qobj", eng.newQObject(this));
 
-    for (int x = 0; x < 2; ++x) {
+    for (int x = 0; x < 2; ++x) { // twice to test overloaded slot as well
         QString code;
         const char *sig;
         QStringList pnames;
@@ -247,8 +248,14 @@ void tst_QScriptContextInfo::qtFunction()
             QCOMPARE(info.functionName(), QString::fromLatin1("testSlot"));
             QCOMPARE(info.functionEndLineNumber(), -1);
             QCOMPARE(info.functionStartLineNumber(), -1);
+            if (x == 0)
+                QEXPECT_FAIL("", "QScriptContextInfo doesn't pick the correct meta-index for overloaded slots", Continue);
             QCOMPARE(info.functionParameterNames().size(), pnames.size());
+            if (x == 0)
+                QEXPECT_FAIL("", "QScriptContextInfo doesn't pick the correct meta-index for overloaded slots", Continue);
             QCOMPARE(info.functionParameterNames(), pnames);
+            if (x == 0)
+                QEXPECT_FAIL("", "QScriptContextInfo doesn't pick the correct meta-index for overloaded slots", Continue);
             QCOMPARE(info.functionMetaIndex(), metaObject()->indexOfMethod(sig));
         }
 
@@ -289,201 +296,6 @@ void tst_QScriptContextInfo::qtPropertyFunction()
     QCOMPARE(lst.at(0).functionType(), QScriptContextInfo::NativeFunction);
 }
 
-void tst_QScriptContextInfo::builtinFunctionNames_data()
-{
-    QTest::addColumn<QString>("expression");
-    QTest::addColumn<QString>("expectedName");
-
-    QTest::newRow("print") << QString("print") << QString("print");
-    QTest::newRow("parseInt") << QString("parseInt") << QString("parseInt");
-    QTest::newRow("parseFloat") << QString("parseFloat") << QString("parseFloat");
-    QTest::newRow("isNaN") << QString("isNaN") << QString("isNaN");
-    QTest::newRow("isFinite") << QString("isFinite") << QString("isFinite");
-    QTest::newRow("decodeURI") << QString("decodeURI") << QString("decodeURI");
-    QTest::newRow("decodeURIComponent") << QString("decodeURIComponent") << QString("decodeURIComponent");
-    QTest::newRow("encodeURI") << QString("encodeURI") << QString("encodeURI");
-    QTest::newRow("encodeURIComponent") << QString("encodeURIComponent") << QString("encodeURIComponent");
-    QTest::newRow("escape") << QString("escape") << QString("escape");
-    QTest::newRow("unescape") << QString("unescape") << QString("unescape");
-    QTest::newRow("version") << QString("version") << QString("version");
-    QTest::newRow("gc") << QString("gc") << QString("gc");
-
-    QTest::newRow("Array") << QString("Array") << QString("Array");
-    QTest::newRow("Array.prototype.toString") << QString("Array.prototype.toString") << QString("toString");
-    QTest::newRow("Array.prototype.toLocaleString") << QString("Array.prototype.toLocaleString") << QString("toLocaleString");
-    QTest::newRow("Array.prototype.concat") << QString("Array.prototype.concat") << QString("concat");
-    QTest::newRow("Array.prototype.join") << QString("Array.prototype.join") << QString("join");
-    QTest::newRow("Array.prototype.pop") << QString("Array.prototype.pop") << QString("pop");
-    QTest::newRow("Array.prototype.push") << QString("Array.prototype.push") << QString("push");
-    QTest::newRow("Array.prototype.reverse") << QString("Array.prototype.reverse") << QString("reverse");
-    QTest::newRow("Array.prototype.shift") << QString("Array.prototype.shift") << QString("shift");
-    QTest::newRow("Array.prototype.slice") << QString("Array.prototype.slice") << QString("slice");
-    QTest::newRow("Array.prototype.sort") << QString("Array.prototype.sort") << QString("sort");
-    QTest::newRow("Array.prototype.splice") << QString("Array.prototype.splice") << QString("splice");
-    QTest::newRow("Array.prototype.unshift") << QString("Array.prototype.unshift") << QString("unshift");
-
-    QTest::newRow("Boolean") << QString("Boolean") << QString("Boolean");
-    QTest::newRow("Boolean.prototype.toString") << QString("Boolean.prototype.toString") << QString("toString");
-
-    QTest::newRow("Date") << QString("Date") << QString("Date");
-    QTest::newRow("Date.prototype.toString") << QString("Date.prototype.toString") << QString("toString");
-    QTest::newRow("Date.prototype.toDateString") << QString("Date.prototype.toDateString") << QString("toDateString");
-    QTest::newRow("Date.prototype.toTimeString") << QString("Date.prototype.toTimeString") << QString("toTimeString");
-    QTest::newRow("Date.prototype.toLocaleString") << QString("Date.prototype.toLocaleString") << QString("toLocaleString");
-    QTest::newRow("Date.prototype.toLocaleDateString") << QString("Date.prototype.toLocaleDateString") << QString("toLocaleDateString");
-    QTest::newRow("Date.prototype.toLocaleTimeString") << QString("Date.prototype.toLocaleTimeString") << QString("toLocaleTimeString");
-    QTest::newRow("Date.prototype.valueOf") << QString("Date.prototype.valueOf") << QString("valueOf");
-    QTest::newRow("Date.prototype.getTime") << QString("Date.prototype.getTime") << QString("getTime");
-    QTest::newRow("Date.prototype.getYear") << QString("Date.prototype.getYear") << QString("getYear");
-    QTest::newRow("Date.prototype.getFullYear") << QString("Date.prototype.getFullYear") << QString("getFullYear");
-    QTest::newRow("Date.prototype.getUTCFullYear") << QString("Date.prototype.getUTCFullYear") << QString("getUTCFullYear");
-    QTest::newRow("Date.prototype.getMonth") << QString("Date.prototype.getMonth") << QString("getMonth");
-    QTest::newRow("Date.prototype.getUTCMonth") << QString("Date.prototype.getUTCMonth") << QString("getUTCMonth");
-    QTest::newRow("Date.prototype.getDate") << QString("Date.prototype.getDate") << QString("getDate");
-    QTest::newRow("Date.prototype.getUTCDate") << QString("Date.prototype.getUTCDate") << QString("getUTCDate");
-    QTest::newRow("Date.prototype.getDay") << QString("Date.prototype.getDay") << QString("getDay");
-    QTest::newRow("Date.prototype.getUTCDay") << QString("Date.prototype.getUTCDay") << QString("getUTCDay");
-    QTest::newRow("Date.prototype.getHours") << QString("Date.prototype.getHours") << QString("getHours");
-    QTest::newRow("Date.prototype.getUTCHours") << QString("Date.prototype.getUTCHours") << QString("getUTCHours");
-    QTest::newRow("Date.prototype.getMinutes") << QString("Date.prototype.getMinutes") << QString("getMinutes");
-    QTest::newRow("Date.prototype.getUTCMinutes") << QString("Date.prototype.getUTCMinutes") << QString("getUTCMinutes");
-    QTest::newRow("Date.prototype.getSeconds") << QString("Date.prototype.getSeconds") << QString("getSeconds");
-    QTest::newRow("Date.prototype.getUTCSeconds") << QString("Date.prototype.getUTCSeconds") << QString("getUTCSeconds");
-    QTest::newRow("Date.prototype.getMilliseconds") << QString("Date.prototype.getMilliseconds") << QString("getMilliseconds");
-    QTest::newRow("Date.prototype.getUTCMilliseconds") << QString("Date.prototype.getUTCMilliseconds") << QString("getUTCMilliseconds");
-    QTest::newRow("Date.prototype.getTimezoneOffset") << QString("Date.prototype.getTimezoneOffset") << QString("getTimezoneOffset");
-    QTest::newRow("Date.prototype.setTime") << QString("Date.prototype.setTime") << QString("setTime");
-    QTest::newRow("Date.prototype.setMilliseconds") << QString("Date.prototype.setMilliseconds") << QString("setMilliseconds");
-    QTest::newRow("Date.prototype.setUTCMilliseconds") << QString("Date.prototype.setUTCMilliseconds") << QString("setUTCMilliseconds");
-    QTest::newRow("Date.prototype.setSeconds") << QString("Date.prototype.setSeconds") << QString("setSeconds");
-    QTest::newRow("Date.prototype.setUTCSeconds") << QString("Date.prototype.setUTCSeconds") << QString("setUTCSeconds");
-    QTest::newRow("Date.prototype.setMinutes") << QString("Date.prototype.setMinutes") << QString("setMinutes");
-    QTest::newRow("Date.prototype.setUTCMinutes") << QString("Date.prototype.setUTCMinutes") << QString("setUTCMinutes");
-    QTest::newRow("Date.prototype.setHours") << QString("Date.prototype.setHours") << QString("setHours");
-    QTest::newRow("Date.prototype.setUTCHours") << QString("Date.prototype.setUTCHours") << QString("setUTCHours");
-    QTest::newRow("Date.prototype.setDate") << QString("Date.prototype.setDate") << QString("setDate");
-    QTest::newRow("Date.prototype.setUTCDate") << QString("Date.prototype.setUTCDate") << QString("setUTCDate");
-    QTest::newRow("Date.prototype.setMonth") << QString("Date.prototype.setMonth") << QString("setMonth");
-    QTest::newRow("Date.prototype.setUTCMonth") << QString("Date.prototype.setUTCMonth") << QString("setUTCMonth");
-    QTest::newRow("Date.prototype.setYear") << QString("Date.prototype.setYear") << QString("setYear");
-    QTest::newRow("Date.prototype.setFullYear") << QString("Date.prototype.setFullYear") << QString("setFullYear");
-    QTest::newRow("Date.prototype.setUTCFullYear") << QString("Date.prototype.setUTCFullYear") << QString("setUTCFullYear");
-    QTest::newRow("Date.prototype.toUTCString") << QString("Date.prototype.toUTCString") << QString("toUTCString");
-    QTest::newRow("Date.prototype.toGMTString") << QString("Date.prototype.toGMTString") << QString("toGMTString");
-
-    QTest::newRow("Error") << QString("Error") << QString("Error");
-    QTest::newRow("Error.prototype.backtrace") << QString("Error.prototype.backtrace") << QString("backtrace");
-    QTest::newRow("Error.prototype.toString") << QString("Error.prototype.toString") << QString("toString");
-
-    QTest::newRow("EvalError") << QString("EvalError") << QString("EvalError");
-    QTest::newRow("RangeError") << QString("RangeError") << QString("RangeError");
-    QTest::newRow("ReferenceError") << QString("ReferenceError") << QString("ReferenceError");
-    QTest::newRow("SyntaxError") << QString("SyntaxError") << QString("SyntaxError");
-    QTest::newRow("TypeError") << QString("TypeError") << QString("TypeError");
-    QTest::newRow("URIError") << QString("URIError") << QString("URIError");
-
-    QTest::newRow("Function") << QString("Function") << QString("Function");
-    QTest::newRow("Function.prototype.toString") << QString("Function.prototype.toString") << QString("toString");
-    QTest::newRow("Function.prototype.apply") << QString("Function.prototype.apply") << QString("apply");
-    QTest::newRow("Function.prototype.call") << QString("Function.prototype.call") << QString("call");
-    QTest::newRow("Function.prototype.connect") << QString("Function.prototype.connect") << QString("connect");
-    QTest::newRow("Function.prototype.disconnect") << QString("Function.prototype.disconnect") << QString("disconnect");
-
-    QTest::newRow("Math.abs") << QString("Math.abs") << QString("abs");
-    QTest::newRow("Math.acos") << QString("Math.acos") << QString("acos");
-    QTest::newRow("Math.asin") << QString("Math.asin") << QString("asin");
-    QTest::newRow("Math.atan") << QString("Math.atan") << QString("atan");
-    QTest::newRow("Math.atan2") << QString("Math.atan2") << QString("atan2");
-    QTest::newRow("Math.ceil") << QString("Math.ceil") << QString("ceil");
-    QTest::newRow("Math.cos") << QString("Math.cos") << QString("cos");
-    QTest::newRow("Math.exp") << QString("Math.exp") << QString("exp");
-    QTest::newRow("Math.floor") << QString("Math.floor") << QString("floor");
-    QTest::newRow("Math.log") << QString("Math.log") << QString("log");
-    QTest::newRow("Math.max") << QString("Math.max") << QString("max");
-    QTest::newRow("Math.min") << QString("Math.min") << QString("min");
-    QTest::newRow("Math.pow") << QString("Math.pow") << QString("pow");
-    QTest::newRow("Math.random") << QString("Math.random") << QString("random");
-    QTest::newRow("Math.round") << QString("Math.round") << QString("round");
-    QTest::newRow("Math.sin") << QString("Math.sin") << QString("sin");
-    QTest::newRow("Math.sqrt") << QString("Math.sqrt") << QString("sqrt");
-    QTest::newRow("Math.tan") << QString("Math.tan") << QString("tan");
-
-    QTest::newRow("Number") << QString("Number") << QString("Number");
-    QTest::newRow("Number.prototype.toString") << QString("Number.prototype.toString") << QString("toString");
-    QTest::newRow("Number.prototype.toLocaleString") << QString("Number.prototype.toLocaleString") << QString("toLocaleString");
-    QTest::newRow("Number.prototype.valueOf") << QString("Number.prototype.valueOf") << QString("valueOf");
-    QTest::newRow("Number.prototype.toFixed") << QString("Number.prototype.toFixed") << QString("toFixed");
-    QTest::newRow("Number.prototype.toExponential") << QString("Number.prototype.toExponential") << QString("toExponential");
-    QTest::newRow("Number.prototype.toPrecision") << QString("Number.prototype.toPrecision") << QString("toPrecision");
-
-    QTest::newRow("Object") << QString("Object") << QString("Object");
-    QTest::newRow("Object.prototype.toString") << QString("Object.prototype.toString") << QString("toString");
-    QTest::newRow("Object.prototype.toLocaleString") << QString("Object.prototype.toLocaleString") << QString("toLocaleString");
-    QTest::newRow("Object.prototype.valueOf") << QString("Object.prototype.valueOf") << QString("valueOf");
-    QTest::newRow("Object.prototype.hasOwnProperty") << QString("Object.prototype.hasOwnProperty") << QString("hasOwnProperty");
-    QTest::newRow("Object.prototype.isPrototypeOf") << QString("Object.prototype.isPrototypeOf") << QString("isPrototypeOf");
-    QTest::newRow("Object.prototype.propertyIsEnumerable") << QString("Object.prototype.propertyIsEnumerable") << QString("propertyIsEnumerable");
-    QTest::newRow("Object.prototype.__defineGetter__") << QString("Object.prototype.__defineGetter__") << QString("__defineGetter__");
-    QTest::newRow("Object.prototype.__defineSetter__") << QString("Object.prototype.__defineSetter__") << QString("__defineSetter__");
-
-    QTest::newRow("RegExp") << QString("RegExp") << QString("RegExp");
-    QTest::newRow("RegExp.prototype.exec") << QString("RegExp.prototype.exec") << QString("exec");
-    QTest::newRow("RegExp.prototype.test") << QString("RegExp.prototype.test") << QString("test");
-    QTest::newRow("RegExp.prototype.toString") << QString("RegExp.prototype.toString") << QString("toString");
-
-    QTest::newRow("String") << QString("String") << QString("String");
-    QTest::newRow("String.prototype.toString") << QString("String.prototype.toString") << QString("toString");
-    QTest::newRow("String.prototype.valueOf") << QString("String.prototype.valueOf") << QString("valueOf");
-    QTest::newRow("String.prototype.charAt") << QString("String.prototype.charAt") << QString("charAt");
-    QTest::newRow("String.prototype.charCodeAt") << QString("String.prototype.charCodeAt") << QString("charCodeAt");
-    QTest::newRow("String.prototype.concat") << QString("String.prototype.concat") << QString("concat");
-    QTest::newRow("String.prototype.indexOf") << QString("String.prototype.indexOf") << QString("indexOf");
-    QTest::newRow("String.prototype.lastIndexOf") << QString("String.prototype.lastIndexOf") << QString("lastIndexOf");
-    QTest::newRow("String.prototype.localeCompare") << QString("String.prototype.localeCompare") << QString("localeCompare");
-    QTest::newRow("String.prototype.match") << QString("String.prototype.match") << QString("match");
-    QTest::newRow("String.prototype.replace") << QString("String.prototype.replace") << QString("replace");
-    QTest::newRow("String.prototype.search") << QString("String.prototype.search") << QString("search");
-    QTest::newRow("String.prototype.slice") << QString("String.prototype.slice") << QString("slice");
-    QTest::newRow("String.prototype.split") << QString("String.prototype.split") << QString("split");
-    QTest::newRow("String.prototype.substring") << QString("String.prototype.substring") << QString("substring");
-    QTest::newRow("String.prototype.toLowerCase") << QString("String.prototype.toLowerCase") << QString("toLowerCase");
-    QTest::newRow("String.prototype.toLocaleLowerCase") << QString("String.prototype.toLocaleLowerCase") << QString("toLocaleLowerCase");
-    QTest::newRow("String.prototype.toUpperCase") << QString("String.prototype.toUpperCase") << QString("toUpperCase");
-    QTest::newRow("String.prototype.toLocaleUpperCase") << QString("String.prototype.toLocaleUpperCase") << QString("toLocaleUpperCase");
-}
-
-class CallSpy : public QScriptEngineAgent
-{
-public:
-    CallSpy(QScriptEngine *engine) : QScriptEngineAgent(engine)
-    { engine->setAgent(this); }
-
-    void functionEntry(qint64 scriptId)
-    {
-        if (functionName.isEmpty() && engine()->currentContext()->parentContext()) {
-            QScriptContextInfo info(engine()->currentContext());
-            functionName = info.functionName();
-            expectedScriptId = scriptId;
-            actualScriptId = info.scriptId();
-        }
-    }
-
-    qint64 expectedScriptId;
-    qint64 actualScriptId;
-    QString functionName;
-};
-
-void tst_QScriptContextInfo::builtinFunctionNames()
-{
-    QFETCH(QString, expression);
-    QFETCH(QString, expectedName);
-    QScriptEngine eng;
-    CallSpy *spy = new CallSpy(&eng);
-    (void)eng.evaluate(QString::fromLatin1("%0()").arg(expression));
-    QCOMPARE(spy->functionName, expectedName);
-    QCOMPARE(spy->actualScriptId, spy->expectedScriptId);
-}
-
 void tst_QScriptContextInfo::nullContext()
 {
     QScriptContextInfo info((QScriptContext*)0);
diff --git a/tests/auto/qscriptengine/tst_qscriptengine.cpp b/tests/auto/qscriptengine/tst_qscriptengine.cpp
index 37be40c8c0..85cee280a3 100644
--- a/tests/auto/qscriptengine/tst_qscriptengine.cpp
+++ b/tests/auto/qscriptengine/tst_qscriptengine.cpp
@@ -83,6 +83,10 @@ private slots:
     void newQMetaObject();
     void newActivationObject();
     void getSetGlobalObject();
+    void globalObjectProperties();
+    void globalObjectGetterSetterProperty();
+    void builtinFunctionNames_data();
+    void builtinFunctionNames();
     void checkSyntax_data();
     void checkSyntax();
     void canEvaluate_data();
@@ -129,6 +133,9 @@ private slots:
     void installTranslatorFunctions();
     void functionScopes();
     void nativeFunctionScopes();
+
+    void qRegExpInport_data();
+    void qRegExpInport();
 };
 
 tst_QScriptEngine::tst_QScriptEngine()
@@ -192,7 +199,9 @@ void tst_QScriptEngine::pushPopContext()
 
     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
 }
 
@@ -457,10 +466,11 @@ void tst_QScriptEngine::newRegExp()
         QCOMPARE(rexp.isValid(), true);
         QCOMPARE(rexp.isRegExp(), true);
         QCOMPARE(rexp.isObject(), true);
-        QVERIFY(!rexp.isFunction());
+        QVERIFY(rexp.isFunction()); // in JSC, RegExp objects are callable
         // prototype should be RegExp.prototype
         QCOMPARE(rexp.prototype().isValid(), true);
-        QCOMPARE(rexp.prototype().isRegExp(), 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());
@@ -477,7 +487,7 @@ void tst_QScriptEngine::newRegExp()
 
         QScriptValue r3 = rxCtor.call(QScriptValue(), QScriptValueList() << r << "gim");
         QVERIFY(r3.isError());
-        QCOMPARE(r3.toString(), QString::fromLatin1("TypeError: cannot specify flags when creating a copy of a RegExp"));
+        QCOMPARE(r3.toString(), QString::fromLatin1("TypeError: Cannot supply flags when constructing one RegExp from another."));
 
         QScriptValue r4 = rxCtor.call(QScriptValue(), QScriptValueList() << "foo" << "gim");
         QVERIFY(r4.isRegExp());
@@ -485,15 +495,17 @@ void tst_QScriptEngine::newRegExp()
         QScriptValue r5 = rxCtor.construct(QScriptValueList() << r);
         QVERIFY(r5.isRegExp());
         QCOMPARE(r5.toString(), QString::fromLatin1("/foo/gim"));
-        QVERIFY(!r5.strictlyEquals(r));
+        // 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));
 
         QScriptValue r6 = rxCtor.construct(QScriptValueList() << "foo" << "bar");
         QVERIFY(r6.isError());
-        QCOMPARE(r6.toString(), QString::fromLatin1("SyntaxError: invalid regular expression flag 'b'"));
+        QCOMPARE(r6.toString(), QString::fromLatin1("SyntaxError: Invalid regular expression: invalid regular expression flag"));
 
         QScriptValue r7 = eng.evaluate("/foo/gimp");
         QVERIFY(r7.isError());
-        QCOMPARE(r7.toString(), QString::fromLatin1("SyntaxError: Invalid regular expression flag 'p'"));
+        QCOMPARE(r7.toString(), QString::fromLatin1("SyntaxError: Invalid regular expression: invalid regular expression flag"));
 
         QScriptValue r8 = eng.evaluate("/foo/migmigmig");
         QVERIFY(r8.isRegExp());
@@ -599,6 +611,8 @@ void tst_QScriptEngine::newQObject()
             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);
     }
     {
@@ -628,6 +642,8 @@ void tst_QScriptEngine::newQObject()
         }
         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);
     }
     {
@@ -798,9 +814,22 @@ void tst_QScriptEngine::newQMetaObject()
     QVERIFY(instance3.instanceOf(qclass));
     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();
     eng.collectGarbage();
+
+    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);
@@ -851,15 +880,20 @@ void tst_QScriptEngine::newQMetaObject()
 
 void tst_QScriptEngine::newActivationObject()
 {
+    QSKIP("internal function not implemented in JSC-based back-end", SkipAll);
     QScriptEngine eng;
     QScriptValue act = eng.newActivationObject();
+    QEXPECT_FAIL("", "", Continue);
     QCOMPARE(act.isValid(), true);
+    QEXPECT_FAIL("", "", Continue);
     QCOMPARE(act.isObject(), true);
     QVERIFY(!act.isFunction());
     QScriptValue v(&eng, 123);
     act.setProperty("prop", v);
+    QEXPECT_FAIL("", "", Continue);
     QCOMPARE(act.property("prop").strictlyEquals(v), true);
     QCOMPARE(act.scope().isValid(), false);
+    QEXPECT_FAIL("", "", Continue);
     QVERIFY(act.prototype().isNull());
 }
 
@@ -929,6 +963,342 @@ void tst_QScriptEngine::getSetGlobalObject()
     }
 }
 
+static QScriptValue getSetFoo(QScriptContext *ctx, QScriptEngine *)
+{
+    if (ctx->argumentCount() > 0)
+        ctx->thisObject().setProperty("foo", ctx->argument(0));
+    return ctx->thisObject().property("foo");
+}
+
+void tst_QScriptEngine::globalObjectProperties()
+{
+    QScriptEngine eng;
+    QScriptValue global = eng.globalObject();
+
+    QVERIFY(global.property("NaN").isNumber());
+    QVERIFY(qIsNaN(global.property("NaN").toNumber()));
+    QCOMPARE(global.propertyFlags("NaN"), QScriptValue::SkipInEnumeration | QScriptValue::Undeletable);
+
+    QVERIFY(global.property("Infinity").isNumber());
+    QVERIFY(qIsInf(global.property("Infinity").toNumber()));
+    QCOMPARE(global.propertyFlags("NaN"), QScriptValue::SkipInEnumeration | QScriptValue::Undeletable);
+
+    QVERIFY(global.property("undefined").isUndefined());
+    QCOMPARE(global.propertyFlags("undefined"), QScriptValue::SkipInEnumeration | QScriptValue::Undeletable);
+
+    QVERIFY(global.property("eval").isFunction());
+    QCOMPARE(global.propertyFlags("eval"), QScriptValue::SkipInEnumeration);
+
+    QVERIFY(global.property("parseInt").isFunction());
+    QCOMPARE(global.propertyFlags("parseInt"), QScriptValue::SkipInEnumeration);
+
+    QVERIFY(global.property("parseFloat").isFunction());
+    QCOMPARE(global.propertyFlags("parseFloat"), QScriptValue::SkipInEnumeration);
+
+    QVERIFY(global.property("isNaN").isFunction());
+    QCOMPARE(global.propertyFlags("isNaN"), QScriptValue::SkipInEnumeration);
+
+    QVERIFY(global.property("isFinite").isFunction());
+    QCOMPARE(global.propertyFlags("isFinite"), QScriptValue::SkipInEnumeration);
+
+    QVERIFY(global.property("decodeURI").isFunction());
+    QCOMPARE(global.propertyFlags("decodeURI"), QScriptValue::SkipInEnumeration);
+
+    QVERIFY(global.property("decodeURIComponent").isFunction());
+    QCOMPARE(global.propertyFlags("decodeURIComponent"), QScriptValue::SkipInEnumeration);
+
+    QVERIFY(global.property("encodeURI").isFunction());
+    QCOMPARE(global.propertyFlags("encodeURI"), QScriptValue::SkipInEnumeration);
+
+    QVERIFY(global.property("encodeURIComponent").isFunction());
+    QCOMPARE(global.propertyFlags("encodeURIComponent"), QScriptValue::SkipInEnumeration);
+
+    QVERIFY(global.property("Object").isFunction());
+    QCOMPARE(global.propertyFlags("Object"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("Function").isFunction());
+    QCOMPARE(global.propertyFlags("Function"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("Array").isFunction());
+    QCOMPARE(global.propertyFlags("Array"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("String").isFunction());
+    QCOMPARE(global.propertyFlags("String"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("Boolean").isFunction());
+    QCOMPARE(global.propertyFlags("Boolean"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("Number").isFunction());
+    QCOMPARE(global.propertyFlags("Number"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("Date").isFunction());
+    QCOMPARE(global.propertyFlags("Date"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("RegExp").isFunction());
+    QCOMPARE(global.propertyFlags("RegExp"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("Error").isFunction());
+    QCOMPARE(global.propertyFlags("Error"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("EvalError").isFunction());
+    QCOMPARE(global.propertyFlags("EvalError"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("RangeError").isFunction());
+    QCOMPARE(global.propertyFlags("RangeError"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("ReferenceError").isFunction());
+    QCOMPARE(global.propertyFlags("ReferenceError"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("SyntaxError").isFunction());
+    QCOMPARE(global.propertyFlags("SyntaxError"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("TypeError").isFunction());
+    QCOMPARE(global.propertyFlags("TypeError"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("URIError").isFunction());
+    QCOMPARE(global.propertyFlags("URIError"), QScriptValue::SkipInEnumeration);
+    QVERIFY(global.property("Math").isObject());
+    QVERIFY(!global.property("Math").isFunction());
+    QEXPECT_FAIL("", "[ECMA compliance] JSC sets DontDelete flag for Math object", Continue);
+    QCOMPARE(global.propertyFlags("Math"), QScriptValue::SkipInEnumeration);
+
+    // enumeration
+    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"
+        ;
+    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());
+}
+
+void tst_QScriptEngine::globalObjectGetterSetterProperty()
+{
+    QScriptEngine engine;
+    QScriptValue global = engine.globalObject();
+    global.setProperty("bar", engine.newFunction(getSetFoo),
+                       QScriptValue::PropertySetter | QScriptValue::PropertyGetter);
+    global.setProperty("foo", 123);
+    QVERIFY(global.property("bar").equals(global.property("foo")));
+    QVERIFY(engine.evaluate("bar").equals(global.property("foo")));
+    global.setProperty("bar", 456);
+    QVERIFY(global.property("bar").equals(global.property("foo")));
+
+    engine.evaluate("__defineGetter__('baz', function() { return 789; })");
+    QVERIFY(engine.evaluate("baz").equals(789));
+    QVERIFY(global.property("baz").equals(789));
+}
+
+void tst_QScriptEngine::builtinFunctionNames_data()
+{
+    QTest::addColumn<QString>("expression");
+    QTest::addColumn<QString>("expectedName");
+
+    QTest::newRow("print") << QString("print") << QString("print");
+    QTest::newRow("parseInt") << QString("parseInt") << QString("parseInt");
+    QTest::newRow("parseFloat") << QString("parseFloat") << QString("parseFloat");
+    QTest::newRow("isNaN") << QString("isNaN") << QString("isNaN");
+    QTest::newRow("isFinite") << QString("isFinite") << QString("isFinite");
+    QTest::newRow("decodeURI") << QString("decodeURI") << QString("decodeURI");
+    QTest::newRow("decodeURIComponent") << QString("decodeURIComponent") << QString("decodeURIComponent");
+    QTest::newRow("encodeURI") << QString("encodeURI") << QString("encodeURI");
+    QTest::newRow("encodeURIComponent") << QString("encodeURIComponent") << QString("encodeURIComponent");
+    QTest::newRow("escape") << QString("escape") << QString("escape");
+    QTest::newRow("unescape") << QString("unescape") << QString("unescape");
+    QTest::newRow("version") << QString("version") << QString("version");
+    QTest::newRow("gc") << QString("gc") << QString("gc");
+
+    QTest::newRow("Array") << QString("Array") << QString("Array");
+    QTest::newRow("Array.prototype.toString") << QString("Array.prototype.toString") << QString("toString");
+    QTest::newRow("Array.prototype.toLocaleString") << QString("Array.prototype.toLocaleString") << QString("toLocaleString");
+    QTest::newRow("Array.prototype.concat") << QString("Array.prototype.concat") << QString("concat");
+    QTest::newRow("Array.prototype.join") << QString("Array.prototype.join") << QString("join");
+    QTest::newRow("Array.prototype.pop") << QString("Array.prototype.pop") << QString("pop");
+    QTest::newRow("Array.prototype.push") << QString("Array.prototype.push") << QString("push");
+    QTest::newRow("Array.prototype.reverse") << QString("Array.prototype.reverse") << QString("reverse");
+    QTest::newRow("Array.prototype.shift") << QString("Array.prototype.shift") << QString("shift");
+    QTest::newRow("Array.prototype.slice") << QString("Array.prototype.slice") << QString("slice");
+    QTest::newRow("Array.prototype.sort") << QString("Array.prototype.sort") << QString("sort");
+    QTest::newRow("Array.prototype.splice") << QString("Array.prototype.splice") << QString("splice");
+    QTest::newRow("Array.prototype.unshift") << QString("Array.prototype.unshift") << QString("unshift");
+
+    QTest::newRow("Boolean") << QString("Boolean") << QString("Boolean");
+    QTest::newRow("Boolean.prototype.toString") << QString("Boolean.prototype.toString") << QString("toString");
+
+    QTest::newRow("Date") << QString("Date") << QString("Date");
+    QTest::newRow("Date.prototype.toString") << QString("Date.prototype.toString") << QString("toString");
+    QTest::newRow("Date.prototype.toDateString") << QString("Date.prototype.toDateString") << QString("toDateString");
+    QTest::newRow("Date.prototype.toTimeString") << QString("Date.prototype.toTimeString") << QString("toTimeString");
+    QTest::newRow("Date.prototype.toLocaleString") << QString("Date.prototype.toLocaleString") << QString("toLocaleString");
+    QTest::newRow("Date.prototype.toLocaleDateString") << QString("Date.prototype.toLocaleDateString") << QString("toLocaleDateString");
+    QTest::newRow("Date.prototype.toLocaleTimeString") << QString("Date.prototype.toLocaleTimeString") << QString("toLocaleTimeString");
+    QTest::newRow("Date.prototype.valueOf") << QString("Date.prototype.valueOf") << QString("valueOf");
+    QTest::newRow("Date.prototype.getTime") << QString("Date.prototype.getTime") << QString("getTime");
+    QTest::newRow("Date.prototype.getYear") << QString("Date.prototype.getYear") << QString("getYear");
+    QTest::newRow("Date.prototype.getFullYear") << QString("Date.prototype.getFullYear") << QString("getFullYear");
+    QTest::newRow("Date.prototype.getUTCFullYear") << QString("Date.prototype.getUTCFullYear") << QString("getUTCFullYear");
+    QTest::newRow("Date.prototype.getMonth") << QString("Date.prototype.getMonth") << QString("getMonth");
+    QTest::newRow("Date.prototype.getUTCMonth") << QString("Date.prototype.getUTCMonth") << QString("getUTCMonth");
+    QTest::newRow("Date.prototype.getDate") << QString("Date.prototype.getDate") << QString("getDate");
+    QTest::newRow("Date.prototype.getUTCDate") << QString("Date.prototype.getUTCDate") << QString("getUTCDate");
+    QTest::newRow("Date.prototype.getDay") << QString("Date.prototype.getDay") << QString("getDay");
+    QTest::newRow("Date.prototype.getUTCDay") << QString("Date.prototype.getUTCDay") << QString("getUTCDay");
+    QTest::newRow("Date.prototype.getHours") << QString("Date.prototype.getHours") << QString("getHours");
+    QTest::newRow("Date.prototype.getUTCHours") << QString("Date.prototype.getUTCHours") << QString("getUTCHours");
+    QTest::newRow("Date.prototype.getMinutes") << QString("Date.prototype.getMinutes") << QString("getMinutes");
+    QTest::newRow("Date.prototype.getUTCMinutes") << QString("Date.prototype.getUTCMinutes") << QString("getUTCMinutes");
+    QTest::newRow("Date.prototype.getSeconds") << QString("Date.prototype.getSeconds") << QString("getSeconds");
+    QTest::newRow("Date.prototype.getUTCSeconds") << QString("Date.prototype.getUTCSeconds") << QString("getUTCSeconds");
+    QTest::newRow("Date.prototype.getMilliseconds") << QString("Date.prototype.getMilliseconds") << QString("getMilliseconds");
+    QTest::newRow("Date.prototype.getUTCMilliseconds") << QString("Date.prototype.getUTCMilliseconds") << QString("getUTCMilliseconds");
+    QTest::newRow("Date.prototype.getTimezoneOffset") << QString("Date.prototype.getTimezoneOffset") << QString("getTimezoneOffset");
+    QTest::newRow("Date.prototype.setTime") << QString("Date.prototype.setTime") << QString("setTime");
+    QTest::newRow("Date.prototype.setMilliseconds") << QString("Date.prototype.setMilliseconds") << QString("setMilliseconds");
+    QTest::newRow("Date.prototype.setUTCMilliseconds") << QString("Date.prototype.setUTCMilliseconds") << QString("setUTCMilliseconds");
+    QTest::newRow("Date.prototype.setSeconds") << QString("Date.prototype.setSeconds") << QString("setSeconds");
+    QTest::newRow("Date.prototype.setUTCSeconds") << QString("Date.prototype.setUTCSeconds") << QString("setUTCSeconds");
+    QTest::newRow("Date.prototype.setMinutes") << QString("Date.prototype.setMinutes") << QString("setMinutes");
+    QTest::newRow("Date.prototype.setUTCMinutes") << QString("Date.prototype.setUTCMinutes") << QString("setUTCMinutes");
+    QTest::newRow("Date.prototype.setHours") << QString("Date.prototype.setHours") << QString("setHours");
+    QTest::newRow("Date.prototype.setUTCHours") << QString("Date.prototype.setUTCHours") << QString("setUTCHours");
+    QTest::newRow("Date.prototype.setDate") << QString("Date.prototype.setDate") << QString("setDate");
+    QTest::newRow("Date.prototype.setUTCDate") << QString("Date.prototype.setUTCDate") << QString("setUTCDate");
+    QTest::newRow("Date.prototype.setMonth") << QString("Date.prototype.setMonth") << QString("setMonth");
+    QTest::newRow("Date.prototype.setUTCMonth") << QString("Date.prototype.setUTCMonth") << QString("setUTCMonth");
+    QTest::newRow("Date.prototype.setYear") << QString("Date.prototype.setYear") << QString("setYear");
+    QTest::newRow("Date.prototype.setFullYear") << QString("Date.prototype.setFullYear") << QString("setFullYear");
+    QTest::newRow("Date.prototype.setUTCFullYear") << QString("Date.prototype.setUTCFullYear") << QString("setUTCFullYear");
+    QTest::newRow("Date.prototype.toUTCString") << QString("Date.prototype.toUTCString") << QString("toUTCString");
+    QTest::newRow("Date.prototype.toGMTString") << QString("Date.prototype.toGMTString") << QString("toGMTString");
+
+    QTest::newRow("Error") << QString("Error") << QString("Error");
+//    QTest::newRow("Error.prototype.backtrace") << QString("Error.prototype.backtrace") << QString("backtrace");
+    QTest::newRow("Error.prototype.toString") << QString("Error.prototype.toString") << QString("toString");
+
+    QTest::newRow("EvalError") << QString("EvalError") << QString("EvalError");
+    QTest::newRow("RangeError") << QString("RangeError") << QString("RangeError");
+    QTest::newRow("ReferenceError") << QString("ReferenceError") << QString("ReferenceError");
+    QTest::newRow("SyntaxError") << QString("SyntaxError") << QString("SyntaxError");
+    QTest::newRow("TypeError") << QString("TypeError") << QString("TypeError");
+    QTest::newRow("URIError") << QString("URIError") << QString("URIError");
+
+    QTest::newRow("Function") << QString("Function") << QString("Function");
+    QTest::newRow("Function.prototype.toString") << QString("Function.prototype.toString") << QString("toString");
+    QTest::newRow("Function.prototype.apply") << QString("Function.prototype.apply") << QString("apply");
+    QTest::newRow("Function.prototype.call") << QString("Function.prototype.call") << QString("call");
+    QTest::newRow("Function.prototype.connect") << QString("Function.prototype.connect") << QString("connect");
+    QTest::newRow("Function.prototype.disconnect") << QString("Function.prototype.disconnect") << QString("disconnect");
+
+    QTest::newRow("Math.abs") << QString("Math.abs") << QString("abs");
+    QTest::newRow("Math.acos") << QString("Math.acos") << QString("acos");
+    QTest::newRow("Math.asin") << QString("Math.asin") << QString("asin");
+    QTest::newRow("Math.atan") << QString("Math.atan") << QString("atan");
+    QTest::newRow("Math.atan2") << QString("Math.atan2") << QString("atan2");
+    QTest::newRow("Math.ceil") << QString("Math.ceil") << QString("ceil");
+    QTest::newRow("Math.cos") << QString("Math.cos") << QString("cos");
+    QTest::newRow("Math.exp") << QString("Math.exp") << QString("exp");
+    QTest::newRow("Math.floor") << QString("Math.floor") << QString("floor");
+    QTest::newRow("Math.log") << QString("Math.log") << QString("log");
+    QTest::newRow("Math.max") << QString("Math.max") << QString("max");
+    QTest::newRow("Math.min") << QString("Math.min") << QString("min");
+    QTest::newRow("Math.pow") << QString("Math.pow") << QString("pow");
+    QTest::newRow("Math.random") << QString("Math.random") << QString("random");
+    QTest::newRow("Math.round") << QString("Math.round") << QString("round");
+    QTest::newRow("Math.sin") << QString("Math.sin") << QString("sin");
+    QTest::newRow("Math.sqrt") << QString("Math.sqrt") << QString("sqrt");
+    QTest::newRow("Math.tan") << QString("Math.tan") << QString("tan");
+
+    QTest::newRow("Number") << QString("Number") << QString("Number");
+    QTest::newRow("Number.prototype.toString") << QString("Number.prototype.toString") << QString("toString");
+    QTest::newRow("Number.prototype.toLocaleString") << QString("Number.prototype.toLocaleString") << QString("toLocaleString");
+    QTest::newRow("Number.prototype.valueOf") << QString("Number.prototype.valueOf") << QString("valueOf");
+    QTest::newRow("Number.prototype.toFixed") << QString("Number.prototype.toFixed") << QString("toFixed");
+    QTest::newRow("Number.prototype.toExponential") << QString("Number.prototype.toExponential") << QString("toExponential");
+    QTest::newRow("Number.prototype.toPrecision") << QString("Number.prototype.toPrecision") << QString("toPrecision");
+
+    QTest::newRow("Object") << QString("Object") << QString("Object");
+    QTest::newRow("Object.prototype.toString") << QString("Object.prototype.toString") << QString("toString");
+    QTest::newRow("Object.prototype.toLocaleString") << QString("Object.prototype.toLocaleString") << QString("toLocaleString");
+    QTest::newRow("Object.prototype.valueOf") << QString("Object.prototype.valueOf") << QString("valueOf");
+    QTest::newRow("Object.prototype.hasOwnProperty") << QString("Object.prototype.hasOwnProperty") << QString("hasOwnProperty");
+    QTest::newRow("Object.prototype.isPrototypeOf") << QString("Object.prototype.isPrototypeOf") << QString("isPrototypeOf");
+    QTest::newRow("Object.prototype.propertyIsEnumerable") << QString("Object.prototype.propertyIsEnumerable") << QString("propertyIsEnumerable");
+    QTest::newRow("Object.prototype.__defineGetter__") << QString("Object.prototype.__defineGetter__") << QString("__defineGetter__");
+    QTest::newRow("Object.prototype.__defineSetter__") << QString("Object.prototype.__defineSetter__") << QString("__defineSetter__");
+
+    QTest::newRow("RegExp") << QString("RegExp") << QString("RegExp");
+    QTest::newRow("RegExp.prototype.exec") << QString("RegExp.prototype.exec") << QString("exec");
+    QTest::newRow("RegExp.prototype.test") << QString("RegExp.prototype.test") << QString("test");
+    QTest::newRow("RegExp.prototype.toString") << QString("RegExp.prototype.toString") << QString("toString");
+
+    QTest::newRow("String") << QString("String") << QString("String");
+    QTest::newRow("String.prototype.toString") << QString("String.prototype.toString") << QString("toString");
+    QTest::newRow("String.prototype.valueOf") << QString("String.prototype.valueOf") << QString("valueOf");
+    QTest::newRow("String.prototype.charAt") << QString("String.prototype.charAt") << QString("charAt");
+    QTest::newRow("String.prototype.charCodeAt") << QString("String.prototype.charCodeAt") << QString("charCodeAt");
+    QTest::newRow("String.prototype.concat") << QString("String.prototype.concat") << QString("concat");
+    QTest::newRow("String.prototype.indexOf") << QString("String.prototype.indexOf") << QString("indexOf");
+    QTest::newRow("String.prototype.lastIndexOf") << QString("String.prototype.lastIndexOf") << QString("lastIndexOf");
+    QTest::newRow("String.prototype.localeCompare") << QString("String.prototype.localeCompare") << QString("localeCompare");
+    QTest::newRow("String.prototype.match") << QString("String.prototype.match") << QString("match");
+    QTest::newRow("String.prototype.replace") << QString("String.prototype.replace") << QString("replace");
+    QTest::newRow("String.prototype.search") << QString("String.prototype.search") << QString("search");
+    QTest::newRow("String.prototype.slice") << QString("String.prototype.slice") << QString("slice");
+    QTest::newRow("String.prototype.split") << QString("String.prototype.split") << QString("split");
+    QTest::newRow("String.prototype.substring") << QString("String.prototype.substring") << QString("substring");
+    QTest::newRow("String.prototype.toLowerCase") << QString("String.prototype.toLowerCase") << QString("toLowerCase");
+    QTest::newRow("String.prototype.toLocaleLowerCase") << QString("String.prototype.toLocaleLowerCase") << QString("toLocaleLowerCase");
+    QTest::newRow("String.prototype.toUpperCase") << QString("String.prototype.toUpperCase") << QString("toUpperCase");
+    QTest::newRow("String.prototype.toLocaleUpperCase") << QString("String.prototype.toLocaleUpperCase") << QString("toLocaleUpperCase");
+}
+
+void tst_QScriptEngine::builtinFunctionNames()
+{
+    QFETCH(QString, expression);
+    QFETCH(QString, expectedName);
+    QScriptEngine eng;
+    QScriptValue ret = eng.evaluate(QString::fromLatin1("%0.name").arg(expression));
+    QVERIFY(ret.isString());
+    QCOMPARE(ret.toString(), expectedName);
+}
+
 void tst_QScriptEngine::checkSyntax_data()
 {
     QTest::addColumn<QString>("code");
@@ -1068,7 +1438,7 @@ void tst_QScriptEngine::evaluate_data()
     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("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;
 
@@ -1081,7 +1451,7 @@ void tst_QScriptEngine::evaluate_data()
                          << -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("0=1")   << QString("\n\n0=1\n") << 10 << true  << 13;
     QTest::newRow("a=1")   << QString("a=1\n")   << 10 << false << -1;
     QTest::newRow("a=1;K") << QString("a=1;\n\nK") << 10 << true  << 12;
 
@@ -1135,10 +1505,13 @@ void tst_QScriptEngine::evaluate()
 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;
 }
 
@@ -1147,9 +1520,13 @@ void tst_QScriptEngine::nestedEvaluate()
     QScriptEngine eng;
     eng.globalObject().setProperty("fun", eng.newFunction(eval_nested));
     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");
+    QVERIFY(bar.isError());
+    QCOMPARE(bar.toString(), QString::fromLatin1("ReferenceError: Can't find variable: bar"));
 }
 
 void tst_QScriptEngine::uncaughtException()
@@ -1157,7 +1534,7 @@ void tst_QScriptEngine::uncaughtException()
     QScriptEngine eng;
     QScriptValue fun = eng.newFunction(myFunction);
     QScriptValue throwFun = eng.newFunction(myThrowingFunction);
-    for (int x = 0; x < 2; ++x) {
+    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());
@@ -1172,7 +1549,7 @@ void tst_QScriptEngine::uncaughtException()
             QVERIFY(eng.uncaughtException().strictlyEquals(ret));
             eng.clearExceptions();
             QVERIFY(!eng.hasUncaughtException());
-            QCOMPARE(eng.uncaughtExceptionLineNumber(), x+2);
+            QCOMPARE(eng.uncaughtExceptionLineNumber(), -1);
             QVERIFY(!eng.uncaughtException().isValid());
 
             eng.evaluate("2 = 3");
@@ -1181,7 +1558,7 @@ void tst_QScriptEngine::uncaughtException()
             QVERIFY(ret2.isError());
             QVERIFY(eng.hasUncaughtException());
             QVERIFY(eng.uncaughtException().strictlyEquals(ret2));
-            QCOMPARE(eng.uncaughtExceptionLineNumber(), -1);
+            QCOMPARE(eng.uncaughtExceptionLineNumber(), 0);
             eng.clearExceptions();
             QVERIFY(!eng.hasUncaughtException());
             eng.evaluate("1 + 2");
@@ -1586,8 +1963,27 @@ void tst_QScriptEngine::valueConversion()
         QRegExp in = QRegExp("foo");
         QScriptValue val = qScriptValueFromValue(&eng, in);
         QVERIFY(val.isRegExp());
+        QRegExp out = val.toRegExp();
+        QEXPECT_FAIL("", "JSC-based back-end doesn't preserve QRegExp::patternSyntax (always uses RegExp2)", Continue);
+        QCOMPARE(out.patternSyntax(), in.patternSyntax());
+        QCOMPARE(out.pattern(), in.pattern());
+        QCOMPARE(out.caseSensitivity(), in.caseSensitivity());
+        QCOMPARE(out.isMinimal(), in.isMinimal());
+    }
+    {
+        QRegExp in = QRegExp("foo", Qt::CaseSensitive, QRegExp::RegExp2);
+        QScriptValue val = qScriptValueFromValue(&eng, in);
+        QVERIFY(val.isRegExp());
         QCOMPARE(val.toRegExp(), in);
     }
+    {
+        QRegExp in = QRegExp("foo");
+        in.setMinimal(true);
+        QScriptValue val = qScriptValueFromValue(&eng, in);
+        QVERIFY(val.isRegExp());
+        QEXPECT_FAIL("", "JSC-based back-end doesn't preserve QRegExp::minimal (always false)", Continue);
+        QCOMPARE(val.toRegExp().isMinimal(), in.isMinimal());
+    }
 }
 
 static QScriptValue __import__(QScriptContext *ctx, QScriptEngine *eng)
@@ -1683,9 +2079,10 @@ void tst_QScriptEngine::importExtension()
                 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());
-            QCOMPARE(ret.property("message").toString(), QLatin1String("invalid assignment lvalue"));
+            QCOMPARE(ret.property("message").toString(), QLatin1String("Parse error"));
         }
         QStringList imp = eng.importedExtensions();
         QCOMPARE(imp.size(), 2);
@@ -1711,26 +2108,27 @@ static QScriptValue recurse2(QScriptContext *ctx, QScriptEngine *eng)
 
 void tst_QScriptEngine::infiniteRecursion()
 {
-    QSKIP("Can cause C stack overflow (task 241294)", SkipAll);
-
+    const QString stackOverflowError = QString::fromLatin1("RangeError: Maximum call stack size exceeded.");
     QScriptEngine eng;
     {
         QScriptValue ret = eng.evaluate("function foo() { foo(); }; foo();");
         QCOMPARE(ret.isError(), true);
-        QCOMPARE(ret.toString(), QLatin1String("Error: call stack overflow"));
+        QCOMPARE(ret.toString(), stackOverflowError);
     }
+#if 0 //The native C++ stack overflow before the JS stack
     {
         QScriptValue fun = eng.newFunction(recurse);
         QScriptValue ret = fun.call();
         QCOMPARE(ret.isError(), true);
-        QCOMPARE(ret.toString(), QLatin1String("Error: call stack overflow"));
+        QCOMPARE(ret.toString(), stackOverflowError);
     }
     {
         QScriptValue fun = eng.newFunction(recurse2);
         QScriptValue ret = fun.construct();
         QCOMPARE(ret.isError(), true);
-        QCOMPARE(ret.toString(), QLatin1String("Error: call stack overflow"));
+        QCOMPARE(ret.toString(), stackOverflowError);
     }
+#endif
 }
 
 struct Bar {
@@ -1898,6 +2296,7 @@ void tst_QScriptEngine::collectGarbage()
         QScriptValue v = eng.newQObject(ptr, QScriptEngine::ScriptOwnership);
     }
     eng.collectGarbage();
+    QEXPECT_FAIL("","collectGarbage not working", Continue);
     QVERIFY(ptr == 0);
 }
 
@@ -1954,7 +2353,7 @@ void tst_QScriptEngine::processEventsWhileRunning()
             eng.pushContext();
 
         QString script = QString::fromLatin1(
-            "var end = Number(new Date()) + 1000;"
+            "var end = Number(new Date()) + 2000;"
             "var x = 0;"
             "while (Number(new Date()) < end) {"
             "    ++x;"
@@ -1997,6 +2396,7 @@ public:
 
 void tst_QScriptEngine::throwErrorFromProcessEvents()
 {
+    QSKIP("Not implemented", SkipAll);
     QScriptEngine eng;
 
     EventReceiver2 receiver(&eng);
@@ -2040,6 +2440,7 @@ void tst_QScriptEngine::stacktrace()
     QVERIFY(eng.hasUncaughtException());
     QVERIFY(result.isError());
 
+    QEXPECT_FAIL("", "", Abort);
     QCOMPARE(eng.uncaughtExceptionBacktrace(), backtrace);
     QVERIFY(eng.hasUncaughtException());
     QVERIFY(result.strictlyEquals(eng.uncaughtException()));
@@ -2150,7 +2551,7 @@ void tst_QScriptEngine::automaticSemicolonInsertion()
     {
         QScriptValue ret = eng.evaluate("{ 1 2 } 3");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("SyntaxError: Expected `;', `;'"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("SyntaxError: Parse error"));
     }
     {
         QScriptValue ret = eng.evaluate("{ 1\n2 } 3");
@@ -2160,7 +2561,7 @@ void tst_QScriptEngine::automaticSemicolonInsertion()
     {
         QScriptValue ret = eng.evaluate("for (a; b\n)");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("SyntaxError: Expected `;'"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("SyntaxError: Parse error"));
     }
     {
         QScriptValue ret = eng.evaluate("(function() { return\n1 + 2 })()");
@@ -2175,7 +2576,7 @@ void tst_QScriptEngine::automaticSemicolonInsertion()
     {
         QScriptValue ret = eng.evaluate("if (a > b)\nelse c = d");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("SyntaxError"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("SyntaxError: Parse error"));
     }
     {
         eng.evaluate("function c() { return { foo: function() { return 5; } } }");
@@ -2187,7 +2588,7 @@ void tst_QScriptEngine::automaticSemicolonInsertion()
     {
         QScriptValue ret = eng.evaluate("throw\n1");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("SyntaxError"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("SyntaxError: Parse error"));
     }
     {
         QScriptValue ret = eng.evaluate("a = Number(1)\n++a");
@@ -2393,6 +2794,13 @@ void tst_QScriptEngine::abortEvaluation()
     eng.abortEvaluation();
     QVERIFY(!eng.hasUncaughtException());
 
+    eng.abortEvaluation(123);
+    {
+        QScriptValue ret = eng.evaluate("'ciao'");
+        QVERIFY(ret.isString());
+        QCOMPARE(ret.toString(), QString::fromLatin1("ciao"));
+    }
+
     EventReceiver3 receiver(&eng);
 
     eng.setProcessEventsInterval(100);
@@ -2557,31 +2965,46 @@ void tst_QScriptEngine::errorConstructors()
     QScriptEngine eng;
     QStringList prefixes;
     prefixes << "" << "Eval" << "Range" << "Reference" << "Syntax" << "Type" << "URI";
-    for (int x = 0; x < 2; ++x) {
+    for (int x = 0; x < 3; ++x) {
         for (int i = 0; i < prefixes.size(); ++i) {
             QString name = prefixes.at(i) + QLatin1String("Error");
             QString code = QString(i+1, QLatin1Char('\n'));
             if (x == 0)
+                code += QLatin1String("throw ");
+            else if (x == 1)
                 code += QLatin1String("new ");
             code += name + QLatin1String("()");
             QScriptValue ret = eng.evaluate(code);
             QVERIFY(ret.isError());
-            QVERIFY(!eng.hasUncaughtException());
-            QCOMPARE(ret.toString(), name);
+            QCOMPARE(eng.hasUncaughtException(), x == 0);
+            eng.clearExceptions();
+            QVERIFY(ret.toString().startsWith(name));
+            if (x != 0)
+                QEXPECT_FAIL("", "JSC doesn't assign lineNumber when errors are not thrown", Continue);
             QCOMPARE(ret.property("lineNumber").toInt32(), i+2);
         }
     }
 }
 
+static QScriptValue argumentsProperty_fun(QScriptContext *, QScriptEngine *eng)
+{
+    eng->evaluate("var a = arguments[0];");
+    eng->evaluate("arguments[0] = 200;");
+    return eng->evaluate("a + arguments[0]");
+}
+
+
 void tst_QScriptEngine::argumentsProperty()
 {
     {
         QScriptEngine eng;
+        QEXPECT_FAIL("", "", Continue);
         QVERIFY(eng.evaluate("arguments").isUndefined());
         eng.evaluate("arguments = 10");
         QScriptValue ret = eng.evaluate("arguments");
         QVERIFY(ret.isNumber());
         QCOMPARE(ret.toInt32(), 10);
+        QEXPECT_FAIL("", "", Continue);
         QVERIFY(!eng.evaluate("delete arguments").toBoolean());
     }
     {
@@ -2596,8 +3019,18 @@ void tst_QScriptEngine::argumentsProperty()
         QScriptValue ret = eng.evaluate("(function() { arguments = 456; return arguments; })()");
         QVERIFY(ret.isNumber());
         QCOMPARE(ret.toInt32(), 456);
+        QEXPECT_FAIL("", "", Continue);
         QVERIFY(eng.evaluate("arguments").isUndefined());
     }
+
+    {
+        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(), 218);
+    }
 }
 
 void tst_QScriptEngine::numberClass()
@@ -2695,7 +3128,7 @@ void tst_QScriptEngine::numberClass()
     {
         QScriptValue ret = eng.evaluate("new Number(123).toExponential()");
         QVERIFY(ret.isString());
-        QCOMPARE(ret.toString(), QString::fromLatin1("1e+02"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("1.23e+2"));
     }
     QVERIFY(proto.property("toFixed").isFunction());
     {
@@ -2707,7 +3140,7 @@ void tst_QScriptEngine::numberClass()
     {
         QScriptValue ret = eng.evaluate("new Number(123).toPrecision()");
         QVERIFY(ret.isString());
-        QCOMPARE(ret.toString(), QString::fromLatin1("1e+02"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("123"));
     }
 }
 
@@ -2781,9 +3214,8 @@ void tst_QScriptEngine::forInStatement()
         QScriptValue ret = eng.evaluate("o = { p: 123 }; r = [];"
                                         "for (var p in o) { r[r.length] = p; o.q = 456; } r");
         QStringList lst = qscriptvalue_cast<QStringList>(ret);
-        QCOMPARE(lst.size(), 2);
+        QCOMPARE(lst.size(), 1);
         QCOMPARE(lst.at(0), QString::fromLatin1("p"));
-        QCOMPARE(lst.at(1), QString::fromLatin1("q"));
     }
 
     // arrays
@@ -2800,9 +3232,9 @@ void tst_QScriptEngine::forInStatement()
                                         "for (var p in a) r[r.length] = p; r");
         QStringList lst = qscriptvalue_cast<QStringList>(ret);
         QCOMPARE(lst.size(), 3);
-        QCOMPARE(lst.at(0), QString::fromLatin1("foo"));
-        QCOMPARE(lst.at(1), QString::fromLatin1("0"));
-        QCOMPARE(lst.at(2), QString::fromLatin1("1"));
+        QCOMPARE(lst.at(0), QString::fromLatin1("0"));
+        QCOMPARE(lst.at(1), QString::fromLatin1("1"));
+        QCOMPARE(lst.at(2), QString::fromLatin1("foo"));
     }
     {
         QScriptValue ret = eng.evaluate("a = [123, 456]; a.foo = 'bar';"
@@ -2811,10 +3243,11 @@ void tst_QScriptEngine::forInStatement()
                                         "for (var p in a) r[r.length] = p; r");
         QStringList lst = qscriptvalue_cast<QStringList>(ret);
         QCOMPARE(lst.size(), 5);
-        QCOMPARE(lst.at(0), QString::fromLatin1("foo"));
-        QCOMPARE(lst.at(1), QString::fromLatin1("0"));
-        QCOMPARE(lst.at(2), QString::fromLatin1("1"));
-        QCOMPARE(lst.at(3), QString::fromLatin1("bar"));
+        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"));
     }
 
     // null and undefined
@@ -2984,23 +3417,33 @@ void tst_QScriptEngine::getterSetterThisObject()
         eng.evaluate("__defineSetter__('x', function() { return this; });");
         {
             QScriptValue ret = eng.evaluate("x = 'foo'");
-            QVERIFY(ret.equals(eng.globalObject()));
+            // SpiderMonkey says setter return value, JSC says RHS.
+            QVERIFY(ret.isString());
+            QCOMPARE(ret.toString(), QString::fromLatin1("foo"));
         }
         {
             QScriptValue ret = eng.evaluate("(function() { return x = 'foo'; })()");
-            QVERIFY(ret.equals(eng.globalObject()));
+            // SpiderMonkey says setter return value, JSC says RHS.
+            QVERIFY(ret.isString());
+            QCOMPARE(ret.toString(), QString::fromLatin1("foo"));
         }
         {
             QScriptValue ret = eng.evaluate("with (this) x = 'foo'");
-            QVERIFY(ret.equals(eng.globalObject()));
+            // SpiderMonkey says setter return value, JSC says RHS.
+            QVERIFY(ret.isString());
+            QCOMPARE(ret.toString(), QString::fromLatin1("foo"));
         }
         {
             QScriptValue ret = eng.evaluate("with ({}) x = 'foo'");
-            QVERIFY(ret.equals(eng.globalObject()));
+            // SpiderMonkey says setter return value, JSC says RHS.
+            QVERIFY(ret.isString());
+            QCOMPARE(ret.toString(), QString::fromLatin1("foo"));
         }
         {
             QScriptValue ret = eng.evaluate("(function() { with ({}) return x = 'foo'; })()");
-            QVERIFY(ret.equals(eng.globalObject()));
+            // SpiderMonkey says setter return value, JSC says RHS.
+            QVERIFY(ret.isString());
+            QCOMPARE(ret.toString(), QString::fromLatin1("foo"));
         }
     }
 
@@ -3016,9 +3459,10 @@ void tst_QScriptEngine::getterSetterThisObject()
         eng.evaluate("q = {}; with (o) with (q) x").equals(eng.evaluate("o"));
         // write
         eng.evaluate("o.__defineSetter__('x', function() { return this; });");
-        QVERIFY(eng.evaluate("(o.x = 'foo') === o").toBoolean());
-        QVERIFY(eng.evaluate("with (o) x = 'foo'").equals(eng.evaluate("o")));
-        QVERIFY(eng.evaluate("with (o) with (q) x = 'foo'").equals(eng.evaluate("o")));
+        // 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"));
     }
 
     // getter+setter in prototype chain
@@ -3034,29 +3478,32 @@ void tst_QScriptEngine::getterSetterThisObject()
         eng.evaluate("with (q) with (o) x").equals(eng.evaluate("o"));
         // write
         eng.evaluate("o.__defineSetter__('x', function() { return this; });");
-        QVERIFY(eng.evaluate("(o.x = 'foo') === o").toBoolean());
-        QVERIFY(eng.evaluate("with (o) x = 'foo'").equals(eng.evaluate("o")));
-        QVERIFY(eng.evaluate("with (o) with (q) x = 'foo'").equals(eng.evaluate("o")));
+        // 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"));
     }
 
     // getter+setter in 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());
-        QVERIFY(eng.evaluate("with (act) x").equals(eng.evaluate("act")));
+        QEXPECT_FAIL("", "Exotic overload (don't care for now)", Continue);
+        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') === act").toBoolean());
-        QVERIFY(eng.evaluate("with (act) x = 'foo'").equals(eng.evaluate("act")));
-        QVERIFY(eng.evaluate("with (act) with (q) x = 'foo'").equals(eng.evaluate("act")));
+        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();
     }
 }
@@ -3141,6 +3588,7 @@ void tst_QScriptEngine::continueInSwitch()
 
 void tst_QScriptEngine::readOnlyPrototypeProperty()
 {
+    QSKIP("JSC semantics differ from old back-end and SpiderMonkey", SkipAll);
     QScriptEngine eng;
     QCOMPARE(eng.evaluate("o = {}; o.__proto__ = parseInt; o.length").toInt32(), 2);
     QCOMPARE(eng.evaluate("o.length = 4; o.length").toInt32(), 2);
@@ -3258,7 +3706,8 @@ void tst_QScriptEngine::reservedWords()
         QScriptEngine eng;
         QScriptValue ret = eng.evaluate(word + " = 123");
         QVERIFY(ret.isError());
-        QVERIFY(ret.toString().startsWith("SyntaxError"));
+        QString str = ret.toString();
+        QVERIFY(str.startsWith("SyntaxError") || str.startsWith("ReferenceError"));
     }
     {
         QScriptEngine eng;
@@ -3269,14 +3718,16 @@ void tst_QScriptEngine::reservedWords()
     {
         QScriptEngine eng;
         QScriptValue ret = eng.evaluate("o = {}; o." + word + " = 123");
-        QVERIFY(!ret.isError());
-        QVERIFY(ret.strictlyEquals(eng.evaluate("o." + word)));
+        // in the old back-end and in SpiderMonkey this is allowed, but not in JSC
+        QVERIFY(ret.isError());
+        QVERIFY(ret.toString().startsWith("SyntaxError"));
     }
     {
         QScriptEngine eng;
         QScriptValue ret = eng.evaluate("o = { " + word + ": 123 }");
-        QVERIFY(!ret.isError());
-        QVERIFY(ret.property(word).isNumber());
+        // in the old back-end and in SpiderMonkey this is allowed, but not in JSC
+        QVERIFY(ret.isError());
+        QVERIFY(ret.toString().startsWith("SyntaxError"));
     }
     {
         // SpiderMonkey allows this, but we don't
@@ -3290,66 +3741,66 @@ void tst_QScriptEngine::reservedWords()
 void tst_QScriptEngine::futureReservedWords_data()
 {
     QTest::addColumn<QString>("word");
-    QTest::newRow("abstract") << QString("abstract");
-    QTest::newRow("boolean") << QString("boolean");
-    QTest::newRow("byte") << QString("byte");
-    QTest::newRow("char") << QString("char");
-    QTest::newRow("class") << QString("class");
-    QTest::newRow("const") << QString("const");
-    QTest::newRow("debugger") << QString("debugger");
-    QTest::newRow("double") << QString("double");
-    QTest::newRow("enum") << QString("enum");
-    QTest::newRow("export") << QString("export");
-    QTest::newRow("extends") << QString("extends");
-    QTest::newRow("final") << QString("final");
-    QTest::newRow("float") << QString("float");
-    QTest::newRow("goto") << QString("goto");
-    QTest::newRow("implements") << QString("implements");
-    QTest::newRow("import") << QString("import");
-    QTest::newRow("int") << QString("int");
-    QTest::newRow("interface") << QString("interface");
-    QTest::newRow("long") << QString("long");
-    QTest::newRow("native") << QString("native");
-    QTest::newRow("package") << QString("package");
-    QTest::newRow("private") << QString("private");
-    QTest::newRow("protected") << QString("protected");
-    QTest::newRow("public") << QString("public");
-    QTest::newRow("short") << QString("short");
-    QTest::newRow("static") << QString("static");
-    QTest::newRow("super") << QString("super");
-    QTest::newRow("synchronized") << QString("synchronized");
-    QTest::newRow("throws") << QString("throws");
-    QTest::newRow("transient") << QString("transient");
-    QTest::newRow("volatile") << QString("volatile");
+    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_QScriptEngine::futureReservedWords()
 {
     QFETCH(QString, word);
+    QFETCH(bool, allowed);
     {
         QScriptEngine eng;
         QScriptValue ret = eng.evaluate(word + " = 123");
-        QVERIFY(ret.isError());
-        QVERIFY(ret.toString().startsWith("SyntaxError"));
+        QCOMPARE(!ret.isError(), allowed);
     }
     {
         QScriptEngine eng;
         QScriptValue ret = eng.evaluate("var " + word + " = 123");
-        QVERIFY(ret.isError());
-        QVERIFY(ret.toString().startsWith("SyntaxError"));
+        QCOMPARE(!ret.isError(), allowed);
     }
     {
         // this should probably be allowed (see task 162567)
         QScriptEngine eng;
         QScriptValue ret = eng.evaluate("o = {}; o." + word + " = 123");
-        QVERIFY(ret.isNumber());
+        QCOMPARE(ret.isNumber(), allowed);
+        QCOMPARE(!ret.isError(), allowed);
     }
     {
         // this should probably be allowed (see task 162567)
         QScriptEngine eng;
         QScriptValue ret = eng.evaluate("o = { " + word + ": 123 }");
-        QVERIFY(!ret.isError());
-        QVERIFY(ret.isObject());
+        QCOMPARE(!ret.isError(), allowed);
     }
 }
 
@@ -3368,7 +3819,7 @@ void tst_QScriptEngine::throwInsideWithStatement()
             "  bad;"
             "}");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("ReferenceError: bad is not defined"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("ReferenceError: Can't find variable: bad"));
     }
     {
         QScriptValue ret = eng.evaluate(
@@ -3381,9 +3832,10 @@ void tst_QScriptEngine::throwInsideWithStatement()
             "  bad;"
             "}");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("ReferenceError: bad is not defined"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("ReferenceError: Can't find variable: bad"));
     }
     {
+        eng.clearExceptions();
         QScriptValue ret = eng.evaluate(
             "o = { bug : \"no bug\" };"
             "with (o) {"
@@ -3393,10 +3845,12 @@ void tst_QScriptEngine::throwInsideWithStatement()
             "    bug;"
             "  }"
             "}");
-        QVERIFY(ret.isString());
-        QCOMPARE(ret.toString(), QString::fromLatin1("no bug"));
+        QVERIFY(ret.isNumber());
+        QCOMPARE(ret.toInt32(), 123);
+        QVERIFY(eng.hasUncaughtException());
     }
     {
+        eng.clearExceptions();
         QScriptValue ret = eng.evaluate(
             "o = { bug : \"no bug\" };"
             "with (o) {"
@@ -3405,7 +3859,7 @@ void tst_QScriptEngine::throwInsideWithStatement()
         QVERIFY(ret.isNumber());
         QScriptValue ret2 = eng.evaluate("bug");
         QVERIFY(ret2.isError());
-        QCOMPARE(ret2.toString(), QString::fromLatin1("ReferenceError: bug is not defined"));
+        QCOMPARE(ret2.toString(), QString::fromLatin1("ReferenceError: Can't find variable: bug"));
     }
 }
 
@@ -3417,13 +3871,35 @@ public:
 
 void tst_QScriptEngine::getSetAgent()
 {
-    QScriptEngine eng;
-    QCOMPARE(eng.agent(), (QScriptEngineAgent*)0);
-    TestAgent agent(&eng);
-    eng.setAgent(&agent);
-    QCOMPARE(eng.agent(), (QScriptEngineAgent*)&agent);
-    eng.setAgent(0);
-    QCOMPARE(eng.agent(), (QScriptEngineAgent*)0);
+    // case 1: 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;
+    }
+    // case 2: 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;
+    }
+    {
+        QScriptEngine eng;
+        QScriptEngine eng2;
+        TestAgent *agent = new TestAgent(&eng);
+        QTest::ignoreMessage(QtWarningMsg, "QScriptEngine::setAgent(): cannot set agent belonging to different engine");
+        eng2.setAgent(agent);
+    }
 }
 
 void tst_QScriptEngine::reentrancy()
@@ -3511,42 +3987,42 @@ void tst_QScriptEngine:: incDecNonObjectProperty()
     {
         QScriptValue ret = eng.evaluate("var a; a.n++");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: not an object"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: Result of expression 'a' [undefined] is not an object."));
     }
     {
         QScriptValue ret = eng.evaluate("var a; a.n--");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: not an object"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: Result of expression 'a' [undefined] is not an object."));
     }
     {
         QScriptValue ret = eng.evaluate("var a = null; a.n++");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: not an object"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: Result of expression 'a' [null] is not an object."));
     }
     {
         QScriptValue ret = eng.evaluate("var a = null; a.n--");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: not an object"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: Result of expression 'a' [null] is not an object."));
     }
     {
         QScriptValue ret = eng.evaluate("var a; ++a.n");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: not an object"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: Result of expression 'a' [null] is not an object."));
     }
     {
         QScriptValue ret = eng.evaluate("var a; --a.n");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: not an object"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: Result of expression 'a' [null] is not an object."));
     }
     {
         QScriptValue ret = eng.evaluate("var a; a.n += 1");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: not an object"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: Result of expression 'a' [null] is not an object."));
     }
     {
         QScriptValue ret = eng.evaluate("var a; a.n -= 1");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: not an object"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: Result of expression 'a' [null] is not an object."));
     }
     {
         QScriptValue ret = eng.evaluate("var a = 'ciao'; a.length++");
@@ -3621,6 +4097,7 @@ void tst_QScriptEngine::functionScopes()
         // top-level functions have only the global object in their scope
         QScriptValue fun = eng.evaluate("(function() {})");
         QVERIFY(fun.isFunction());
+        QEXPECT_FAIL("", "Function scope proxying is not implemented", Abort);
         QVERIFY(fun.scope().isObject());
         QVERIFY(fun.scope().strictlyEquals(eng.globalObject()));
         QVERIFY(!eng.globalObject().scope().isValid());
@@ -3689,7 +4166,7 @@ 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++; }");
+     return eng->evaluate("(function() { return count++; })");
 }
 
 void tst_QScriptEngine::nativeFunctionScopes()
@@ -3715,6 +4192,90 @@ void tst_QScriptEngine::nativeFunctionScopes()
             QCOMPARE(ret.toInt32(), 123);
         }
     }
+
+    //from http://doc.trolltech.com/latest/qtscript.html#nested-functions-and-the-scope-chain
+    {
+        QScriptEngine eng;
+        eng.evaluate("function counter() { var count = 0; return function() { return count++; } }\n"
+                     "var c1 = counter();  var c2 = counter(); ");
+        QCOMPARE(eng.evaluate("c1()").toString(), QString::fromLatin1("0"));
+        QCOMPARE(eng.evaluate("c1()").toString(), QString::fromLatin1("1"));
+        QCOMPARE(eng.evaluate("c2()").toString(), QString::fromLatin1("0"));
+        QCOMPARE(eng.evaluate("c2()").toString(), QString::fromLatin1("1"));
+        QVERIFY(!eng.hasUncaughtException());
+    }
+    {
+        QScriptEngine eng;
+        eng.globalObject().setProperty("counter", eng.newFunction(counter));
+        eng.evaluate("var c1 = counter();  var c2 = counter(); ");
+        QCOMPARE(eng.evaluate("c1()").toString(), QString::fromLatin1("0"));
+        QCOMPARE(eng.evaluate("c1()").toString(), QString::fromLatin1("1"));
+        QCOMPARE(eng.evaluate("c2()").toString(), QString::fromLatin1("0"));
+        QCOMPARE(eng.evaluate("c2()").toString(), QString::fromLatin1("1"));
+        QVERIFY(!eng.hasUncaughtException());
+    }
+    {
+        QScriptEngine eng;
+        eng.globalObject().setProperty("counter", eng.newFunction(counter_hybrid));
+        eng.evaluate("var c1 = counter();  var c2 = counter(); ");
+        QCOMPARE(eng.evaluate("c1()").toString(), QString::fromLatin1("0"));
+        QCOMPARE(eng.evaluate("c1()").toString(), QString::fromLatin1("1"));
+        QCOMPARE(eng.evaluate("c2()").toString(), QString::fromLatin1("0"));
+        QCOMPARE(eng.evaluate("c2()").toString(), QString::fromLatin1("1"));
+        QVERIFY(!eng.hasUncaughtException());
+    }
+}
+
+static QRegExp minimal(QRegExp r) { r.setMinimal(true); return r; }
+
+void tst_QScriptEngine::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]")) << "}?} ?} *";
+}
+
+void tst_QScriptEngine::qRegExpInport()
+{
+    QFETCH(QRegExp, rx);
+    QFETCH(QString, string);
+
+    QScriptEngine eng;
+    QScriptValue rexp;
+    rexp = eng.newRegExp(rx);
+
+    QCOMPARE(rexp.isValid(), true);
+    QCOMPARE(rexp.isRegExp(), true);
+    QVERIFY(rexp.isFunction());
+
+    QScriptValue func = eng.evaluate("(function(string, regexp) { return string.match(regexp); })");
+    QScriptValue result = func.call(QScriptValue(),  QScriptValueList() << string << rexp);
+
+    rx.indexIn(string);
+    for (int i = 0; i <= rx.numCaptures(); i++)  {
+        QCOMPARE(result.property(i).toString(), rx.cap(i));
+    }
 }
 
 QTEST_MAIN(tst_QScriptEngine)
diff --git a/tests/auto/qscriptengineagent/tst_qscriptengineagent.cpp b/tests/auto/qscriptengineagent/tst_qscriptengineagent.cpp
index 3ad9f07f7c..932803ad20 100644
--- a/tests/auto/qscriptengineagent/tst_qscriptengineagent.cpp
+++ b/tests/auto/qscriptengineagent/tst_qscriptengineagent.cpp
@@ -44,6 +44,7 @@
 
 #include <QtScript/qscriptengineagent.h>
 #include <QtScript/qscriptengine.h>
+#include <qscriptvalueiterator.h>
 
 //TESTED_CLASS=
 //TESTED_FILES=
@@ -67,16 +68,43 @@ signals:
     void testSignal(double arg);
 
 private slots:
+    void scriptLoadAndUnload_statement();
     void scriptLoadAndUnload();
+    void scriptLoadAndUnload_eval();
     void contextPushAndPop();
-    void functionEntryAndExit();
-    void positionChange();
+    void functionEntryAndExit_semicolon();
+    void functionEntryAndExit_expression();
+    void functionEntryAndExit_functionCall();
+    void functionEntryAndExit_functionCallWithoutReturn();
+    void functionEntryAndExit_functionDefinition();
+    void functionEntryAndExit_native();
+    void functionEntryAndExit_native2();
+    void functionEntryAndExit_nativeThrowing();
+    void functionEntryAndExit_builtin();
+    void functionEntryAndExit_objects();
+    void functionEntryAndExit_slots();
+    void functionEntryAndExit_property_set();
+    void functionEntryAndExit_property_get();
+    void functionEntryAndExit_call();
+    void functionEntryAndExit_functionReturn_construct();
+    void functionEntryAndExit_functionReturn_call();
+    void functionEntryAndExit_objectCall();
+    void positionChange_1();
+    void positionChange_2();
     void exceptionThrowAndCatch();
-    void eventOrder();
+    void eventOrder_assigment();
+    void eventOrder_functionDefinition();
+    void eventOrder_throwError();
+    void eventOrder_throwAndCatch();
+    void eventOrder_functions();
+    void eventOrder_throwCatchFinally();
+    void eventOrder_signalsHandling();
     void recursiveObserve();
     void multipleAgents();
     void syntaxError();
+    void extension_invoctaion();
     void extension();
+    void isEvaluatingInExtension();
 
 private:
     double m_testProperty;
@@ -94,13 +122,13 @@ struct ScriptEngineEvent
 {
     enum Type {
         ScriptLoad,
-        ScriptUnload,
+        ScriptUnload,//1
         ContextPush,
-        ContextPop,
-        FunctionEntry,
-        FunctionExit,
+        ContextPop,  //3
+        FunctionEntry, //4
+        FunctionExit, //5
         PositionChange,
-        ExceptionThrow,
+        ExceptionThrow,//7
         ExceptionCatch,
         DebuggerInvocationRequest
     };
@@ -288,7 +316,7 @@ QVariant ScriptEngineSpy::extension(Extension ext, const QVariant &arg)
     return QVariant();
 }
 
-void tst_QScriptEngineAgent::scriptLoadAndUnload()
+void tst_QScriptEngineAgent::scriptLoadAndUnload_statement()
 {
     QScriptEngine eng;
     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreScriptLoad
@@ -331,7 +359,15 @@ void tst_QScriptEngineAgent::scriptLoadAndUnload()
         QCOMPARE(spy->at(1).type, ScriptEngineEvent::ScriptUnload);
         QCOMPARE(spy->at(1).scriptId, spy->at(0).scriptId);
     }
+    delete spy;
+}
 
+void tst_QScriptEngineAgent::scriptLoadAndUnload()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreScriptLoad
+                                                       | ScriptEngineSpy::IgnoreScriptUnload));
+    QCOMPARE(eng.agent(), (QScriptEngineAgent*)spy);
     {
         spy->clear();
         QString code = "function foo() { print('ciao'); }";
@@ -383,6 +419,7 @@ void tst_QScriptEngineAgent::scriptLoadAndUnload()
 
         code = "bar = foo(); foo = null";
         eng.evaluate(code);
+        QEXPECT_FAIL("","ScriptUnload event occur in different places than in old backend", Abort);
         QCOMPARE(spy->count(), 3);
 
         QCOMPARE(spy->at(1).type, ScriptEngineEvent::ScriptLoad);
@@ -403,11 +440,19 @@ void tst_QScriptEngineAgent::scriptLoadAndUnload()
         eng.collectGarbage(); // foo() is GC'ed
         QCOMPARE(spy->count(), 6);
     }
+    delete spy;
+}
 
+void tst_QScriptEngineAgent::scriptLoadAndUnload_eval()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreScriptLoad
+                                                       | ScriptEngineSpy::IgnoreScriptUnload));
     {
         spy->clear();
         eng.evaluate("eval('function foo() { print(123); }')");
 
+        QEXPECT_FAIL("","Eval is threaded in different way that in old backend", Abort);
         QCOMPARE(spy->count(), 3);
 
         QCOMPARE(spy->at(0).type, ScriptEngineEvent::ScriptLoad);
@@ -420,7 +465,7 @@ void tst_QScriptEngineAgent::scriptLoadAndUnload()
         QCOMPARE(spy->at(2).type, ScriptEngineEvent::ScriptUnload);
         QCOMPARE(spy->at(2).scriptId, spy->at(0).scriptId);
     }
-
+    delete spy;
 }
 
 void tst_QScriptEngineAgent::contextPushAndPop()
@@ -455,12 +500,12 @@ static QScriptValue nativeFunctionCallingArg(QScriptContext *ctx, QScriptEngine
     return ctx->argument(0).call();
 }
 
-void tst_QScriptEngineAgent::functionEntryAndExit()
+/** check behaiviour of ';' */
+void tst_QScriptEngineAgent::functionEntryAndExit_semicolon()
 {
     QScriptEngine eng;
     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
                                                        | ScriptEngineSpy::IgnoreFunctionExit));
-
     {
         spy->clear();
         eng.evaluate(";");
@@ -474,7 +519,15 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         QCOMPARE(spy->at(1).scriptId, spy->at(0).scriptId);
         QVERIFY(spy->at(1).value.isUndefined());
     }
+    delete spy;
+}
 
+/** check behaiviour of expression */
+void tst_QScriptEngineAgent::functionEntryAndExit_expression()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
     {
         spy->clear();
         eng.evaluate("1 + 2");
@@ -491,10 +544,18 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         QVERIFY(spy->at(1).value.isNumber());
         QCOMPARE(spy->at(1).value.toNumber(), qsreal(3));
     }
+    delete spy;
+}
 
+/** check behaiviour of standard function call */
+void tst_QScriptEngineAgent::functionEntryAndExit_functionCall()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
     {
         spy->clear();
-        eng.evaluate("(function() { return 123; } )()");
+        QVERIFY(eng.evaluate("(function() { return 123; } )()").toNumber()==123);
 
         QCOMPARE(spy->count(), 4);
 
@@ -518,7 +579,46 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         QVERIFY(spy->at(3).value.isNumber());
         QCOMPARE(spy->at(3).value.toNumber(), qsreal(123));
     }
+    delete spy;
+}
+
+/** check behaiviour of standard function call */
+void tst_QScriptEngineAgent::functionEntryAndExit_functionCallWithoutReturn()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
+    {
+        spy->clear();
+        eng.evaluate("(function() { var a = 123; } )()");
+
+        QCOMPARE(spy->count(), 4);
+
+        // evaluate() entry
+        QCOMPARE(spy->at(0).type, ScriptEngineEvent::FunctionEntry);
+        QVERIFY(spy->at(0).scriptId != -1);
+
+        // anonymous function entry
+        QCOMPARE(spy->at(1).type, ScriptEngineEvent::FunctionEntry);
+        QCOMPARE(spy->at(1).scriptId, spy->at(0).scriptId);
+
+        // anonymous function exit
+        QCOMPARE(spy->at(2).type, ScriptEngineEvent::FunctionExit);
+        QCOMPARE(spy->at(2).scriptId, spy->at(0).scriptId);
+
+        // evaluate() exit
+        QCOMPARE(spy->at(3).type, ScriptEngineEvent::FunctionExit);
+        QCOMPARE(spy->at(3).scriptId, spy->at(0).scriptId);
+    }
+    delete spy;
+}
 
+/** check behaiviour of function definition */
+void tst_QScriptEngineAgent::functionEntryAndExit_functionDefinition()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
     {
         spy->clear();
         eng.evaluate("function foo() { return 456; }");
@@ -556,15 +656,23 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         QVERIFY(spy->at(5).value.isNumber());
         QCOMPARE(spy->at(5).value.toNumber(), qsreal(456));
     }
+    delete spy;
+}
 
+/** check behaiviour of native function */
+void tst_QScriptEngineAgent::functionEntryAndExit_native()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
     // native functions
-
     {
         QScriptValue fun = eng.newFunction(nativeFunctionReturningArg);
         eng.globalObject().setProperty("nativeFunctionReturningArg", fun);
 
         spy->clear();
         eng.evaluate("nativeFunctionReturningArg(123)");
+
         QCOMPARE(spy->count(), 4);
 
         // evaluate() entry
@@ -586,7 +694,15 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         QVERIFY(spy->at(3).value.isNumber());
         QCOMPARE(spy->at(3).value.toNumber(), qsreal(123));
     }
+    delete spy;
+}
 
+/** check behaiviour of native function */
+void tst_QScriptEngineAgent::functionEntryAndExit_native2()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
     {
         QScriptValue fun = eng.newFunction(nativeFunctionCallingArg);
         eng.globalObject().setProperty("nativeFunctionCallingArg", fun);
@@ -622,14 +738,25 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         QVERIFY(spy->at(5).value.isNumber());
         QCOMPARE(spy->at(5).value.toNumber(), qsreal(123));
     }
+    delete spy;
+}
 
+/** check behaiviour of native function throwing error*/
+void tst_QScriptEngineAgent::functionEntryAndExit_nativeThrowing()
+{
+    /* This function was changed from old backend. JSC return more Entrys / Exits, (exactly +1)
+       in exception creation time */
+
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
     {
         QScriptValue fun = eng.newFunction(nativeFunctionThrowingError);
         eng.globalObject().setProperty("nativeFunctionThrowingError", fun);
 
         spy->clear();
         eng.evaluate("nativeFunctionThrowingError('ciao')");
-        QCOMPARE(spy->count(), 4);
+        QCOMPARE(spy->count(), 6);
 
         // evaluate() entry
         QCOMPARE(spy->at(0).type, ScriptEngineEvent::FunctionEntry);
@@ -638,20 +765,38 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         QCOMPARE(spy->at(1).type, ScriptEngineEvent::FunctionEntry);
         QCOMPARE(spy->at(1).scriptId, qint64(-1));
 
-        // native function exit
-        QCOMPARE(spy->at(2).type, ScriptEngineEvent::FunctionExit);
+        // Exception constructor entry
+        QCOMPARE(spy->at(2).type, ScriptEngineEvent::FunctionEntry);
         QCOMPARE(spy->at(2).scriptId, qint64(-1));
-        QVERIFY(spy->at(2).value.isError());
 
-        // evaluate() exit
+        // Exception constructor exit
         QCOMPARE(spy->at(3).type, ScriptEngineEvent::FunctionExit);
-        QCOMPARE(spy->at(3).scriptId, spy->at(0).scriptId);
+        QCOMPARE(spy->at(3).scriptId, qint64(-1));
         QVERIFY(spy->at(3).value.isError());
+
+        // native function exit
+        QCOMPARE(spy->at(4).type, ScriptEngineEvent::FunctionExit);
+        QCOMPARE(spy->at(4).scriptId, qint64(-1));
+        QVERIFY(spy->at(4).value.isError());
+
+        // evaluate() exit
+        QCOMPARE(spy->at(5).type, ScriptEngineEvent::FunctionExit);
+        QCOMPARE(spy->at(5).scriptId, spy->at(0).scriptId);
+        QVERIFY(spy->at(5).value.isError());
     }
+    delete spy;
+}
 
+/** check behaiviour of built-in function */
+void tst_QScriptEngineAgent::functionEntryAndExit_builtin()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
     {
         spy->clear();
         eng.evaluate("'ciao'.toString()");
+
         QCOMPARE(spy->count(), 4);
 
         // evaluate() entry
@@ -673,11 +818,19 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         QVERIFY(spy->at(3).value.isString());
         QCOMPARE(spy->at(3).value.toString(), QString("ciao"));
     }
+    delete spy;
+}
 
+/** check behaiviour of object creation*/
+void tst_QScriptEngineAgent::functionEntryAndExit_objects()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
     {
         spy->clear();
         eng.evaluate("Array(); Boolean(); Date(); Function(); Number(); Object(); RegExp(); String()");
-        QCOMPARE(spy->count(), 20);
+        QCOMPARE(spy->count(), 18);
 
         // evaluate() entry
         QCOMPARE(spy->at(0).type, ScriptEngineEvent::FunctionEntry);
@@ -713,63 +866,62 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         QCOMPARE(spy->at(7).type, ScriptEngineEvent::FunctionEntry);
         QCOMPARE(spy->at(7).scriptId, qint64(-1));
 
-        // evaluate() entry
-        QCOMPARE(spy->at(8).type, ScriptEngineEvent::FunctionEntry);
-        QVERIFY(spy->at(8).scriptId != -1);
+        // Function constructor exit
+        QCOMPARE(spy->at(8).type, ScriptEngineEvent::FunctionExit);
+        QCOMPARE(spy->at(8).scriptId, qint64(-1));
+        QVERIFY(spy->at(8).value.isFunction());
 
-        // evaluate() exit
-        QCOMPARE(spy->at(9).type, ScriptEngineEvent::FunctionExit);
-        QCOMPARE(spy->at(9).scriptId, spy->at(8).scriptId);
-        QVERIFY(spy->at(9).value.isFunction());
+        // Number constructor entry
+        QCOMPARE(spy->at(9).type, ScriptEngineEvent::FunctionEntry);
+        QCOMPARE(spy->at(9).scriptId, qint64(-1));
 
-        // Function constructor exit
+        // Number constructor exit
         QCOMPARE(spy->at(10).type, ScriptEngineEvent::FunctionExit);
         QCOMPARE(spy->at(10).scriptId, qint64(-1));
-        QVERIFY(spy->at(10).value.isFunction());
+        QVERIFY(spy->at(10).value.isNumber());
 
-        // Number constructor entry
+        // Object constructor entry
         QCOMPARE(spy->at(11).type, ScriptEngineEvent::FunctionEntry);
         QCOMPARE(spy->at(11).scriptId, qint64(-1));
 
-        // Number constructor exit
+        // Object constructor exit
         QCOMPARE(spy->at(12).type, ScriptEngineEvent::FunctionExit);
         QCOMPARE(spy->at(12).scriptId, qint64(-1));
-        QVERIFY(spy->at(12).value.isNumber());
+        QVERIFY(spy->at(12).value.isObject());
 
-        // Object constructor entry
+        // RegExp constructor entry
         QCOMPARE(spy->at(13).type, ScriptEngineEvent::FunctionEntry);
         QCOMPARE(spy->at(13).scriptId, qint64(-1));
 
-        // Object constructor exit
+        // RegExp constructor exit
         QCOMPARE(spy->at(14).type, ScriptEngineEvent::FunctionExit);
         QCOMPARE(spy->at(14).scriptId, qint64(-1));
-        QVERIFY(spy->at(14).value.isObject());
+        QVERIFY(spy->at(14).value.isRegExp());
 
-        // RegExp constructor entry
+        // String constructor entry
         QCOMPARE(spy->at(15).type, ScriptEngineEvent::FunctionEntry);
         QCOMPARE(spy->at(15).scriptId, qint64(-1));
 
-        // RegExp constructor exit
+        // String constructor exit
         QCOMPARE(spy->at(16).type, ScriptEngineEvent::FunctionExit);
         QCOMPARE(spy->at(16).scriptId, qint64(-1));
-        QVERIFY(spy->at(16).value.isRegExp());
-
-        // String constructor entry
-        QCOMPARE(spy->at(17).type, ScriptEngineEvent::FunctionEntry);
-        QCOMPARE(spy->at(17).scriptId, qint64(-1));
-
-        // String constructor exit
-        QCOMPARE(spy->at(18).type, ScriptEngineEvent::FunctionExit);
-        QCOMPARE(spy->at(18).scriptId, qint64(-1));
-        QVERIFY(spy->at(18).value.isString());
+        QVERIFY(spy->at(16).value.isString());
 
         // evaluate() exit
-        QCOMPARE(spy->at(19).type, ScriptEngineEvent::FunctionExit);
-        QCOMPARE(spy->at(19).scriptId, spy->at(0).scriptId);
-        QVERIFY(spy->at(19).value.isString());
-        QCOMPARE(spy->at(19).value.toString(), QString());
+        QCOMPARE(spy->at(17).type, ScriptEngineEvent::FunctionExit);
+        QCOMPARE(spy->at(17).scriptId, spy->at(0).scriptId);
+        QVERIFY(spy->at(17).value.isString());
+        QCOMPARE(spy->at(17).value.toString(), QString());
     }
+    delete spy;
+}
 
+/** check behaiviour of slots*/
+void tst_QScriptEngineAgent::functionEntryAndExit_slots()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
     // slots
     {
         eng.globalObject().setProperty("qobj", eng.newQObject(this));
@@ -789,7 +941,15 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         // evaluate() exit
         QCOMPARE(spy->at(3).type, ScriptEngineEvent::FunctionExit);
     }
+    delete spy;
+}
 
+/** check behaiviour of property accessors*/
+void tst_QScriptEngineAgent::functionEntryAndExit_property_set()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
     // property accessors
     {
         eng.globalObject().setProperty("qobj", eng.newQObject(this));
@@ -810,7 +970,21 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         // evaluate() exit
         QCOMPARE(spy->at(3).type, ScriptEngineEvent::FunctionExit);
         QVERIFY(spy->at(3).value.strictlyEquals(spy->at(2).value));
+    }
+    delete spy;
+}
 
+/** check behaiviour of property accessors*/
+void tst_QScriptEngineAgent::functionEntryAndExit_property_get()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
+    // property accessors
+    {
+        eng.globalObject().setProperty("qobj", eng.newQObject(this));
+        // set
+        eng.evaluate("qobj.testProperty = 456");
         // get
         spy->clear();
         eng.evaluate("qobj.testProperty");
@@ -829,7 +1003,16 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         QCOMPARE(spy->at(3).type, ScriptEngineEvent::FunctionExit);
         QVERIFY(spy->at(3).value.strictlyEquals(spy->at(2).value));
     }
+    delete spy;
+}
 
+
+/** check behaiviour of calling script functions from c++*/
+void tst_QScriptEngineAgent::functionEntryAndExit_call()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
     // calling script functions from C++
 
     {
@@ -850,17 +1033,22 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         QVERIFY(spy->at(1).value.isNumber());
         QCOMPARE(spy->at(1).value.toNumber(), qsreal(123));
     }
+    delete spy;
+}
 
-    for (int x = 0; x < 2; ++x) {
+/** check behaiviour of native function returnning arg*/
+void tst_QScriptEngineAgent::functionEntryAndExit_functionReturn_call()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
+    {
         QScriptValue fun = eng.newFunction(nativeFunctionReturningArg);
 
         spy->clear();
         QScriptValueList args;
         args << QScriptValue(&eng, 123);
-        if (x)
-            fun.construct(args);
-        else
-            fun.call(QScriptValue(), args);
+        fun.call(QScriptValue(), args);
         QCOMPARE(spy->count(), 2);
 
         // entry
@@ -872,10 +1060,53 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         QCOMPARE(spy->at(1).scriptId, spy->at(0).scriptId);
         QVERIFY(spy->at(1).value.strictlyEquals(args.at(0)));
     }
+    delete spy;
+}
 
+void tst_QScriptEngineAgent::functionEntryAndExit_functionReturn_construct()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
+    {
+        QScriptValue fun = eng.newFunction(nativeFunctionReturningArg);
+
+        spy->clear();
+        QScriptValueList args;
+        args << QScriptValue(&eng, 123);
+        QScriptValue obj = fun.construct(args);
+
+        QVERIFY(args.at(0).isValid());
+        QVERIFY(args.at(0).isNumber());
+        QVERIFY(args.at(0).toNumber() == 123);
+
+        QCOMPARE(spy->count(), 2);
+
+        // entry
+        QCOMPARE(spy->at(0).type, ScriptEngineEvent::FunctionEntry);
+        QVERIFY(spy->at(0).scriptId == -1);
+
+        // exit
+        QCOMPARE(spy->at(1).type, ScriptEngineEvent::FunctionExit);
+        QCOMPARE(spy->at(1).scriptId, spy->at(0).scriptId);
+
+        QVERIFY(spy->at(1).value.strictlyEquals(args.at(0)));
+    }
+
+    delete spy;
+}
+
+/** check behaiviour of object creation with args (?)*/
+void tst_QScriptEngineAgent::functionEntryAndExit_objectCall()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry
+                                                       | ScriptEngineSpy::IgnoreFunctionExit));
     for (int x = 0; x < 2; ++x) {
         QScriptValue fun = eng.evaluate("Boolean");
 
+        QVERIFY(!fun.isError());
+
         spy->clear();
         QScriptValueList args;
         args << QScriptValue(&eng, true);
@@ -894,20 +1125,28 @@ void tst_QScriptEngineAgent::functionEntryAndExit()
         QCOMPARE(spy->at(1).scriptId, spy->at(0).scriptId);
         QVERIFY(spy->at(1).value.equals(args.at(0)));
     }
+    delete spy;
 }
 
-void tst_QScriptEngineAgent::positionChange()
+void tst_QScriptEngineAgent::positionChange_1()
 {
     QScriptEngine eng;
     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnorePositionChange));
     {
         spy->clear();
         eng.evaluate(";");
+        QEXPECT_FAIL("","JSC do not evaluate ';' to statemant",Continue);
         QCOMPARE(spy->count(), 1);
-        QCOMPARE(spy->at(0).type, ScriptEngineEvent::PositionChange);
-        QVERIFY(spy->at(0).scriptId != -1);
-        QCOMPARE(spy->at(0).lineNumber, 1);
-        QCOMPARE(spy->at(0).columnNumber, 1);
+        if (spy->count()) {
+            QEXPECT_FAIL("","JSC do not evaluate ';' to statemant",Continue);
+            QCOMPARE(spy->at(0).type, ScriptEngineEvent::PositionChange);
+            QEXPECT_FAIL("","JSC do not evaluate ';' to statemant",Continue);
+            QVERIFY(spy->at(0).scriptId != -1);
+            QEXPECT_FAIL("","JSC do not evaluate ';' to statemant",Continue);
+            QCOMPARE(spy->at(0).lineNumber, 1);
+            QEXPECT_FAIL("","JSC do not evaluate ';' to statemant",Continue);
+            QCOMPARE(spy->at(0).columnNumber, 1);
+        }
     }
 
     {
@@ -958,7 +1197,13 @@ void tst_QScriptEngineAgent::positionChange()
         QCOMPARE(spy->at(2).lineNumber, lineNumber + 1);
         QCOMPARE(spy->at(2).columnNumber, 1);
     }
+    delete spy;
+}
 
+void tst_QScriptEngineAgent::positionChange_2()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnorePositionChange));
     {
         spy->clear();
         int lineNumber = 789;
@@ -1115,42 +1360,6 @@ void tst_QScriptEngineAgent::positionChange()
 
     {
         spy->clear();
-        eng.evaluate("for (var i in { a: 10, b: 20 }) { void(i); }");
-        QCOMPARE(spy->count(), 5);
-
-        // for
-        QCOMPARE(spy->at(0).type, ScriptEngineEvent::PositionChange);
-        QVERIFY(spy->at(0).scriptId != -1);
-        QCOMPARE(spy->at(0).lineNumber, 1);
-        QCOMPARE(spy->at(0).columnNumber, 1);
-
-        // a: 10
-        QCOMPARE(spy->at(1).type, ScriptEngineEvent::PositionChange);
-        QCOMPARE(spy->at(1).scriptId, spy->at(0).scriptId);
-        QCOMPARE(spy->at(1).lineNumber, 1);
-        QCOMPARE(spy->at(1).columnNumber, 20);
-
-        // b: 20
-        QCOMPARE(spy->at(2).type, ScriptEngineEvent::PositionChange);
-        QCOMPARE(spy->at(2).scriptId, spy->at(0).scriptId);
-        QCOMPARE(spy->at(2).lineNumber, 1);
-        QCOMPARE(spy->at(2).columnNumber, 27);
-
-        // void(i)
-        QCOMPARE(spy->at(3).type, ScriptEngineEvent::PositionChange);
-        QCOMPARE(spy->at(3).scriptId, spy->at(0).scriptId);
-        QCOMPARE(spy->at(3).lineNumber, 1);
-        QCOMPARE(spy->at(3).columnNumber, 35);
-
-        // void(i)
-        QCOMPARE(spy->at(4).type, ScriptEngineEvent::PositionChange);
-        QCOMPARE(spy->at(4).scriptId, spy->at(0).scriptId);
-        QCOMPARE(spy->at(4).lineNumber, 1);
-        QCOMPARE(spy->at(4).columnNumber, 35);
-    }
-
-    {
-        spy->clear();
         eng.evaluate("for ( ; ; ) { break; }");
         QCOMPARE(spy->count(), 2);
 
@@ -1271,6 +1480,30 @@ void tst_QScriptEngineAgent::positionChange()
 
     {
         spy->clear();
+        eng.evaluate("try { throw 1; } catch(e) { i = e; } finally { i = 2; }");
+        QCOMPARE(spy->count(), 3);
+
+        // throw 1
+        QCOMPARE(spy->at(0).type, ScriptEngineEvent::PositionChange);
+        QVERIFY(spy->at(0).scriptId != -1);
+        QCOMPARE(spy->at(0).lineNumber, 1);
+        QCOMPARE(spy->at(0).columnNumber, 7);
+
+        // i = e
+        QCOMPARE(spy->at(1).type, ScriptEngineEvent::PositionChange);
+        QCOMPARE(spy->at(1).scriptId, spy->at(0).scriptId);
+        QCOMPARE(spy->at(1).lineNumber, 1);
+        QCOMPARE(spy->at(1).columnNumber, 29);
+
+        // i = 2
+        QCOMPARE(spy->at(2).type, ScriptEngineEvent::PositionChange);
+        QCOMPARE(spy->at(2).scriptId, spy->at(0).scriptId);
+        QCOMPARE(spy->at(2).lineNumber, 1);
+        QCOMPARE(spy->at(2).columnNumber, 48);
+    }
+
+    {
+        spy->clear();
         eng.evaluate("try { i = 1; } catch(e) { i = 2; } finally { i = 3; }");
         QCOMPARE(spy->count(), 2);
 
@@ -1288,28 +1521,26 @@ void tst_QScriptEngineAgent::positionChange()
     }
 
     {
+        QEXPECT_FAIL("","I believe the test is wrong. Expressions shouldn't call positionChange "
+                     "because statement '1+2' will call it at least twice, why debugger have to "
+                     "stop here so many times?", Abort);
         spy->clear();
-        eng.evaluate("try { throw 1; } catch(e) { i = e; } finally { i = 2; }");
-        QCOMPARE(spy->count(), 3);
+        eng.evaluate("c = {a: 10, b: 20}");
+        QCOMPARE(spy->count(), 2);
 
-        // throw 1
+        // a: 10
         QCOMPARE(spy->at(0).type, ScriptEngineEvent::PositionChange);
         QVERIFY(spy->at(0).scriptId != -1);
         QCOMPARE(spy->at(0).lineNumber, 1);
-        QCOMPARE(spy->at(0).columnNumber, 7);
+        QCOMPARE(spy->at(0).columnNumber, 1);
 
-        // i = e
+        // b: 20
         QCOMPARE(spy->at(1).type, ScriptEngineEvent::PositionChange);
         QCOMPARE(spy->at(1).scriptId, spy->at(0).scriptId);
         QCOMPARE(spy->at(1).lineNumber, 1);
-        QCOMPARE(spy->at(1).columnNumber, 29);
-
-        // i = 2
-        QCOMPARE(spy->at(2).type, ScriptEngineEvent::PositionChange);
-        QCOMPARE(spy->at(2).scriptId, spy->at(0).scriptId);
-        QCOMPARE(spy->at(2).lineNumber, 1);
-        QCOMPARE(spy->at(2).columnNumber, 48);
+        QCOMPARE(spy->at(1).columnNumber, 20);
     }
+    delete spy;
 }
 
 void tst_QScriptEngineAgent::exceptionThrowAndCatch()
@@ -1359,11 +1590,10 @@ void tst_QScriptEngineAgent::exceptionThrowAndCatch()
     }
 }
 
-void tst_QScriptEngineAgent::eventOrder()
+void tst_QScriptEngineAgent::eventOrder_assigment()
 {
     QScriptEngine eng;
     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng);
-
     {
         spy->clear();
         eng.evaluate("i = 3; i = 5");
@@ -1386,7 +1616,13 @@ void tst_QScriptEngineAgent::eventOrder()
         QCOMPARE(spy->at(5).type, ScriptEngineEvent::ScriptUnload);
         QCOMPARE(spy->at(5).scriptId, spy->at(0).scriptId);
     }
+    delete spy;
+}
 
+void tst_QScriptEngineAgent::eventOrder_functionDefinition()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng);
     {
         spy->clear();
         eng.evaluate("function foo(arg) { void(arg); }");
@@ -1429,7 +1665,13 @@ void tst_QScriptEngineAgent::eventOrder()
         eng.evaluate("foo = null");
         eng.collectGarbage();
     }
+    delete spy;
+}
 
+void tst_QScriptEngineAgent::eventOrder_throwError()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng);
     {
         spy->clear();
         eng.evaluate("throw new Error('ciao')");
@@ -1456,7 +1698,13 @@ void tst_QScriptEngineAgent::eventOrder()
         // unload
         QCOMPARE(spy->at(9).type, ScriptEngineEvent::ScriptUnload);
     }
+    delete spy;
+}
 
+void tst_QScriptEngineAgent::eventOrder_throwAndCatch()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng);
     {
         spy->clear();
         eng.evaluate("try { throw new Error('ciao') } catch (e) { void(e); }");
@@ -1490,7 +1738,13 @@ void tst_QScriptEngineAgent::eventOrder()
         // unload
         QCOMPARE(spy->at(11).type, ScriptEngineEvent::ScriptUnload);
     }
+    delete spy;
+}
 
+void tst_QScriptEngineAgent::eventOrder_functions()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng);
     {
         spy->clear();
         eng.evaluate("function foo(arg) { return bar(arg); }");
@@ -1544,6 +1798,7 @@ void tst_QScriptEngineAgent::eventOrder()
 
         // redefine bar()
         eng.evaluate("function bar(arg) { throw new Error(arg); }");
+        eng.collectGarbage();
         QCOMPARE(spy->count(), 25);
         QCOMPARE(spy->at(21).type, ScriptEngineEvent::ScriptLoad);
         QCOMPARE(spy->at(22).type, ScriptEngineEvent::FunctionEntry);
@@ -1552,7 +1807,8 @@ void tst_QScriptEngineAgent::eventOrder()
         QCOMPARE(spy->at(24).scriptId, spy->at(3).scriptId);
 
         eng.evaluate("foo('ciao')");
-        QCOMPARE(spy->count(), 45);
+
+        //QCOMPARE(spy->count(), 45);
 
         // load
         QCOMPARE(spy->at(25).type, ScriptEngineEvent::ScriptLoad);
@@ -1588,6 +1844,7 @@ void tst_QScriptEngineAgent::eventOrder()
         QCOMPARE(spy->at(37).type, ScriptEngineEvent::ContextPop);
         // exception
         QCOMPARE(spy->at(38).type, ScriptEngineEvent::ExceptionThrow);
+        QEXPECT_FAIL("","New backend propably gives bad script id for exceptions", Abort);
         QCOMPARE(spy->at(38).scriptId, spy->at(21).scriptId);
         QVERIFY(!spy->at(38).hasExceptionHandler);
         // bar() exit
@@ -1610,7 +1867,13 @@ void tst_QScriptEngineAgent::eventOrder()
         QCOMPARE(spy->at(44).type, ScriptEngineEvent::ScriptUnload);
         QCOMPARE(spy->at(44).scriptId, spy->at(25).scriptId);
     }
+    delete spy;
+}
 
+void tst_QScriptEngineAgent::eventOrder_throwCatchFinally()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng);
     {
         spy->clear();
         eng.evaluate("try { throw 1; } catch(e) { i = e; } finally { i = 2; }");
@@ -1635,11 +1898,17 @@ void tst_QScriptEngineAgent::eventOrder()
         // unload
         QCOMPARE(spy->at(8).type, ScriptEngineEvent::ScriptUnload);
     }
+    delete spy;
+}
 
+void tst_QScriptEngineAgent::eventOrder_signalsHandling()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng);
     // signal handling
     {
         spy->clear();
-        QScriptValue fun = eng.evaluate("function(arg) { throw Error(arg); }");
+        QScriptValue fun = eng.evaluate("(function(arg) { throw Error(arg); })");
         QVERIFY(fun.isFunction());
         QCOMPARE(spy->count(), 4);
         QCOMPARE(spy->at(0).type, ScriptEngineEvent::ScriptLoad);
@@ -1652,13 +1921,14 @@ void tst_QScriptEngineAgent::eventOrder()
 
         emit testSignal(123);
 
+        QEXPECT_FAIL("","Signals events problem", Abort);
         QCOMPARE(spy->count(), 14);
         // new context
         QCOMPARE(spy->at(4).type, ScriptEngineEvent::ContextPush);
         // anonymous function entry
         QCOMPARE(spy->at(5).type, ScriptEngineEvent::FunctionEntry);
         QCOMPARE(spy->at(5).scriptId, spy->at(0).scriptId);
-        // throw
+        // throw statement
         QCOMPARE(spy->at(6).type, ScriptEngineEvent::PositionChange);
         QCOMPARE(spy->at(6).scriptId, spy->at(0).scriptId);
         // new context
@@ -1683,6 +1953,7 @@ void tst_QScriptEngineAgent::eventOrder()
         // restore context
         QCOMPARE(spy->at(13).type, ScriptEngineEvent::ContextPop);
     }
+    delete spy;
 }
 
 class DoubleAgent : public ScriptEngineSpy
@@ -1707,32 +1978,45 @@ void tst_QScriptEngineAgent::recursiveObserve()
     eng.evaluate("3 + 4", "foo.qs", 123);
 
     QCOMPARE(spy->count(), 10);
-    // load "3 + 4"
-    QCOMPARE(spy->at(0).type, ScriptEngineEvent::ScriptLoad);
+
+    int i = 0;
+    // load "3 + 4"    
+    QCOMPARE(spy->at(i).type, ScriptEngineEvent::ScriptLoad);
+    i++;
     // evaluate() entry
-    QCOMPARE(spy->at(1).type, ScriptEngineEvent::FunctionEntry);
+    QCOMPARE(spy->at(i).type, ScriptEngineEvent::FunctionEntry);
+    i++;
     // load "1 + 2"
-    QCOMPARE(spy->at(2).type, ScriptEngineEvent::ScriptLoad);
+    QCOMPARE(spy->at(i).type, ScriptEngineEvent::ScriptLoad);
+    i++;
     // evaluate() entry
-    QCOMPARE(spy->at(3).type, ScriptEngineEvent::FunctionEntry);
+    QCOMPARE(spy->at(i).type, ScriptEngineEvent::FunctionEntry);
+    i++;
     // 1 + 2
-    QCOMPARE(spy->at(4).type, ScriptEngineEvent::PositionChange);
-    QCOMPARE(spy->at(4).scriptId, spy->at(2).scriptId);
+    QCOMPARE(spy->at(i).type, ScriptEngineEvent::PositionChange);
+    QCOMPARE(spy->at(i).scriptId, spy->at(2).scriptId);
+    i++;
     // evaluate() exit
-    QCOMPARE(spy->at(5).type, ScriptEngineEvent::FunctionExit);
+    QCOMPARE(spy->at(i).type, ScriptEngineEvent::FunctionExit);
+    i++;
     // unload "1 + 2"
-    QCOMPARE(spy->at(6).type, ScriptEngineEvent::ScriptUnload);
-    QCOMPARE(spy->at(6).scriptId, spy->at(2).scriptId);
+    QCOMPARE(spy->at(i).type, ScriptEngineEvent::ScriptUnload);
+    QCOMPARE(spy->at(i).scriptId, spy->at(2).scriptId);
+    i++;
     // 3 + 4
-    QCOMPARE(spy->at(7).type, ScriptEngineEvent::PositionChange);
-    QCOMPARE(spy->at(7).scriptId, spy->at(0).scriptId);
+    QCOMPARE(spy->at(i).type, ScriptEngineEvent::PositionChange);
+    QCOMPARE(spy->at(i).scriptId, spy->at(0).scriptId);
+    i++;
     // evaluate() exit
-    QCOMPARE(spy->at(8).type, ScriptEngineEvent::FunctionExit);
+    QCOMPARE(spy->at(i).type, ScriptEngineEvent::FunctionExit);
+    i++;
     // unload "3 + 4"
-    QCOMPARE(spy->at(9).type, ScriptEngineEvent::ScriptUnload);
-    QCOMPARE(spy->at(9).scriptId, spy->at(0).scriptId);
+    QCOMPARE(spy->at(i).type, ScriptEngineEvent::ScriptUnload);
+    QCOMPARE(spy->at(i).scriptId, spy->at(0).scriptId);
 }
 
+
+/** When second agent is attached to Engine the first one should be deatached */
 void tst_QScriptEngineAgent::multipleAgents()
 {
     QScriptEngine eng;
@@ -1755,31 +2039,56 @@ void tst_QScriptEngineAgent::multipleAgents()
 
 void tst_QScriptEngineAgent::syntaxError()
 {
+    /* This test was changed. Old backend didn't generate events in exception objects creation time
+        JSC does */
     QScriptEngine eng;
     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng);
     {
+        int i = 0;
         spy->clear();
         eng.evaluate("{");
-        QCOMPARE(spy->count(), 5);
-
-        QCOMPARE(spy->at(0).type, ScriptEngineEvent::ScriptLoad);
-        QVERIFY(spy->at(0).scriptId != -1);
-        QCOMPARE(spy->at(1).type, ScriptEngineEvent::FunctionEntry);
-        QCOMPARE(spy->at(1).scriptId, spy->at(0).scriptId);
-        QCOMPARE(spy->at(2).type, ScriptEngineEvent::ExceptionThrow);
-        QCOMPARE(spy->at(2).scriptId, spy->at(0).scriptId);
-        QVERIFY(!spy->at(2).hasExceptionHandler);
-        QVERIFY(spy->at(2).value.isError());
-        QCOMPARE(spy->at(2).value.toString(), QString("SyntaxError: Expected `}'"));
-        QCOMPARE(spy->at(2).scriptId, spy->at(0).scriptId);
-        QCOMPARE(spy->at(3).type, ScriptEngineEvent::FunctionExit);
-        QCOMPARE(spy->at(3).scriptId, spy->at(0).scriptId);
-        QCOMPARE(spy->at(4).type, ScriptEngineEvent::ScriptUnload);
-        QCOMPARE(spy->at(4).scriptId, spy->at(0).scriptId);
+        
+        //QCOMPARE(spy->count(), 9);
+
+        QCOMPARE(spy->at(i).type, ScriptEngineEvent::ScriptLoad);
+        QVERIFY(spy->at(i).scriptId != -1);
+        i = 1;
+        QCOMPARE(spy->at(i).type, ScriptEngineEvent::FunctionEntry);
+        QCOMPARE(spy->at(i).scriptId, spy->at(0).scriptId);
+
+        //create exception
+
+        i = 2;
+        QCOMPARE(spy->at(i).type, ScriptEngineEvent::ContextPush);
+        QVERIFY(spy->at(i).scriptId == -1);
+        i = 3;
+        QCOMPARE(spy->at(i).type, ScriptEngineEvent::FunctionEntry);
+        QVERIFY(spy->at(i).scriptId == -1);
+        i = 4;
+        QCOMPARE(spy->at(i).type, ScriptEngineEvent::FunctionExit);
+        QVERIFY(spy->at(i).scriptId == -1);
+        i = 5;
+        QCOMPARE(spy->at(i).type, ScriptEngineEvent::ContextPop);
+        QVERIFY(spy->at(i).scriptId == -1);
+        i = 6;
+        QCOMPARE(spy->at(i).type, ScriptEngineEvent::ExceptionThrow);
+        QCOMPARE(spy->at(i).scriptId, spy->at(0).scriptId);
+        QVERIFY(!spy->at(i).hasExceptionHandler);
+        QVERIFY(spy->at(i).value.isError());
+        QEXPECT_FAIL("","There are other messages in JSC",Continue);
+        QCOMPARE(spy->at(i).value.toString(), QString("SyntaxError: Expected `}'"));
+        QCOMPARE(spy->at(i).scriptId, spy->at(0).scriptId);
+        i = 7;
+        //exit script
+        QCOMPARE(spy->at(i).type, ScriptEngineEvent::FunctionExit);
+        QCOMPARE(spy->at(i).scriptId, spy->at(0).scriptId);
+        i = 8;
+        QCOMPARE(spy->at(i).type, ScriptEngineEvent::ScriptUnload);
+        QCOMPARE(spy->at(i).scriptId, spy->at(0).scriptId);
     }
 }
 
-void tst_QScriptEngineAgent::extension()
+void tst_QScriptEngineAgent::extension_invoctaion()
 {
     QScriptEngine eng;
     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreDebuggerInvocationRequest
@@ -1799,9 +2108,19 @@ void tst_QScriptEngineAgent::extension()
         QCOMPARE(spy->at(1).lineNumber, lineNumber);
         QCOMPARE(spy->at(1).columnNumber, 1);
 
+        QEXPECT_FAIL("","In JSC Eval('debugger') returns undefined",Abort);
         QVERIFY(ret.isString());
         QCOMPARE(ret.toString(), QString::fromLatin1("extension(DebuggerInvocationRequest)"));
     }
+    delete spy;
+}
+
+void tst_QScriptEngineAgent::extension()
+{
+    QScriptEngine eng;
+    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreDebuggerInvocationRequest
+                                                   | ScriptEngineSpy::IgnoreScriptLoad));
+
     {
         spy->clear();
         spy->enableIgnoreFlags(ScriptEngineSpy::IgnoreDebuggerInvocationRequest);
@@ -1810,9 +2129,32 @@ void tst_QScriptEngineAgent::extension()
 
         QCOMPARE(spy->count(), 1);
         QCOMPARE(spy->at(0).type, ScriptEngineEvent::ScriptLoad);
-
         QVERIFY(ret.isUndefined());
     }
+    delete spy;
+}
+
+class TestIsEvaluatingAgent : public QScriptEngineAgent
+{
+public:
+    TestIsEvaluatingAgent(QScriptEngine *engine)
+        : QScriptEngineAgent(engine), wasEvaluating(false)
+    { engine->setAgent(this); }
+    bool supportsExtension(Extension ext) const
+    { return ext == DebuggerInvocationRequest; }
+    QVariant extension(Extension, const QVariant &)
+    { wasEvaluating = engine()->isEvaluating(); return QVariant(); }
+
+    bool wasEvaluating;
+};
+
+void tst_QScriptEngineAgent::isEvaluatingInExtension()
+{
+    QScriptEngine eng;
+    TestIsEvaluatingAgent *spy = new TestIsEvaluatingAgent(&eng);
+    QVERIFY(!spy->wasEvaluating);
+    eng.evaluate("debugger");
+    QVERIFY(spy->wasEvaluating);
 }
 
 QTEST_MAIN(tst_QScriptEngineAgent)
diff --git a/tests/auto/qscriptenginedebugger/tst_qscriptenginedebugger.cpp b/tests/auto/qscriptenginedebugger/tst_qscriptenginedebugger.cpp
index 356e683d6d..70a198d6e5 100644
--- a/tests/auto/qscriptenginedebugger/tst_qscriptenginedebugger.cpp
+++ b/tests/auto/qscriptenginedebugger/tst_qscriptenginedebugger.cpp
@@ -479,7 +479,7 @@ void tst_QScriptEngineDebugger::consoleCommands()
 
     outputEdit->clear();
     executeConsoleCommand(inputEdit, outputEdit, ".backtrace");
-    QCOMPARE(outputEdit->toPlainText(), QString::fromLatin1("qsdb> .backtrace\n#0  <global>()@:-1"));
+    QCOMPARE(outputEdit->toPlainText(), QString::fromLatin1("qsdb> .backtrace\n#0  <global>() at -1"));
 
     outputEdit->clear();
     executeConsoleCommand(inputEdit, outputEdit, ".down");
@@ -491,7 +491,7 @@ void tst_QScriptEngineDebugger::consoleCommands()
 
     outputEdit->clear();
     executeConsoleCommand(inputEdit, outputEdit, ".frame");
-    QCOMPARE(outputEdit->toPlainText(), QString::fromLatin1("qsdb> .frame\n#0  <global>()@:-1"));
+    QCOMPARE(outputEdit->toPlainText(), QString::fromLatin1("qsdb> .frame\n#0  <global>() at -1"));
 
     outputEdit->clear();
     executeConsoleCommand(inputEdit, outputEdit, ".break foo.qs:789");
diff --git a/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp b/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp
index 7e03954b31..1a5788e81b 100644
--- a/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp
+++ b/tests/auto/qscriptextqobject/tst_qscriptextqobject.cpp
@@ -498,6 +498,7 @@ private slots:
     void getSetChildren();
     void callQtInvokable();
     void connectAndDisconnect();
+    void connectAndDisconnectWithBadArgs();
     void cppConnectAndDisconnect();
     void classEnums();
     void classConstructor();
@@ -841,14 +842,14 @@ void tst_QScriptExtQObject::getSetStaticProperty()
         m_engine->globalObject().setProperty("brushPointer", QScriptValue());
     }
 
-    // try to install custom property getter+setter
+    // install custom property getter+setter
     {
         QScriptValue mobj = m_engine->globalObject().property("myObject");
-        QTest::ignoreMessage(QtWarningMsg, "QScriptValue::setProperty() failed: "
-                             "cannot set getter or setter of native property "
-                             "`intProperty'");
         mobj.setProperty("intProperty", m_engine->newFunction(getSetProperty),
                          QScriptValue::PropertyGetter | QScriptValue::PropertySetter);
+        QVERIFY(mobj.property("intProperty").toInt32() != 321);
+        mobj.setProperty("intProperty", 321);
+        QCOMPARE(mobj.property("intProperty").toInt32(), 321);
     }
 
     // method properties are persistent
@@ -857,7 +858,7 @@ void tst_QScriptExtQObject::getSetStaticProperty()
         QVERIFY(slot.isFunction());
         QScriptValue sameSlot = m_engine->evaluate("myObject.mySlot");
         QVERIFY(sameSlot.strictlyEquals(slot));
-        sameSlot = m_engine->evaluate("myObject['mySlot()']");
+        sameSlot = m_engine->evaluate("myObject[mySlot()]");
         QEXPECT_FAIL("", "Signature-based method lookup creates new function wrapper object", Continue);
         QVERIFY(sameSlot.strictlyEquals(slot));
     }
@@ -900,6 +901,8 @@ void tst_QScriptExtQObject::getSetDynamicProperty()
 
 void tst_QScriptExtQObject::getSetChildren()
 {
+    QScriptValue mobj = m_engine->evaluate("myObject");
+
     // initially the object does not have the child
     QCOMPARE(m_engine->evaluate("myObject.hasOwnProperty('child')")
              .strictlyEquals(QScriptValue(m_engine, false)), true);
@@ -910,7 +913,6 @@ void tst_QScriptExtQObject::getSetChildren()
     QCOMPARE(m_engine->evaluate("myObject.hasOwnProperty('child')")
              .strictlyEquals(QScriptValue(m_engine, true)), true);
 
-    QScriptValue mobj = m_engine->evaluate("myObject");
     QVERIFY(mobj.propertyFlags("child") & QScriptValue::ReadOnly);
     QVERIFY(mobj.propertyFlags("child") & QScriptValue::Undeletable);
     QVERIFY(mobj.propertyFlags("child") & QScriptValue::SkipInEnumeration);
@@ -1457,12 +1459,12 @@ void tst_QScriptExtQObject::callQtInvokable()
         m_myObject->resetQtFunctionInvoked();
         QScriptValue ret = m_engine->evaluate("new myObject(123)");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: myObject is not a constructor"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: Result of expression 'myObject' [MyQObject(name = \"\")] is not a constructor."));
     }
     {
         m_myObject->resetQtFunctionInvoked();
         QScriptValue ret = m_engine->evaluate("myObject(123)");
-        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: myObject is not a function"));
+        QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: Result of expression 'myObject' [MyQObject(name = \"\")] is not a function."));
     }
 
     // task 233624
@@ -1494,7 +1496,7 @@ void tst_QScriptExtQObject::connectAndDisconnect()
     // connect(function)
     QCOMPARE(m_engine->evaluate("myObject.mySignal.connect(123)").isError(), true);
 
-    m_engine->evaluate("myHandler = function() { global.gotSignal = true; global.signalArgs = arguments; global.slotThisObject = this; global.signalSender = __qt_sender__; }");
+    m_engine->evaluate("myHandler = function() { global.gotSignal = true; global.signalArgs = arguments; global.slotThisObject = this; }");
 
     m_myObject->clearConnectedSignal();
     QVERIFY(m_engine->evaluate("myObject.mySignal.connect(myHandler)").isUndefined());
@@ -1504,7 +1506,6 @@ void tst_QScriptExtQObject::connectAndDisconnect()
     m_engine->evaluate("myObject.mySignal()");
     QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true);
     QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 0.0);
-    QCOMPARE(m_engine->evaluate("signalSender").toQObject(), (QObject *)m_myObject);
     QVERIFY(m_engine->evaluate("slotThisObject").strictlyEquals(m_engine->globalObject()));
 
     m_engine->evaluate("gotSignal = false");
@@ -1527,6 +1528,7 @@ void tst_QScriptExtQObject::connectAndDisconnect()
     QVERIFY(m_engine->evaluate("myObject.mySignal.disconnect(myHandler)").isError());
 
     QVERIFY(m_engine->evaluate("myObject.mySignal2.connect(myHandler)").isUndefined());
+    QVERIFY(m_engine->evaluate("myObject.mySignalWithIntArg.disconnect(myHandler)").isUndefined());
 
     m_engine->evaluate("gotSignal = false");
     m_myObject->emitMySignal2(false);
@@ -1604,6 +1606,7 @@ void tst_QScriptExtQObject::connectAndDisconnect()
     m_myObject->emitMySignalWithVariantArg(123);
     QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true);
     QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 1.0);
+    QVERIFY(m_engine->evaluate("signalArgs[0]").isNumber());
     QCOMPARE(m_engine->evaluate("signalArgs[0]").toNumber(), 123.0);
     QVERIFY(m_engine->evaluate("myObject.mySignalWithVariantArg.disconnect(myHandler)").isUndefined());
 
@@ -1635,7 +1638,6 @@ void tst_QScriptExtQObject::connectAndDisconnect()
     QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true);
     QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 0.0);
     QVERIFY(m_engine->evaluate("slotThisObject").strictlyEquals(m_engine->evaluate("otherObject")));
-    QVERIFY(m_engine->evaluate("signalSender").strictlyEquals(m_engine->evaluate("myObject")));
     QCOMPARE(m_engine->evaluate("slotThisObject").property("name").toString(), QLatin1String("foo"));
     QVERIFY(m_engine->evaluate("myObject.mySignal.disconnect(otherObject, myHandler)").isUndefined());
 
@@ -1646,7 +1648,6 @@ void tst_QScriptExtQObject::connectAndDisconnect()
     QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true);
     QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 1.0);
     QVERIFY(m_engine->evaluate("slotThisObject").strictlyEquals(m_engine->evaluate("yetAnotherObject")));
-    QVERIFY(m_engine->evaluate("signalSender").strictlyEquals(m_engine->evaluate("myObject")));
     QCOMPARE(m_engine->evaluate("slotThisObject").property("name").toString(), QLatin1String("bar"));
     QVERIFY(m_engine->evaluate("myObject.mySignal2.disconnect(yetAnotherObject, myHandler)").isUndefined());
 
@@ -1656,7 +1657,6 @@ void tst_QScriptExtQObject::connectAndDisconnect()
     QCOMPARE(m_engine->evaluate("gotSignal").toBoolean(), true);
     QCOMPARE(m_engine->evaluate("signalArgs.length").toNumber(), 1.0);
     QCOMPARE(m_engine->evaluate("slotThisObject").toQObject(), (QObject *)m_myObject);
-    QVERIFY(m_engine->evaluate("signalSender").strictlyEquals(m_engine->evaluate("myObject")));
     QVERIFY(m_engine->evaluate("myObject.mySignal2.disconnect(myObject, myHandler)").isUndefined());
 
     // connect(obj, string)
@@ -1716,7 +1716,20 @@ void tst_QScriptExtQObject::connectAndDisconnect()
     QCOMPARE(m_myObject->qtFunctionActuals().at(0).toInt(), 456);
     QVERIFY(m_engine->evaluate("myObject.mySignalWithIntArg.disconnect(myObject['myOverloadedSlot(int)'])").isUndefined());
 
-    // erroneous input
+    // when the wrapper dies, the connection stays alive
+    QVERIFY(m_engine->evaluate("myObject.mySignal.connect(myObject.mySlot)").isUndefined());
+    m_myObject->resetQtFunctionInvoked();
+    m_myObject->emitMySignal();
+    QCOMPARE(m_myObject->qtFunctionInvoked(), 20);
+    m_engine->evaluate("myObject = null");
+    m_engine->collectGarbage();
+    m_myObject->resetQtFunctionInvoked();
+    m_myObject->emitMySignal();
+    QCOMPARE(m_myObject->qtFunctionInvoked(), 20);
+}
+
+void tst_QScriptExtQObject::connectAndDisconnectWithBadArgs()
+{
     {
         QScriptValue ret = m_engine->evaluate("(function() { }).connect()");
         QVERIFY(ret.isError());
@@ -1800,17 +1813,6 @@ void tst_QScriptExtQObject::connectAndDisconnect()
         QVERIFY(ret.isError());
         QCOMPARE(ret.toString(), QLatin1String("Error: Function.prototype.disconnect: failed to disconnect from MyQObject::mySignal()"));
     }
-
-    // when the wrapper dies, the connection stays alive
-    QVERIFY(m_engine->evaluate("myObject.mySignal.connect(myObject.mySlot)").isUndefined());
-    m_myObject->resetQtFunctionInvoked();
-    m_myObject->emitMySignal();
-    QCOMPARE(m_myObject->qtFunctionInvoked(), 20);
-    m_engine->evaluate("myObject = null");
-    m_engine->collectGarbage();
-    m_myObject->resetQtFunctionInvoked();
-    m_myObject->emitMySignal();
-    QCOMPARE(m_myObject->qtFunctionInvoked(), 20);
 }
 
 void tst_QScriptExtQObject::cppConnectAndDisconnect()
@@ -1886,7 +1888,8 @@ void tst_QScriptExtQObject::cppConnectAndDisconnect()
     // make sure we don't crash when engine is deleted
     {
         QScriptEngine *eng2 = new QScriptEngine;
-        QScriptValue fun2 = eng2->evaluate("function(text) { signalObject = this; signalArg = text; }");
+        QScriptValue fun2 = eng2->evaluate("(function(text) { signalObject = this; signalArg = text; })");
+        QVERIFY(fun2.isFunction());
         QVERIFY(qScriptConnect(&edit, SIGNAL(textChanged(const QString &)), QScriptValue(), fun2));
         delete eng2;
         edit.setText("ciao");
@@ -1909,7 +1912,8 @@ void tst_QScriptExtQObject::cppConnectAndDisconnect()
                 this, SLOT(onSignalHandlerException(QScriptValue)));
 
         eng.globalObject().setProperty("edit", eng.newQObject(&edit));
-        QScriptValue fun = eng.evaluate("function() { nonExistingFunction(); }");
+        QScriptValue fun = eng.evaluate("(function() { nonExistingFunction(); })");
+        QVERIFY(fun.isFunction());
         QVERIFY(qScriptConnect(&edit, SIGNAL(textChanged(const QString &)), QScriptValue(), fun));
 
         m_signalHandlerException = QScriptValue();
@@ -2341,6 +2345,35 @@ void tst_QScriptExtQObject::findChildren()
         QVERIFY(count == 0);
     }
 
+    // matchall regexp
+    {
+        QScriptValue result = m_engine->evaluate("myObject.findChildren(/.*/)");
+        QVERIFY(result.isArray());
+        int count = 3;
+        QCOMPARE(result.property("length").toInt32(), count);
+        for (int i = 0; i < 3; ++i) {
+            QObject *o = result.property(i).toQObject();
+            if (o == namelessChild || o == child || o == anotherChild)
+                --count;
+        }
+        QVERIFY(count == 0);
+    }
+
+    // matchall regexp my*
+    {
+        QScriptValue result = m_engine->evaluate("myObject.findChildren(new RegExp(\"^my.*\"))");
+        QCOMPARE(result.isArray(), true);
+        QCOMPARE(result.property(QLatin1String("length")).toNumber(), 2.0);
+        QObject *o1 = result.property(QLatin1String("0")).toQObject();
+        QObject *o2 = result.property(QLatin1String("1")).toQObject();
+        if (o1 != child) {
+            QCOMPARE(o1, anotherChild);
+            QCOMPARE(o2, child);
+        } else {
+            QCOMPARE(o1, child);
+            QCOMPARE(o2, anotherChild);
+        }
+    }
     delete anotherChild;
     delete namelessChild;
     delete child;
@@ -2809,13 +2842,6 @@ void tst_QScriptExtQObject::objectDeleted()
         QVERIFY(!ret.isValid());
     }
 
-    // myInvokable is stored in member table (since we've accessed it before deletion)
-    QVERIFY(v.property("myInvokable").isFunction());
-    {
-        QScriptValue ret = v.property("myInvokable").call(v);
-        QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QLatin1String("Error: cannot call function of deleted QObject"));
-    }
     // myInvokableWithIntArg is not stored in member table (since we've not accessed it)
     {
         QScriptValue ret = v.property("myInvokableWithIntArg");
@@ -2828,7 +2854,7 @@ void tst_QScriptExtQObject::objectDeleted()
     {
         QScriptValue ret = eng.evaluate("o()");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QLatin1String("TypeError: o is not a function"));
+        QCOMPARE(ret.toString(), QLatin1String("TypeError: Result of expression 'o' [] is not a function."));
     }
     {
         QScriptValue ret = eng.evaluate("o.objectName");
@@ -2838,7 +2864,7 @@ void tst_QScriptExtQObject::objectDeleted()
     {
         QScriptValue ret = eng.evaluate("o.myInvokable()");
         QVERIFY(ret.isError());
-        QCOMPARE(ret.toString(), QLatin1String("Error: cannot call function of deleted QObject"));
+        QCOMPARE(ret.toString(), QLatin1String("Error: cannot access member `myInvokable' of deleted QObject"));
     }
     {
         QScriptValue ret = eng.evaluate("o.myInvokableWithIntArg(10)");
diff --git a/tests/auto/qscriptjstestsuite/tst_qscriptjstestsuite.cpp b/tests/auto/qscriptjstestsuite/tst_qscriptjstestsuite.cpp
index 2843367ddd..f77738f1c0 100644
--- a/tests/auto/qscriptjstestsuite/tst_qscriptjstestsuite.cpp
+++ b/tests/auto/qscriptjstestsuite/tst_qscriptjstestsuite.cpp
@@ -413,8 +413,6 @@ tst_Suite::tst_Suite()
     addExpectedFailure("ecma/String/15.5.4.12-4.js", "var s = new String( String.fromCharCode(1117) ); s.toUpperCase().charCodeAt(0)", fromCharCodeMessage);
     addExpectedFailure("ecma/String/15.5.4.12-5.js", "var s = new String( String.fromCharCode(1415) ); s.toUpperCase().charCodeAt(0)", fromCharCodeMessage);
 
-    addExpectedFailure("ecma/String/15.5.4.6-2.js", "function f() { return this; }; function g() { var h = f; return h(); }; g().toString()", willFixInNextReleaseMessage);
-
     addExpectedFailure("ecma/TypeConversion/9.3.1-3.js", "- \"-0x123456789abcde8\"", willFixInNextReleaseMessage);
 
     addExpectedFailure("ecma/extensions/15.1.2.1-1.js", "var PROPS = ''; for ( p in eval ) { PROPS += p }; PROPS", willFixInNextReleaseMessage);
@@ -428,9 +426,6 @@ tst_Suite::tst_Suite()
     addExpectedFailure("ecma/GlobalObject/15.1.2.6.js", "var MYPROPS=''; for ( var p in isNaN ) { MYPROPS+= p }; MYPROPS", willFixInNextReleaseMessage);
     addExpectedFailure("ecma/GlobalObject/15.1.2.7.js", "var MYPROPS=''; for ( p in isFinite ) { MYPROPS+= p }; MYPROPS", willFixInNextReleaseMessage);
 
-    addExpectedFailure("ecma/Statements/12.6.3-12.js", "var result=''; for ( aVar in this ) { if (aVar == 'aVar') {return a failure}; result", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma/String/15.5.4.6-2.js", "var d = new Date(0); d.indexOf = String.prototype.indexOf; d.getTimezoneOffset()>0 ? d.indexOf('31') : d.indexOf('01')", willFixInNextReleaseMessage);
-
     // qstrtod() has problems parsing reaaaaally big numbers -- they come out as NaN rather than Infinity or Number.MAX_VALUE
     addSkip("ecma/TypeConversion/9.3.1-3.js", "parseInt(s1,10) == 1.7976931348623157e+308 || parseInt(s1,10) == Infinity", brokenOnSomePlatformsMessage);
     addSkip("ecma/TypeConversion/9.3.1-3.js", "parseInt(s2,10) == Infinity || parseInt(s2,10) == 1.7976931348623157e+308", brokenOnSomePlatformsMessage);
@@ -448,11 +443,6 @@ tst_Suite::tst_Suite()
     addExpectedFailure("ecma_2/RegExp/multiline-001.js", "/.*[y]$/m.exec(ivory-billed\ndowny\nhairy\nacorn\nyellow-bellied sapsucker\nnorthern flicker\npileated\n)", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_2/RegExp/multiline-001.js", "/.*[d]$/m.exec(ivory-billed\ndowny\nhairy\nacorn\nyellow-bellied sapsucker\nnorthern flicker\npileated\n)", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_2/String/match-002.js", "//.toString()", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_2/String/match-002.js", "( Boston, Mass. 02134 ).match(/([d]{5})([- ]?[d]{4})?$/)[2]", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_2/String/match-002.js", "( Boston, MA 02134 ).match(re = /([d]{5})([- ]?[d]{4})?$/; re.lastIndex =0)[2]", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_2/String/match-002.js", "( Boston, MA 02134 ).match(re = /([d]{5})([- ]?[d]{4})?$/; re.lastIndex = 16)[2]", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_2/String/match-002.js", "( Boston, MA 02134 ).match(re = /([d]{5})([- ]?[d]{4})?$/; re.lastIndex = 11)[2]", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_2/String/match-002.js", "( Boston, MA 02134 ).match(re = /([d]{5})([- ]?[d]{4})?$/; re.lastIndex = 111)[2]", willFixInNextReleaseMessage);
 
 #if defined(Q_WS_WIN)
     addExpectedFailure(QRegExp(), "VAR1 = 0; VAR2= Infinity; VAR1 %= VAR2;VAR1", willFixInNextReleaseMessage);
@@ -481,16 +471,9 @@ tst_Suite::tst_Suite()
     addExpectedFailure(QRegExp(), "Math.atan2(-Infinity, -Infinity)", willFixInNextReleaseMessage);
 #endif
 
-    addExpectedFailure("ecma_3/Array/15.4.4.11-01.js", "Array.sort should not eat exceptions", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Array/15.4.4.3-1.js", "Testing Array.prototype.toLocaleString() -", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/Array/15.4.5.1-01.js", "15.4.5.1 - array.length coverage", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/ExecutionContexts/10.1.4-1.js", "Expected to be able to delete x", willFixInNextReleaseMessage);
 
-    addExpectedFailure("ecma_3/extensions/regress-220367-002.js", "Section 1 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/extensions/regress-220367-002.js", "Section 2 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/extensions/regress-220367-002.js", "Section 3 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/extensions/regress-220367-002.js", "Section 4 of test - ", willFixInNextReleaseMessage);
-
     addExpectedFailure("ecma_3/extensions/regress-228087-002.js",
                        "Section 1 of test - \nregexp = /{1.*}/g\n"
                        "string = 'foo {1} foo {2} foo'\n"
@@ -555,30 +538,12 @@ tst_Suite::tst_Suite()
     addExpectedFailure("ecma_3/extensions/regress-274152.js", "Do not ignore unicode format-control characters: 8", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/extensions/regress-368516.js", "Treat unicode BOM characters as whitespace: 0", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/extensions/regress-368516.js", "Treat unicode BOM characters as whitespace: 1", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Function/arguments-001.js", "Section 3 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Function/regress-131964.js", "Section 3 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Function/regress-131964.js", "Section 4 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Function/regress-137181.js", "Section 2 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Function/regress-85880.js", "Section A of test", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Function/regress-85880.js", "Section B of test", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Function/regress-85880.js", "Section C of test", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Function/regress-85880.js", "Section D of test", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Function/regress-85880.js", "Section E of test", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Function/regress-85880.js", "Section F of test", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Function/regress-85880.js", "Section G of test", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Function/regress-85880.js", "Section H of test", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Function/regress-94506.js", "Section 3 of test", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/FunExpr/fe-001-n.js", "Previous statement should have thrown a ReferenceError", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/FunExpr/fe-002.js", "Inner function statement should not have been called.", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/LexicalConventions/7.9.1.js", "Automatic Semicolon insertion in postfix expressions: expr\n++", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/LexicalConventions/7.9.1.js", "Automatic Semicolon insertion in postfix expressions: expr\n--", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/LexicalConventions/7.9.1.js", "Automatic Semicolon insertion in postfix expressions: (x\n)-- y", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/LexicalConventions/7.9.1.js", "Automatic Semicolon insertion in postfix expressions: (x)-- y", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Number/15.7.4.2-01.js", "3.3.toString.length should be 1", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Number/15.7.4.6-1.js", "Section A of test: no error intended!", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Number/15.7.4.7-2.js", "num.toPrecision(undefined) should equal num.toString()", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/Object/8.6.1-01.js", "In strict mode, setting a read-only property should generate a warning: Throw if STRICT and WERROR is enabled", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Object/8.6.2.6-001.js", "Section 1 of test - ", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/Operators/order-01.js", "operator evaluation order: 11.8.2 >", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/Operators/order-01.js", "operator evaluation order: 11.8.4 >=", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/15.10.2-1.js", "Section 5 of test - \nregexp = /(aa|aabaac|ba|b|c)*/\nstring = 'aabaac'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"aaba\", \"ba\"]\nActual: [\"aabaac\", \"aabaac\"]\n", willFixInNextReleaseMessage);
@@ -589,7 +554,6 @@ tst_Suite::tst_Suite()
     addExpectedFailure("ecma_3/RegExp/15.10.2-1.js", "Section 11 of test - \nregexp = /(?=(a+))a*b\\1/\nstring = 'baaabac'\nERROR !!! match arrays have different lengths:\nExpect: [\"aba\", \"a\"]\nActual: [\"aaab\"]\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/15.10.2-1.js", "Section 12 of test - \nregexp = /(.*?)a(?!(a+)b\\2c)\\2(.*)/\nstring = 'baaabaac'\nERROR !!! regexp FAILED to match anything !!!\nExpect: baaabaac,ba,,abaac\nActual: null\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/15.10.2-1.js", "Section 13 of test - \nregexp = /(?=(a+))/\nstring = 'baaabac'\nERROR !!! match arrays have different lengths:\nExpect: [\"\", \"aaa\"]\nActual: [\"\"]\n", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/15.10.2.12.js", "15.10.2.12 - CharacterClassEscape d", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/perlstress-001.js", "Section 34 of test - \nregexp = /a]/\nstring = 'a]'\nERROR !!! regexp FAILED to match anything !!!\nExpect: a]\nActual: null\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/perlstress-001.js", "Section 66 of test - \nregexp = /a.+?c/\nstring = 'abcabc'\nERROR !!! regexp FAILED to match anything !!!\nExpect: abc\nActual: null\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/perlstress-001.js", "Section 94 of test - \nregexp = /^a(bc+|b[eh])g|.h$/\nstring = 'abh'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"bh\", , ]\nActual: [\"bh\", \"\"]\n", willFixInNextReleaseMessage);
@@ -666,25 +630,6 @@ tst_Suite::tst_Suite()
     addExpectedFailure("ecma_3/RegExp/regress-165353.js", "Section 1 of test - \nregexp = /^([a-z]+)*[a-z]$/\nstring = 'a'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"a\", , ]\nActual: [\"a\", \"\"]\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-169497.js", "Section 1 of test - \nregexp = /<body.*>((.*\\n?)*?)<\\/body>/i\nstring = '<html>\\n<body onXXX=\"alert(event.type);\">\\n<p>Kibology for all</p>\\n<p>All for Kibology</p>\\n</body>\\n</html>'\nERROR !!! regexp FAILED to match anything !!!\nExpect: <body onXXX=\"alert(event.type);\">\n<p>Kibology for all</p>\n<p>All for Kibology</p>\n</body>,\n<p>Kibology for all</p>\n<p>All for Kibology</p>\n,<p>All for Kibology</p>\n\nActual: null\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-187133.js", "Section 5 of test - \nregexp = /(?!a|b)|c/\nstring = 'bc'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"\"]\nActual: [\"c\"]\n", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 1 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 2 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 3 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 4 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 5 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 6 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 9 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 10 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 11 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 12 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 28 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 29 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 30 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 31 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 32 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 33 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 34 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 35 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-188206.js", "Section 36 of test - ", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-191479.js", "Section 1 of test - \nregexp = /(\\d|\\d\\s){2,}/\nstring = '12 3 45'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"12\", \"2\"]\nActual: [\"12 3 45\", \"5\"]\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-191479.js", "Section 3 of test - \nregexp = /(\\d|\\d\\s)+/\nstring = '12 3 45'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"12\", \"2\"]\nActual: [\"12 3 45\", \"5\"]\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-191479.js", "Section 8 of test - \nregexp = /(\\d|\\d\\s){2,}?/\nstring = '12 3 45'\nERROR !!! regexp FAILED to match anything !!!\nExpect: 12,2\nActual: null\n", willFixInNextReleaseMessage);
@@ -702,12 +647,6 @@ tst_Suite::tst_Suite()
     addExpectedFailure("ecma_3/RegExp/regress-216591.js", "Section 2 of test - \nregexp = /\\{(([a-z0-9\\-_]+?\\.)+?)([a-z0-9\\-_]+?)\\}/gi\nstring = 'a {result.data.DATA} b'\nERROR !!! match arrays have different lengths:\nExpect: [\"{result.data.DATA}\"]\nActual: []\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-220367-001.js", "Section 1 of test - \nregexp = /(a)|(b)/\nstring = 'a'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"a\", \"a\", , ]\nActual: [\"a\", \"a\", \"\"]\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-220367-001.js", "Section 2 of test - \nregexp = /(a)|(b)/\nstring = 'b'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"b\", , \"b\"]\nActual: [\"b\", \"\", \"b\"]\n", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-223273.js", "Section 1 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-223273.js", "Section 2 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-223273.js", "Section 3 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-223273.js", "Section 4 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-223273.js", "Section 11 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-223273.js", "Section 12 of test - ", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-223535.js", "Section 2 of test - \nregexp = /|a/\nstring = 'a'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"\"]\nActual: [\"a\"]\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-223535.js", "Section 6 of test - \nregexp = /(|a)/\nstring = 'a'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"\", \"\"]\nActual: [\"a\", \"a\"]\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-223535.js", "Section 7 of test - \nregexp = /(|a|)/\nstring = 'a'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"\", \"\"]\nActual: [\"a\", \"a\"]\n", willFixInNextReleaseMessage);
@@ -718,7 +657,6 @@ tst_Suite::tst_Suite()
     addExpectedFailure("ecma_3/RegExp/regress-225289.js", "Section 10 of test - \nregexp = /((?:a|[^a])*)/g\nstring = 'a'\nERROR !!! match arrays have different lengths:\nExpect: [\"a\", \"\"]\nActual: [\"a\"]\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-225289.js", "Section 11 of test - \nregexp = /((?:a|[^a])*)/g\nstring = ''\nERROR !!! match arrays have different lengths:\nExpect: [\"\"]\nActual: []\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-225289.js", "Section 12 of test - \nregexp = /((?:a|[^a])*)/g\nstring = '()'\nERROR !!! match arrays have different lengths:\nExpect: [\"()\", \"\"]\nActual: [\"()\"]\n", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/RegExp/regress-309840.js", "Treat / in a literal regexp class as valid", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-31316.js", "Section 1 of test - \nregexp = /<([^\\/<>][^<>]*[^\\/])>|<([^\\/<>])>/\nstring = '<p>Some<br />test</p>'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"<p>\", , \"p\"]\nActual: [\"<p>\", \"\", \"p\"]\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-330684.js", "Do not hang on RegExp", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-375711.js", "Do not assert with /[Q-b]/i.exec(\"\"): /[q-b]/.exec(\"\")", willFixInNextReleaseMessage);
@@ -742,42 +680,10 @@ tst_Suite::tst_Suite()
     addExpectedFailure("ecma_3/RegExp/regress-85721.js", "Section 2 of test - \nregexp = /<sql:connection id=\"([^\\r\\n]*?)\">\\s*<sql:url>\\s*([^\\r\\n]*?)\\s*<\\/sql:url>\\s*<sql:driver>\\s*([^\\r\\n]*?)\\s*<\\/sql:driver>\\s*(\\s*<sql:userId>\\s*([^\\r\\n]*?)\\s*<\\/sql:userId>\\s*)?\\s*(\\s*<sql:password>\\s*([^\\r\\n]*?)\\s*<\\/sql:password>\\s*)?\\s*<\\/sql:connection>/\nstring = '<sql:connection id=\"conn1\"> <sql:url>www.m.com</sql:url> <sql:driver>drive.class</sql:driver>\\n<sql:userId>foo</sql:userId> <sql:password>goo</sql:password> </sql:connection>'\nERROR !!! regexp FAILED to match anything !!!\nExpect: <sql:connection id=\"conn1\"> <sql:url>www.m.com</sql:url> <sql:driver>drive.class</sql:driver>\n<sql:userId>foo</sql:userId> <sql:password>goo</sql:password> </sql:connection>,conn1,www.m.com,drive.class,<sql:userId>foo</sql:userId> ,foo,<sql:password>goo</sql:password> ,goo\nActual: null\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-87231.js", "Section 3 of test - \nregexp = /^(A)?(A.*)$/\nstring = 'A'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"A\", , \"A\"]\nActual: [\"A\", \"\", \"A\"]\n", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/RegExp/regress-87231.js", "Section 6 of test - \nregexp = /(A)?(A.*)/\nstring = 'zxcasd;fl\\  ^AaaAAaaaf;lrlrzs'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"AaaAAaaaf;lrlrzs\", , \"AaaAAaaaf;lrlrzs\"]\nActual: [\"AaaAAaaaf;lrlrzs\", \"\", \"AaaAAaaaf;lrlrzs\"]\n", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/Statements/regress-226517.js", "Section 1 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 14", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 20", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 24", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 27", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 28", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 29", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 30", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 31", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 32", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 33", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 34", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 35", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 36", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 37", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 39", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 56", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 58", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 59", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 60", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 62", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 64", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 65", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 66", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 67", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 68", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 69", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/String/15.5.4.14.js", "15.5.4.14 - String.prototype.split(/()/)", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/regress-104375.js", "Section 1 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/regress-104375.js", "Section 2 of test - ", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/regress-304376.js", "String.prototype should be readonly and permanent", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/regress-392378.js", "Regular Expression Non-participating Capture Groups are inaccurate in edge cases: \"y\".split(/(x)?
y/)", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/regress-392378.js", "Regular Expression Non-participating Capture Groups are inaccurate in edge cases: \"y\".split(/(x)?y/)", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/regress-392378.js", "Regular Expression Non-participating Capture Groups are inaccurate in edge cases: \"y\".replace(/(x)?\\1y/, function($0, $1){ return String($1); })", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/regress-392378.js", "Regular Expression Non-participating Capture Groups are inaccurate in edge cases: \"y\".replace(/(x)?y/, function($0, $1){ return String($1); })", willFixInNextReleaseMessage);
-    addExpectedFailure("ecma_3/String/regress-392378.js", "Regular Expression Non-participating Capture Groups are inaccurate in edge cases: \"y\".replace(/(x)?y/, function($0, $1){ return $1; })", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/Unicode/regress-352044-01.js", "issues with Unicode escape sequences in JavaScript source code", willFixInNextReleaseMessage);
     addExpectedFailure("ecma_3/Unicode/uc-001.js", "Unicode format-control character test (Category Cf.)", willFixInNextReleaseMessage);
 
@@ -789,6 +695,38 @@ tst_Suite::tst_Suite()
     addFileExclusion("regress-322135-04.js", "takes forever");
     addFileExclusion("ecma_3/RegExp/regress-375715-04.js", "bug");
 
+    // Failures due to switch to JSC as back-end
+    addExpectedFailure("ecma/Array/15.4.3.1-2.js", "var props = ''; for ( p in Array  ) { props += p } props", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma/Boolean/15.6.3.1-1.js", "var str='';for ( p in Boolean ) { str += p } str;", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma/Expressions/11.4.1.js", "var abc; delete(abc)", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma/FunctionObjects/15.3.3.1-2.js", "var str='';for (prop in Function ) str += prop; str;", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma/ObjectObjects/15.2.3.1-1.js", "var str = '';for ( p in Object ) { str += p; }; str", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma/Statements/12.6.3-11.js", "result = \"\"; for ( p in Number ) { result += String(p) };", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma/Statements/12.6.3-2.js", "Boolean.prototype.foo = 34; for ( j in Boolean ) Boolean[j]", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma/TypeConversion/9.3.1-3.js", "-\"\\u20001234\\u2001\"", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_2/RegExp/properties-001.js", "//.toString()", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/Date/15.9.4.3.js", "15.9.4.3 - Date.UTC edge-case arguments.: date Infinity", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/Date/15.9.4.3.js", "15.9.4.3 - Date.UTC edge-case arguments.: hours Infinity", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/Date/15.9.4.3.js", "15.9.4.3 - Date.UTC edge-case arguments.: minutes Infinity", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/Date/15.9.4.3.js", "15.9.4.3 - Date.UTC edge-case arguments.: seconds Infinity", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/Function/regress-131964.js", "Section 1 of test - ", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/Function/regress-313570.js", "length of objects whose prototype chain includes a function: immutable", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/FunExpr/fe-001.js", "Both functions were defined.", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/RegExp/15.10.2-1.js", "Section 7 of test - \nregexp = /(z)((a+)?(b+)?(c))*/\nstring = 'zaacbbbcac'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"zaacbbbcac\", \"z\", \"ac\", \"a\", , \"c\"]\nActual: [\"zaacbbbcac\", \"z\", \"ac\", \"a\", \"bbb\", \"c\"]\n", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/RegExp/15.10.2-1.js", "Section 12 of test - \nregexp = /(.*?)a(?!(a+)b\\2c)\\2(.*)/\nstring = 'baaabaac'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"baaabaac\", \"ba\", , \"abaac\"]\nActual: [\"baaabaac\", \"ba\", \"aa\", \"abaac\"]\n", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/RegExp/perlstress-001.js", "Section 218 of test - \nregexp = /((foo)|(bar))*/\nstring = 'foobar'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"foobar\", \"bar\", , \"bar\"]\nActual: [\"foobar\", \"bar\", \"foo\", \"bar\"]\n", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/RegExp/perlstress-001.js", "Section 234 of test - \nregexp = /(?:(f)(o)(o)|(b)(a)(r))*/\nstring = 'foobar'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"foobar\", , , , \"b\", \"a\", \"r\"]\nActual: [\"foobar\", \"f\", \"o\", \"o\", \"b\", \"a\", \"r\"]\n", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/RegExp/perlstress-001.js", "Section 241 of test - \nregexp = /^(?:b|a(?=(.)))*\\1/\nstring = 'abc'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"ab\", , ]\nActual: [\"ab\", \"b\"]\n", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/RegExp/perlstress-001.js", "Section 412 of test - \nregexp = /^(a(b)?)+$/\nstring = 'aba'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"aba\", \"a\", , ]\nActual: [\"aba\", \"a\", \"b\"]\n", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/RegExp/perlstress-001.js", "Section 413 of test - \nregexp = /^(aa(bb)?)+$/\nstring = 'aabbaa'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"aabbaa\", \"aa\", , ]\nActual: [\"aabbaa\", \"aa\", \"bb\"]\n", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/RegExp/regress-209919.js", "Section 1 of test - \nregexp = /(a|b*)*/\nstring = 'a'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"a\", \"a\"]\nActual: [\"a\", \"\"]\n", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/RegExp/regress-209919.js", "Section 5 of test - \nregexp = /^\\-?(\\d{1,}|\\.{0,})*(\\,\\d{1,})?$/\nstring = '100.00'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"100.00\", \"00\", , ]\nActual: [\"100.00\", \"\", , ]\n", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/RegExp/regress-209919.js", "Section 6 of test - \nregexp = /^\\-?(\\d{1,}|\\.{0,})*(\\,\\d{1,})?$/\nstring = '100,00'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"100,00\", \"100\", \",00\"]\nActual: [\"100,00\", \"\", \",00\"]\n", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/RegExp/regress-209919.js", "Section 7 of test - \nregexp = /^\\-?(\\d{1,}|\\.{0,})*(\\,\\d{1,})?$/\nstring = '1.000,00'\nERROR !!! regexp failed to give expected match array:\nExpect: [\"1.000,00\", \"000\", \",00\"]\nActual: [\"1.000,00\", \"\", \",00\"]\n", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/RegExp/regress-311414.js", "RegExp captured tail match should be O(N) BigO 2 < 2", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 7", willFixInNextReleaseMessage);
+    addExpectedFailure("ecma_3/String/15.5.4.11.js", "Section 26", willFixInNextReleaseMessage);
+
     static const char klass[] = "tst_QScriptJsTestSuite";
 
     QVector<uint> *data = qt_meta_data_tst_Suite();
diff --git a/tests/auto/qscriptv8testsuite/tst_qscriptv8testsuite.cpp b/tests/auto/qscriptv8testsuite/tst_qscriptv8testsuite.cpp
index a065d1be31..68db92a5af 100644
--- a/tests/auto/qscriptv8testsuite/tst_qscriptv8testsuite.cpp
+++ b/tests/auto/qscriptv8testsuite/tst_qscriptv8testsuite.cpp
@@ -52,6 +52,15 @@
 //TESTED_CLASS=
 //TESTED_FILES=
 
+// Uncomment the following define to have the autotest generate
+// addExpectedFailure() code for all the tests that fail.
+// This is useful when a whole new test (sub)suite is added.
+// The code is stored in addexpectedfailures.cpp.
+// Paste the contents into this file after the existing
+// addExpectedFailure() calls.
+
+//#define GENERATE_ADDEXPECTEDFAILURE_CODE
+
 static QString readFile(const QString &filename)
 {
     QFile file(filename);
@@ -110,6 +119,9 @@ private:
     QList<ExpectedFailure> expectedFailures;
     QList<QPair<QRegExp, QString> > testExclusions;
     QString mjsunitContents;
+#ifdef GENERATE_ADDEXPECTEDFAILURE_CODE
+    QString generatedAddExpectedFailureCode;
+#endif
 };
 
 QMetaObject tst_Suite::staticMetaObject;
@@ -179,6 +191,14 @@ int tst_Suite::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
                                                QTest::Continue, path.toLatin1(),
                                                lineNumber);
                         }
+#ifdef GENERATE_ADDEXPECTEDFAILURE_CODE
+                        else {
+                            generatedAddExpectedFailureCode.append(
+                                "    addExpectedFailure(\"" + name
+                                + "\", \"" + actual + "\", \"" + expected
+                                + "\", willFixInNextReleaseMessage);\n");
+                        }
+#endif
                         QTest::qCompare(actual, expected, "actual", "expect",
                                         path.toLatin1(), lineNumber);
                     } else {
@@ -211,44 +231,18 @@ tst_Suite::tst_Suite()
         }
     }
     QString willFixInNextReleaseMessage = QString::fromLatin1("Will fix in next release");
-    addExpectedFailure("apply", "morundefineder", "morseper", willFixInNextReleaseMessage);
     addExpectedFailure("arguments-enum", "2", "0", willFixInNextReleaseMessage);
-    addExpectedFailure("array-concat", "undefined", "baz", willFixInNextReleaseMessage);
-    addExpectedFailure("array-functions-prototype", "undefined", "one", willFixInNextReleaseMessage);
     addExpectedFailure("const-redecl", "undefined", "TypeError", willFixInNextReleaseMessage);
-    addExpectedFailure("const", "2", "1", willFixInNextReleaseMessage);
-    addExpectedFailure("declare-locally", "undefined", "42", willFixInNextReleaseMessage);
-    addExpectedFailure("delay-syntax-error", "false", "true", willFixInNextReleaseMessage);
-    addExpectedFailure("delete-vars-from-eval", "false", "true", willFixInNextReleaseMessage);
-    addExpectedFailure("dont-enum-array-holes", "4", "2", willFixInNextReleaseMessage);
-    addExpectedFailure("fun-as-prototype", "undefined", "Funky", willFixInNextReleaseMessage);
-    addExpectedFailure("fun_name", "function(){}", "functionanonymous(){}", willFixInNextReleaseMessage);
-    addExpectedFailure("function-caller", "undefined", "function f(match) {\n    g(match);\n}", willFixInNextReleaseMessage);
     addExpectedFailure("global-const-var-conflicts", "false", "true", willFixInNextReleaseMessage);
-    addExpectedFailure("length", "3", "1", willFixInNextReleaseMessage);
-    addExpectedFailure("math-min-max", "-Infinity", "Infinity", willFixInNextReleaseMessage);
-    addExpectedFailure("newline-in-string", "asdf\n\nasdf\n?asdf\n\tasdf\n\\\n\n", "asdf\nasdf?asdf\tasdf\\", willFixInNextReleaseMessage);
-    addExpectedFailure("number-tostring", "1111111111111111081984.00000000", "1.1111111111111111e+21", willFixInNextReleaseMessage);
-    addExpectedFailure("parse-int-float", "false", "true", willFixInNextReleaseMessage);
-    addExpectedFailure("regexp-multiline-stack-trace", "false", "true", willFixInNextReleaseMessage);
-    addExpectedFailure("regexp-multiline", "false", "true", willFixInNextReleaseMessage);
-    addExpectedFailure("regexp-standalones", "0", "2", willFixInNextReleaseMessage);
-    addExpectedFailure("regexp-static", "undefined", "abc123.456def", willFixInNextReleaseMessage);
-    addExpectedFailure("sparse-array-reverse", "nopcb", "nopdcba", willFixInNextReleaseMessage);
-    addExpectedFailure("str-to-num", "false", "true", willFixInNextReleaseMessage);
     addExpectedFailure("string-lastindexof", "0", "-1", "test is wrong?");
-    addExpectedFailure("string-split", "5", "13", "regular expression semantics");
-//    addExpectedFailure("substr", "", "abcdefghijklmn", willFixInNextReleaseMessage);
-    addExpectedFailure("to-precision", "1.2345e+27", "1.23450e+27", willFixInNextReleaseMessage);
-    addExpectedFailure("try", "3", "4", "task 209990");
-    addExpectedFailure("try_catch_scopes", "0", "1", "task 227055");
-    addExpectedFailure("unusual-constructor", "false", "true", "no idea");
-    addExpectedFailure("unicode-test", "13792", "13793", "test is wrong?");
-    addExpectedFailure("with-leave", "false", "true", "task 233769");
 
     addTestExclusion("debug-*", "not applicable");
     addTestExclusion("mirror-*", "not applicable");
 
+    addTestExclusion("array-concat", "Hangs on JSC backend");
+    addTestExclusion("array-splice", "Hangs on JSC backend");
+    addTestExclusion("sparse-array-reverse", "Hangs on JSC backend");
+
     addTestExclusion("string-case", "V8-specific behavior? (Doesn't pass on SpiderMonkey either)");
 
 #ifdef Q_OS_WINCE
@@ -262,6 +256,20 @@ tst_Suite::tst_Suite()
     addTestExclusion("nested-repetition-count-overflow", "Demands too much memory on Symbian");
     addTestExclusion("unicode-test", "Demands too much memory on Symbian");
 #endif
+    // Failures due to switch to JSC as back-end
+    addExpectedFailure("date-parse", "NaN", "946713600000", willFixInNextReleaseMessage);
+    addExpectedFailure("delete-global-properties", "true", "false", willFixInNextReleaseMessage);
+    addExpectedFailure("delete", "false", "true", willFixInNextReleaseMessage);
+    addExpectedFailure("function-arguments-null", "false", "true", willFixInNextReleaseMessage);
+    addExpectedFailure("function-caller", "null", "function eval() {\n    [native code]\n}", willFixInNextReleaseMessage);
+    addExpectedFailure("function-prototype", "prototype", "disconnectconnect", willFixInNextReleaseMessage);
+    addExpectedFailure("number-tostring", "0", "0.0000a7c5ac471b4788", willFixInNextReleaseMessage);
+    addExpectedFailure("parse-int-float", "1e+21", "1", willFixInNextReleaseMessage);
+    addExpectedFailure("regexp", "false", "true", willFixInNextReleaseMessage);
+    addExpectedFailure("smi-negative-zero", "-Infinity", "Infinity", willFixInNextReleaseMessage);
+    addExpectedFailure("string-split", "4", "3", willFixInNextReleaseMessage);
+    addExpectedFailure("substr", "abcdefghijklmn", "", willFixInNextReleaseMessage);
+
     static const char klass[] = "tst_QScriptV8TestSuite";
 
     QVector<uint> *data = qt_meta_data_tst_Suite();
@@ -304,6 +312,14 @@ tst_Suite::tst_Suite()
 
 tst_Suite::~tst_Suite()
 {
+#ifdef GENERATE_ADDEXPECTEDFAILURE_CODE
+    if (!generatedAddExpectedFailureCode.isEmpty()) {
+        QFile file("addexpectedfailures.cpp");
+        file.open(QFile::WriteOnly);
+        QTextStream ts(&file);
+        ts << generatedAddExpectedFailureCode;
+    }
+#endif
 }
 
 void tst_Suite::addExpectedFailure(const QString &testName, const QString &actual,
diff --git a/tests/auto/qscriptvalue/tst_qscriptvalue.cpp b/tests/auto/qscriptvalue/tst_qscriptvalue.cpp
index 357435aa70..16a9e8729d 100644
--- a/tests/auto/qscriptvalue/tst_qscriptvalue.cpp
+++ b/tests/auto/qscriptvalue/tst_qscriptvalue.cpp
@@ -315,14 +315,14 @@ void tst_QScriptValue::ctor()
     }
 
     // 0 engine
-    QVERIFY(!QScriptValue(0, QScriptValue::UndefinedValue).isValid());
-    QVERIFY(!QScriptValue(0, QScriptValue::NullValue).isValid());
-    QVERIFY(!QScriptValue(0, false).isValid());
-    QVERIFY(!QScriptValue(0, int(1)).isValid());
-    QVERIFY(!QScriptValue(0, uint(1)).isValid());
-    QVERIFY(!QScriptValue(0, 1.0).isValid());
-    QVERIFY(!QScriptValue(0, "ciao").isValid());
-    QVERIFY(!QScriptValue(0, QString("ciao")).isValid());
+    QVERIFY(QScriptValue(0, QScriptValue::UndefinedValue).isUndefined());
+    QVERIFY(QScriptValue(0, QScriptValue::NullValue).isNull());
+    QVERIFY(QScriptValue(0, false).isBool());
+    QVERIFY(QScriptValue(0, int(1)).isNumber());
+    QVERIFY(QScriptValue(0, uint(1)).isNumber());
+    QVERIFY(QScriptValue(0, 1.0).isNumber());
+    QVERIFY(QScriptValue(0, "ciao").isString());
+    QVERIFY(QScriptValue(0, QString("ciao")).isString());
 }
 
 void tst_QScriptValue::engine()
@@ -381,8 +381,8 @@ void tst_QScriptValue::toString()
     QCOMPARE(qscriptvalue_cast<QString>(object), QString("[object Object]"));
 
     QScriptValue fun = eng.newFunction(myFunction);
-    QCOMPARE(fun.toString(), QString("function () { [native] }"));
-    QCOMPARE(qscriptvalue_cast<QString>(fun), QString("function () { [native] }"));
+    QCOMPARE(fun.toString(), QString("function () {\n    [native code]\n}"));
+    QCOMPARE(qscriptvalue_cast<QString>(fun), QString("function () {\n    [native code]\n}"));
 
     // toString() that throws exception
     {
@@ -435,6 +435,18 @@ void tst_QScriptValue::toString()
         QCOMPARE(str.toString(), QString("ciao"));
         QCOMPARE(qscriptvalue_cast<QString>(str), QString("ciao"));
     }
+
+    // variant should use internal valueOf(), then fall back to QVariant::toString(),
+    // then fall back to "QVariant(typename)"
+    QScriptValue 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)"));
 }
 
 void tst_QScriptValue::toNumber()
@@ -1273,7 +1285,7 @@ void tst_QScriptValue::toVariant()
     }
 
     {
-        QRegExp rx = QRegExp("[0-9a-z]+");
+        QRegExp rx = QRegExp("[0-9a-z]+", Qt::CaseSensitive, QRegExp::RegExp2);
         QScriptValue rxObject = eng.newRegExp(rx);
         QVariant var = rxObject.toVariant();
         QCOMPARE(var, QVariant(rx));
@@ -1825,30 +1837,40 @@ void tst_QScriptValue::getSetProperty()
             // getter() returns this.x
             object4.setProperty("foo", eng.newFunction(getter),
                                 QScriptValue::PropertyGetter | QScriptValue::UserRange);
+            QCOMPARE(object4.propertyFlags("foo") & ~QScriptValue::UserRange,
+                        QScriptValue::PropertyGetter );
+
+            QEXPECT_FAIL("", "User-range flags are not retained for getter/setter properties", Continue);
             QCOMPARE(object4.propertyFlags("foo"),
                      QScriptValue::PropertyGetter | QScriptValue::UserRange);
             object4.setProperty("x", num);
             QCOMPARE(object4.property("foo").strictlyEquals(num), true);
-            
+
             // setter() sets this.x
             object4.setProperty("foo", eng.newFunction(setter),
-                                QScriptValue::PropertySetter | QScriptValue::UserRange);
+                                QScriptValue::PropertySetter);
+            QCOMPARE(object4.propertyFlags("foo") & ~QScriptValue::UserRange,
+                                QScriptValue::PropertySetter | QScriptValue::PropertyGetter);
+
             QCOMPARE(object4.propertyFlags("foo"),
-                     QScriptValue::PropertySetter | QScriptValue::UserRange);
+                     QScriptValue::PropertySetter | QScriptValue::PropertyGetter);
             object4.setProperty("foo", str);
             QCOMPARE(object4.property("x").strictlyEquals(str), true);
             QCOMPARE(object4.property("foo").strictlyEquals(str), true);
-            
+
             // kill the getter
             object4.setProperty("foo", QScriptValue(), QScriptValue::PropertyGetter);
-            QCOMPARE(object4.property("foo").isValid(), false);
-            
+            QVERIFY(!(object4.propertyFlags("foo") & QScriptValue::PropertyGetter));
+            QVERIFY(object4.propertyFlags("foo") & QScriptValue::PropertySetter);
+            QCOMPARE(object4.property("foo").isUndefined(), true);
+
             // setter should still work
             object4.setProperty("foo", num);
             QCOMPARE(object4.property("x").strictlyEquals(num), true);
-            
+
             // kill the setter too
             object4.setProperty("foo", QScriptValue(), QScriptValue::PropertySetter);
+            QVERIFY(!(object4.propertyFlags("foo") & QScriptValue::PropertySetter));
             // now foo is just a regular property
             object4.setProperty("foo", str);
             QCOMPARE(object4.property("x").strictlyEquals(num), true);
@@ -1861,21 +1883,21 @@ void tst_QScriptValue::getSetProperty()
             object4.setProperty("foo", eng.newFunction(setter), QScriptValue::PropertySetter);
             object4.setProperty("foo", str);
             QCOMPARE(object4.property("x").strictlyEquals(str), true);
-            QCOMPARE(object4.property("foo").isValid(), false);
-            
+            QCOMPARE(object4.property("foo").isUndefined(), true);
+
             // getter() returns this.x
             object4.setProperty("foo", eng.newFunction(getter), QScriptValue::PropertyGetter);
             object4.setProperty("x", num);
             QCOMPARE(object4.property("foo").strictlyEquals(num), true);
-            
+
             // kill the setter
             object4.setProperty("foo", QScriptValue(), QScriptValue::PropertySetter);
             QTest::ignoreMessage(QtWarningMsg, "QScriptValue::setProperty() failed: property 'foo' has a getter but no setter");
             object4.setProperty("foo", str);
-            
+
             // getter should still work
             QCOMPARE(object4.property("foo").strictlyEquals(num), true);
-            
+
             // kill the getter too
             object4.setProperty("foo", QScriptValue(), QScriptValue::PropertyGetter);
             // now foo is just a regular property
@@ -1887,21 +1909,16 @@ void tst_QScriptValue::getSetProperty()
         // use a single function as both getter and setter
         object4.setProperty("foo", QScriptValue());
         object4.setProperty("foo", eng.newFunction(getterSetter),
-                            QScriptValue::PropertyGetter | QScriptValue::PropertySetter
-                            | QScriptValue::UserRange);
+                            QScriptValue::PropertyGetter | QScriptValue::PropertySetter);
         QCOMPARE(object4.propertyFlags("foo"),
-                 QScriptValue::PropertyGetter | QScriptValue::PropertySetter
-                 | QScriptValue::UserRange);
+                 QScriptValue::PropertyGetter | QScriptValue::PropertySetter);
         object4.setProperty("x", num);
         QCOMPARE(object4.property("foo").strictlyEquals(num), true);
 
-        // killing the getter will also kill the setter, since they are the same function
+        // killing the getter will preserve the setter, even though they are the same function
         object4.setProperty("foo", QScriptValue(), QScriptValue::PropertyGetter);
-        QCOMPARE(object4.property("foo").isValid(), false);
-        // now foo is just a regular property
-        object4.setProperty("foo", str);
-        QCOMPARE(object4.property("x").strictlyEquals(num), true);
-        QCOMPARE(object4.property("foo").strictlyEquals(str), true);
+        QVERIFY(object4.propertyFlags("foo") & QScriptValue::PropertySetter);
+        QCOMPARE(object4.property("foo").isUndefined(), true);
 
         // getter/setter that throws an error
         {
@@ -1955,12 +1972,12 @@ void tst_QScriptValue::getSetProperty()
             {
                 QScriptValue ret = eng.evaluate("this.globalGetterSetterProperty()");
                 QVERIFY(ret.isError());
-                QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: globalGetterSetterProperty is not a function"));
+                QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: Result of expression 'this.globalGetterSetterProperty' [123] is not a function."));
             }
             {
                 QScriptValue ret = eng.evaluate("new this.globalGetterSetterProperty()");
                 QVERIFY(ret.isError());
-                QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: globalGetterSetterProperty is not a constructor"));
+                QCOMPARE(ret.toString(), QString::fromLatin1("TypeError: Result of expression 'this.globalGetterSetterProperty' [123] is not a constructor."));
             }
         }
 
@@ -2026,6 +2043,10 @@ void tst_QScriptValue::getSetProperty()
             "} found");
         QCOMPARE(ret.strictlyEquals(QScriptValue(&eng, true)), true);
     }
+    // should still be deletable from C++
+    object.setProperty("undeletableProperty", QScriptValue());
+    QVERIFY(!object.property("undeletableProperty").isValid());
+    QCOMPARE(object.propertyFlags("undeletableProperty"), 0);
 
   // SkipInEnumeration
     object.setProperty("dontEnumProperty", num, QScriptValue::SkipInEnumeration);
@@ -2068,6 +2089,14 @@ void tst_QScriptValue::getSetProperty()
     object.setProperty("flagProperty", str, QScriptValue::UserRange);
     QCOMPARE(object.propertyFlags("flagProperty"), QScriptValue::UserRange);
 
+    // flags of property in the prototype
+    {
+        QScriptValue object2 = eng.newObject();
+        object2.setPrototype(object);
+        QCOMPARE(object2.propertyFlags("flagProperty", QScriptValue::ResolveLocal), 0);
+        QCOMPARE(object2.propertyFlags("flagProperty"), QScriptValue::UserRange);
+    }
+
     // using interned strings
     QScriptString foo = eng.toStringHandle("foo");
 
@@ -2077,17 +2106,6 @@ void tst_QScriptValue::getSetProperty()
     object.setProperty(foo, num);
     QVERIFY(object.property(foo).strictlyEquals(num));
     QVERIFY(object.property("foo").strictlyEquals(num));
-
-    // can't set arguments and length property of function objects
-    {
-        QScriptValue fun = eng.newFunction(getterSetter, /*length=*/2);
-        for (int x = 0; x < 2; ++x) {
-            QVERIFY(fun.property("arguments").isNull());
-            QVERIFY(fun.property("length").strictlyEquals(QScriptValue(&eng, 2)));
-            fun.setProperty("arguments", QScriptValue());
-            fun.setProperty("length", QScriptValue());
-        }
-    }
 }
 
 void tst_QScriptValue::getSetPrototype()
@@ -2127,7 +2145,7 @@ void tst_QScriptValue::getSetPrototype()
         QCOMPARE(eng.hasUncaughtException(), true);
         QVERIFY(ret.strictlyEquals(eng.uncaughtException()));
         QCOMPARE(ret.isError(), true);
-        QCOMPARE(ret.toString(), QLatin1String("Error: cycle in prototype chain"));
+        QCOMPARE(ret.toString(), QLatin1String("Error: cyclic __proto__ value"));
     }
     {
         QScriptValue ret = eng.evaluate("p.__proto__ = { }");
@@ -2235,7 +2253,7 @@ void tst_QScriptValue::call()
     QScriptEngine eng;
 
     {
-        QScriptValue fun = eng.evaluate("function() { return 1; }");
+        QScriptValue fun = eng.evaluate("(function() { return 1; })");
         QVERIFY(fun.isFunction());
         QScriptValue result = fun.call();
         QVERIFY(result.isNumber());
@@ -2261,7 +2279,7 @@ void tst_QScriptValue::call()
 
     // test that correct "this" object is used
     {
-        QScriptValue fun = eng.evaluate("function() { return this; }");
+        QScriptValue fun = eng.evaluate("(function() { return this; })");
         QCOMPARE(fun.isFunction(), true);
 
         {
@@ -2274,7 +2292,7 @@ void tst_QScriptValue::call()
 
     // test that correct arguments are passed
     {
-        QScriptValue fun = eng.evaluate("function() { return arguments[0]; }");
+        QScriptValue fun = eng.evaluate("(function() { return arguments[0]; })");
         QCOMPARE(fun.isFunction(), true);
 
         {
@@ -2298,10 +2316,17 @@ void tst_QScriptValue::call()
             QCOMPARE(result.isNumber(), true);
             QCOMPARE(result.toNumber(), 123.0);
         }
+        {
+            QScriptValue args = eng.newArray();
+            args.setProperty(0, 123);
+            QScriptValue result = fun.call(eng.undefinedValue(), args);
+            QVERIFY(result.isNumber());
+            QCOMPARE(result.toNumber(), 123.0);
+        }
     }
 
     {
-        QScriptValue fun = eng.evaluate("function() { return arguments[1]; }");
+        QScriptValue fun = eng.evaluate("(function() { return arguments[1]; })");
         QCOMPARE(fun.isFunction(), true);
 
         {
@@ -2311,11 +2336,20 @@ void tst_QScriptValue::call()
             QCOMPARE(result.isNumber(), true);
             QCOMPARE(result.toNumber(), 456.0);
         }
+        {
+            QScriptValue args = eng.newArray();
+            args.setProperty(0, 123);
+            args.setProperty(1, 456);
+            QScriptValue result = fun.call(eng.undefinedValue(), args);
+            QVERIFY(result.isNumber());
+            QCOMPARE(result.toNumber(), 456.0);
+        }
     }
 
     {
-        QScriptValue fun = eng.evaluate("function() { throw new Error('foo'); }");
+        QScriptValue fun = eng.evaluate("(function() { throw new Error('foo'); })");
         QCOMPARE(fun.isFunction(), true);
+        QVERIFY(!eng.hasUncaughtException());
 
         {
             QScriptValue result = fun.call();
@@ -2326,11 +2360,13 @@ void tst_QScriptValue::call()
     }
 
     {
+        eng.clearExceptions();
         QScriptValue fun = eng.newFunction(getArg);
         {
             QScriptValueList args;
             args << QScriptValue(&eng, 123.0);
             QScriptValue result = fun.call(eng.undefinedValue(), args);
+            QVERIFY(!eng.hasUncaughtException());
             QCOMPARE(result.isNumber(), true);
             QCOMPARE(result.toNumber(), 123.0);
         }
@@ -2342,6 +2378,13 @@ void tst_QScriptValue::call()
             QCOMPARE(result.isNumber(), true);
             QCOMPARE(result.toNumber(), 123.0);
         }
+        {
+            QScriptValue args = eng.newArray();
+            args.setProperty(0, 123);
+            QScriptValue result = fun.call(eng.undefinedValue(), args);
+            QVERIFY(result.isNumber());
+            QCOMPARE(result.toNumber(), 123.0);
+        }
     }
 
     {
@@ -2350,6 +2393,7 @@ void tst_QScriptValue::call()
             QScriptValueList args;
             args << QScriptValue(&eng, 123.0);
             QScriptValue result = fun.call(eng.undefinedValue(), args);
+            QVERIFY(!eng.hasUncaughtException());
             QCOMPARE(result.isNumber(), true);
             QCOMPARE(result.toNumber(), 123.0);
         }
@@ -2365,6 +2409,7 @@ void tst_QScriptValue::call()
             QScriptValueList args;
             args << QScriptValue();
             QScriptValue ret = fun.call(QScriptValue(), args);
+            QVERIFY(!eng.hasUncaughtException());
             QCOMPARE(ret.isValid(), true);
             QCOMPARE(ret.isUndefined(), true);
         }
@@ -2413,22 +2458,28 @@ void tst_QScriptValue::call()
 
     {
         QScriptEngine otherEngine;
-        QScriptValue fun = otherEngine.evaluate("function() { return 1; }");
+        QScriptValue fun = otherEngine.evaluate("(function() { return 1; })");
+        QVERIFY(fun.isFunction());
         QTest::ignoreMessage(QtWarningMsg, "QScriptValue::call() failed: "
                              "cannot call function with thisObject created in "
                              "a different engine");
         QCOMPARE(fun.call(Object).isValid(), false);
-        QCOMPARE(fun.call(QScriptValue(), QScriptValueList() << QScriptValue(&eng, 123)).isValid(), true);
+        QTest::ignoreMessage(QtWarningMsg, "QScriptValue::call() failed: "
+                             "cannot call function with argument created in "
+                             "a different engine");
+        QCOMPARE(fun.call(QScriptValue(), QScriptValueList() << QScriptValue(&eng, 123)).isValid(), false);
     }
 
     {
-        QScriptValue fun = eng.evaluate("function() { return arguments; }");
+        QScriptValue fun = eng.evaluate("(function() { return arguments; })");
+        QVERIFY(fun.isFunction());
         QScriptValue array = eng.newArray(3);
         array.setProperty(0, QScriptValue(&eng, 123.0));
         array.setProperty(1, QScriptValue(&eng, 456.0));
         array.setProperty(2, QScriptValue(&eng, 789.0));
         // call with single array object as arguments
         QScriptValue ret = fun.call(QScriptValue(), 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);
@@ -2455,16 +2506,54 @@ void tst_QScriptValue::call()
     }
 }
 
+static QScriptValue ctorReturningUndefined(QScriptContext *ctx, QScriptEngine *)
+{
+    ctx->thisObject().setProperty("foo", 123);
+    return QScriptValue(QScriptValue::UndefinedValue);
+}
+
+static QScriptValue ctorReturningNewObject(QScriptContext *, QScriptEngine *eng)
+{
+    QScriptValue result = eng->newObject();
+    result.setProperty("bar", 456);
+    return result;
+}
+
 void tst_QScriptValue::construct()
 {
     QScriptEngine eng;
 
     {
-        QScriptValue fun = eng.evaluate("function () { }");
+        QScriptValue fun = eng.evaluate("(function () { this.foo = 123; })");
         QVERIFY(fun.isFunction());
         QScriptValue ret = fun.construct();
         QVERIFY(ret.isObject());
         QVERIFY(ret.instanceOf(fun));
+        QCOMPARE(ret.property("foo").toInt32(), 123);
+    }
+    // returning a different object overrides the default-constructed one
+    {
+        QScriptValue fun = eng.evaluate("(function () { return { bar: 456 }; })");
+        QVERIFY(fun.isFunction());
+        QScriptValue ret = fun.construct();
+        QVERIFY(ret.isObject());
+        QVERIFY(!ret.instanceOf(fun));
+        QCOMPARE(ret.property("bar").toInt32(), 456);
+    }
+
+    {
+        QScriptValue fun = eng.newFunction(ctorReturningUndefined);
+        QScriptValue ret = fun.construct();
+        QVERIFY(ret.isObject());
+        QVERIFY(ret.instanceOf(fun));
+        QCOMPARE(ret.property("foo").toInt32(), 123);
+    }
+    {
+        QScriptValue fun = eng.newFunction(ctorReturningNewObject);
+        QScriptValue ret = fun.construct();
+        QVERIFY(ret.isObject());
+        QVERIFY(!ret.instanceOf(fun));
+        QCOMPARE(ret.property("bar").toInt32(), 456);
     }
 
     QScriptValue Number = eng.evaluate("Number");
@@ -2479,7 +2568,7 @@ void tst_QScriptValue::construct()
 
     // test that internal prototype is set correctly
     {
-        QScriptValue fun = eng.evaluate("function() { return this.__proto__; }");
+        QScriptValue fun = eng.evaluate("(function() { return this.__proto__; })");
         QCOMPARE(fun.isFunction(), true);
         QCOMPARE(fun.property("prototype").isObject(), true);
         QScriptValue ret = fun.construct();
@@ -2488,14 +2577,14 @@ void tst_QScriptValue::construct()
 
     // test that we return the new object even if a non-object value is returned from the function
     {
-        QScriptValue fun = eng.evaluate("function() { return 123; }");
+        QScriptValue fun = eng.evaluate("(function() { return 123; })");
         QCOMPARE(fun.isFunction(), true);
         QScriptValue ret = fun.construct();
         QCOMPARE(ret.isObject(), true);
     }
 
     {
-        QScriptValue fun = eng.evaluate("function() { throw new Error('foo'); }");
+        QScriptValue fun = eng.evaluate("(function() { throw new Error('foo'); })");
         QCOMPARE(fun.isFunction(), true);
         QScriptValue ret = fun.construct();
         QCOMPARE(ret.isError(), true);
@@ -2507,13 +2596,17 @@ void tst_QScriptValue::construct()
     QCOMPARE(inv.construct().isValid(), false);
 
     {
-        QScriptValue fun = eng.evaluate("function() { return arguments; }");
+        QScriptValue fun = eng.evaluate("(function() { return arguments; })");
+        QVERIFY(fun.isFunction());
         QScriptValue array = eng.newArray(3);
         array.setProperty(0, QScriptValue(&eng, 123.0));
         array.setProperty(1, QScriptValue(&eng, 456.0));
         array.setProperty(2, QScriptValue(&eng, 789.0));
         // construct with single array object as arguments
         QScriptValue 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);
@@ -2728,10 +2821,25 @@ void tst_QScriptValue::equals()
     QScriptValue qobj2 = eng.newQObject(this);
     QVERIFY(qobj1.equals(qobj2)); // compares the QObject pointers
 
+    QScriptValue compareFun = eng.evaluate("(function(a, b) { return a == b; })");
+    QVERIFY(compareFun.isFunction());
+    {
+        QScriptValue ret = compareFun.call(QScriptValue(), QScriptValueList() << qobj1 << qobj2);
+        QVERIFY(ret.isBool());
+        QEXPECT_FAIL("", "In JSC back-end, == on QObject wrappers doesn't work", Continue);
+        QVERIFY(ret.toBool());
+    }
+
     {
         QScriptValue var1 = eng.newVariant(QVariant(false));
         QScriptValue var2 = eng.newVariant(QVariant(false));
         QVERIFY(var1.equals(var2));
+        {
+            QScriptValue ret = compareFun.call(QScriptValue(), QScriptValueList() << var1 << var2);
+            QVERIFY(ret.isBool());
+            QEXPECT_FAIL("", "In JSC back-end, == on QVariant wrappers doesn't work", Continue);
+            QVERIFY(ret.toBool());
+        }
     }
     {
         QScriptValue var1 = eng.newVariant(QVariant(false));
@@ -2951,165 +3059,165 @@ void tst_QScriptValue::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() {\n    this;\n}");
-    QTest::newRow("identifier") << QString("function(a) { a; }") << QString("function(a) {\n    a;\n}");
-    QTest::newRow("null") << QString("function() { null; }") << QString("function() {\n    null;\n}");
-    QTest::newRow("true") << QString("function() { true; }") << QString("function() {\n    true;\n}");
-    QTest::newRow("false") << QString("function() { false; }") << QString("function() {\n    false;\n}");
-    QTest::newRow("string") << QString("function() { 'test'; }") << QString("function() {\n    \"test\";\n}");
-    QTest::newRow("string") << QString("function() { \"test\"; }") << QString("function() {\n    \"test\";\n}");
-    QTest::newRow("number") << QString("function() { 123; }") << QString("function() {\n    123;\n}");
-    QTest::newRow("number") << QString("function() { 123.456; }") << QString("function() {\n    123.456;\n}");
-    QTest::newRow("regexp") << QString("function() { /hello/; }") << QString("function() {\n    /hello/;\n}");
-    QTest::newRow("regexp") << QString("function() { /hello/gim; }") << QString("function() {\n    /hello/gim;\n}");
-    QTest::newRow("array") << QString("function() { []; }") << QString("function() {\n    [];\n}");
-    QTest::newRow("array") << QString("function() { [10]; }") << QString("function() {\n    [10];\n}");
-    QTest::newRow("array") << QString("function() { [10, 20, 30]; }") << QString("function() {\n    [10, 20, 30];\n}");
-    QTest::newRow("array") << QString("function() { [10, 20, , 40]; }") << QString("function() {\n    [10, 20, , 40];\n}");
-    QTest::newRow("array") << QString("function() { [,]; }") << QString("function() {\n    [, ];\n}");
-    QTest::newRow("array") << QString("function() { [, 10]; }") << QString("function() {\n    [, 10];\n}");
-    QTest::newRow("array") << QString("function() { [, 10, ]; }") << QString("function() {\n    [, 10];\n}");
-    QTest::newRow("array") << QString("function() { [, 10, ,]; }") << QString("function() {\n    [, 10, ];\n}");
-    QTest::newRow("array") << QString("function() { [[10], [20]]; }") << QString("function() {\n    [[10], [20]];\n}");
-    QTest::newRow("member") << QString("function() { a.b; }") << QString("function() {\n    a.b;\n}");
-    QTest::newRow("member") << QString("function() { a.b.c; }") << QString("function() {\n    a.b.c;\n}");
-    QTest::newRow("call") << QString("function() { f(); }") << QString("function() {\n    f();\n}");
-    QTest::newRow("call") << QString("function() { f(a); }") << QString("function() {\n    f(a);\n}");
-    QTest::newRow("call") << QString("function() { f(a, b); }") << QString("function() {\n    f(a, b);\n}");
-    QTest::newRow("new") << QString("function() { new C(); }") << QString("function() {\n    new C();\n}");
-    QTest::newRow("new") << QString("function() { new C(a); }") << QString("function() {\n    new C(a);\n}");
-    QTest::newRow("new") << QString("function() { new C(a, b); }") << QString("function() {\n    new C(a, b);\n}");
-    QTest::newRow("++") << QString("function() { a++; }") << QString("function() {\n    a++;\n}");
-    QTest::newRow("++") << QString("function() { ++a; }") << QString("function() {\n    ++a;\n}");
-    QTest::newRow("--") << QString("function() { a--; }") << QString("function() {\n    a--;\n}");
-    QTest::newRow("--") << QString("function() { --a; }") << QString("function() {\n    --a;\n}");
-    QTest::newRow("delete") << QString("function() { delete a; }") << QString("function() {\n    delete a;\n}");
-    QTest::newRow("void") << QString("function() { void a; }") << QString("function() {\n    void a;\n}");
-    QTest::newRow("typeof") << QString("function() { typeof a; }") << QString("function() {\n    typeof a;\n}");
-    QTest::newRow("+") << QString("function() { +a; }") << QString("function() {\n    +a;\n}");
-    QTest::newRow("-") << QString("function() { -a; }") << QString("function() {\n    -a;\n}");
-    QTest::newRow("~") << QString("function() { ~a; }") << QString("function() {\n    ~a;\n}");
-    QTest::newRow("!") << QString("function() { !a; }") << QString("function() {\n    !a;\n}");
-    QTest::newRow("+") << QString("function() { a + b; }") << QString("function() {\n    a + b;\n}");
-    QTest::newRow("&&") << QString("function() { a && b; }") << QString("function() {\n    a && b;\n}");
-    QTest::newRow("&=") << QString("function() { a &= b; }") << QString("function() {\n    a &= b;\n}");
-    QTest::newRow("=") << QString("function() { a = b; }") << QString("function() {\n    a = b;\n}");
-    QTest::newRow("&") << QString("function() { a & b; }") << QString("function() {\n    a & b;\n}");
-    QTest::newRow("|") << QString("function() { a | b; }") << QString("function() {\n    a | b;\n}");
-    QTest::newRow("^") << QString("function() { a ^ b; }") << QString("function() {\n    a ^ b;\n}");
-    QTest::newRow("-=") << QString("function() { a -= b; }") << QString("function() {\n    a -= b;\n}");
-    QTest::newRow("/") << QString("function() { a / b; }") << QString("function() {\n    a / b;\n}");
-    QTest::newRow("/=") << QString("function() { a /= b; }") << QString("function() {\n    a /= b;\n}");
-    QTest::newRow("==") << QString("function() { a == b; }") << QString("function() {\n    a == b;\n}");
-    QTest::newRow(">=") << QString("function() { a >= b; }") << QString("function() {\n    a >= b;\n}");
-    QTest::newRow(">") << QString("function() { a > b; }") << QString("function() {\n    a > b;\n}");
-    QTest::newRow("in") << QString("function() { a in b; }") << QString("function() {\n    a in b;\n}");
-    QTest::newRow("+=") << QString("function() { a += b; }") << QString("function() {\n    a += b;\n}");
-    QTest::newRow("instanceof") << QString("function() { a instanceof b; }") << QString("function() {\n    a instanceof b;\n}");
-    QTest::newRow("<=") << QString("function() { a <= b; }") << QString("function() {\n    a <= b;\n}");
-    QTest::newRow("<<") << QString("function() { a << b; }") << QString("function() {\n    a << b;\n}");
-    QTest::newRow("<<=") << QString("function() { a <<= b; }") << QString("function() {\n    a <<= b;\n}");
-    QTest::newRow("<") << QString("function() { a < b; }") << QString("function() {\n    a < b;\n}");
-    QTest::newRow("%") << QString("function() { a % b; }") << QString("function() {\n    a % b;\n}");
-    QTest::newRow("%=") << QString("function() { a %= b; }") << QString("function() {\n    a %= b;\n}");
-    QTest::newRow("*") << QString("function() { a * b; }") << QString("function() {\n    a * b;\n}");
-    QTest::newRow("*=") << QString("function() { a *= b; }") << QString("function() {\n    a *= b;\n}");
-    QTest::newRow("!=") << QString("function() { a != b; }") << QString("function() {\n    a != b;\n}");
-    QTest::newRow("||") << QString("function() { a || b; }") << QString("function() {\n    a || b;\n}");
-    QTest::newRow("|=") << QString("function() { a |= b; }") << QString("function() {\n    a |= b;\n}");
-    QTest::newRow(">>") << QString("function() { a >> b; }") << QString("function() {\n    a >> b;\n}");
-    QTest::newRow(">>=") << QString("function() { a >>= b; }") << QString("function() {\n    a >>= b;\n}");
-    QTest::newRow("===") << QString("function() { a === b; }") << QString("function() {\n    a === b;\n}");
-    QTest::newRow("!==") << QString("function() { a !== b; }") << QString("function() {\n    a !== b;\n}");
-    QTest::newRow("-") << QString("function() { a - b; }") << QString("function() {\n    a - b;\n}");
-    QTest::newRow(">>>") << QString("function() { a >>> b; }") << QString("function() {\n    a >>> b;\n}");
-    QTest::newRow(">>>=") << QString("function() { a >>>= b; }") << QString("function() {\n    a >>>= b;\n}");
-    QTest::newRow("^=") << QString("function() { a ^= b; }") << QString("function() {\n    a ^= b;\n}");
-    QTest::newRow("? :") << QString("function() { a ? b : c; }") << QString("function() {\n    a ? b : c;\n}");
-    QTest::newRow("a; b; c") << QString("function() { a; b; c; }") << QString("function() {\n    a;\n    b;\n    c;\n}");
-    QTest::newRow("var a;") << QString("function() { var a; }") << QString("function() {\n    var a;\n}");
-    QTest::newRow("var a, b;") << QString("function() { var a, b; }") << QString("function() {\n    var a, b;\n}");
-    QTest::newRow("var a = 10;") << QString("function() { var a = 10; }") << QString("function() {\n    var a = 10;\n}");
-    QTest::newRow("var a, b = 20;") << QString("function() { var a, b = 20; }") << QString("function() {\n    var a, b = 20;\n}");
-    QTest::newRow("var a = 10, b = 20;") << QString("function() { var a = 10, b = 20; }") << QString("function() {\n    var a = 10, b = 20;\n}");
-    QTest::newRow("if") << QString("function() { if (a) b; }") << QString("function() {\n    if (a) {\n        b;\n    }\n}");
-    QTest::newRow("if") << QString("function() { if (a) { b; c; } }") << QString("function() {\n    if (a) {\n        b;\n        c;\n    }\n}");
-    QTest::newRow("if-else") << QString("function() { if (a) b; else c; }") << QString("function() {\n    if (a) {\n        b;\n    } else {\n        c;\n    }\n}");
-    QTest::newRow("if-else") << QString("function() { if (a) { b; c; } else { d; e; } }") << QString("function() {\n    if (a) {\n        b;\n        c;\n    } else {\n        d;\n        e;\n    }\n}");
-    QTest::newRow("do-while") << QString("function() { do { a; } while (b); }") << QString("function() {\n    do {\n        a;\n    } while (b);\n}");
-    QTest::newRow("do-while") << QString("function() { do { a; b; c; } while (d); }") << QString("function() {\n    do {\n        a;\n        b;\n        c;\n    } while (d);\n}");
-    QTest::newRow("while") << QString("function() { while (a) { b; } }") << QString("function() {\n    while (a) {\n        b;\n    }\n}");
-    QTest::newRow("while") << QString("function() { while (a) { b; c; } }") << QString("function() {\n    while (a) {\n        b;\n        c;\n    }\n}");
-    QTest::newRow("for") << QString("function() { for (a; b; c) { } }") << QString("function() {\n    for (a; b; c) {\n        \n    }\n}");
-    QTest::newRow("for") << QString("function() { for (; a; b) { } }") << QString("function() {\n    for (; a; b) {\n        \n    }\n}");
-    QTest::newRow("for") << QString("function() { for (; ; a) { } }") << QString("function() {\n    for (; ; a) {\n        \n    }\n}");
-    QTest::newRow("for") << QString("function() { for (; ; ) { } }") << QString("function() {\n    for (; ; ) {\n        \n    }\n}");
-    QTest::newRow("for") << QString("function() { for (var a; b; c) { } }") << QString("function() {\n    for (var a; b; c) {\n        \n    }\n}");
-    QTest::newRow("for") << QString("function() { for (var a, b, c; d; e) { } }") << QString("function() {\n    for (var a, b, c; d; e) {\n        \n    }\n}");
-    QTest::newRow("continue") << QString("function() { for (; ; ) { continue; } }") << QString("function() {\n    for (; ; ) {\n        continue;\n    }\n}");
-    QTest::newRow("continue") << QString("function() { for (; ; ) { continue label; } }") << QString("function() {\n    for (; ; ) {\n        continue label;\n    }\n}");
-    QTest::newRow("break") << QString("function() { for (; ; ) { break; } }") << QString("function() {\n    for (; ; ) {\n        break;\n    }\n}");
-    QTest::newRow("break") << QString("function() { for (; ; ) { break label; } }") << QString("function() {\n    for (; ; ) {\n        break label;\n    }\n}");
-    QTest::newRow("return") << QString("function() { return; }") << QString("function() {\n    return;\n}");
-    QTest::newRow("return") << QString("function() { return 10; }") << QString("function() {\n    return 10;\n}");
-    QTest::newRow("with") << QString("function() { with (a) { b; } }") << QString("function() {\n    with (a) {\n        b;\n    }\n}");
-    QTest::newRow("with") << QString("function() { with (a) { b; c; } }") << QString("function() {\n    with (a) {\n        b;\n        c;\n    }\n}");
-    QTest::newRow("switch") << QString("function() { switch (a) { } }") << QString("function() {\n    switch (a) {\n        \n    }\n}");
-    QTest::newRow("switch") << QString("function() { switch (a) { case 1: ; } }") << QString("function() {\n    switch (a) {\n        case 1:\n        ;\n    }\n}");
-    QTest::newRow("switch") << QString("function() { switch (a) { case 1: b; break; } }") << QString("function() {\n    switch (a) {\n        case 1:\n        b;\n        break;\n    }\n}");
-    QTest::newRow("switch") << QString("function() { switch (a) { case 1: b; break; case 2: break; } }") << QString("function() {\n    switch (a) {\n        case 1:\n        b;\n        break;\n        case 2:\n        break;\n    }\n}");
-    QTest::newRow("switch") << QString("function() { switch (a) { case 1: case 2: ; } }") << QString("function() {\n    switch (a) {\n        case 1:\n        case 2:\n        ;\n    }\n}");
-    QTest::newRow("switch") << QString("function() { switch (a) { case 1: default: ; } }") << QString("function() {\n    switch (a) {\n        case 1:\n        default:\n        ;\n    }\n}");
-    QTest::newRow("switch") << QString("function() { switch (a) { case 1: default: ; case 3: ; } }") << QString("function() {\n    switch (a) {\n        case 1:\n        default:\n        ;\n        case 3:\n        ;\n    }\n}");
-    QTest::newRow("label") << QString("function() { a: b; }") << QString("function() {\n    a: b;\n}");
-    QTest::newRow("throw") << QString("function() { throw a; }") << QString("function() {\n    throw a;\n}");
-    QTest::newRow("try-catch") << QString("function() { try { a; } catch (e) { b; } }") << QString("function() {\n    try {\n        a;\n    } catch (e) {\n        b;\n    }\n}");
-    QTest::newRow("try-finally") << QString("function() { try { a; } finally { b; } }") << QString("function() {\n    try {\n        a;\n    } finally {\n        b;\n    }\n}");
-    QTest::newRow("try-catch-finally") << QString("function() { try { a; } catch (e) { b; } finally { c; } }") << QString("function() {\n    try {\n        a;\n    } catch (e) {\n        b;\n    } finally {\n        c;\n    }\n}");
-    QTest::newRow("a + b + c + d") << QString("function() { a + b + c + d; }") << QString("function() {\n    a + b + c + d;\n}");
-    QTest::newRow("a + b - c") << QString("function() { a + b - c; }") << QString("function() {\n    a + b - c;\n}");
-    QTest::newRow("a + -b") << QString("function() { a + -b; }") << QString("function() {\n    a + -b;\n}");
-    QTest::newRow("a + ~b") << QString("function() { a + ~b; }") << QString("function() {\n    a + ~b;\n}");
-    QTest::newRow("a + !b") << QString("function() { a + !b; }") << QString("function() {\n    a + !b;\n}");
-    QTest::newRow("a + +b") << QString("function() { a + +b; }") << QString("function() {\n    a + +b;\n}");
-    QTest::newRow("(a + b) - c") << QString("function() { (a + b) - c; }") << QString("function() {\n    a + b - c;\n}");
-    QTest::newRow("(a - b + c") << QString("function() { a - b + c; }") << QString("function() {\n    a - b + c;\n}");
-    QTest::newRow("(a - (b + c)") << QString("function() { a - (b + c); }") << QString("function() {\n    a - (b + c);\n}");
-    QTest::newRow("a + -(b + c)") << QString("function() { a + -(b + c); }") << QString("function() {\n    a + -(b + c);\n}");
-    QTest::newRow("a + ~(b + c)") << QString("function() { a + ~(b + c); }") << QString("function() {\n    a + ~(b + c);\n}");
-    QTest::newRow("a + !(b + c)") << QString("function() { a + !(b + c); }") << QString("function() {\n    a + !(b + c);\n}");
-    QTest::newRow("a + +(b + c)") << QString("function() { a + +(b + c); }") << QString("function() {\n    a + +(b + c);\n}");
-    QTest::newRow("a + b * c") << QString("function() { a + b * c; }") << QString("function() {\n    a + b * c;\n}");
-    QTest::newRow("(a + b) * c") << QString("function() { (a + b) * c; }") << QString("function() {\n    (a + b) * c;\n}");
-    QTest::newRow("(a + b) * (c + d)") << QString("function() { (a + b) * (c + d); }") << QString("function() {\n    (a + b) * (c + d);\n}");
-    QTest::newRow("a + (b * c)") << QString("function() { a + (b * c); }") << QString("function() {\n    a + b * c;\n}");
-    QTest::newRow("a + (b / c)") << QString("function() { a + (b / c); }") << QString("function() {\n    a + b / c;\n}");
-    QTest::newRow("(a / b) * c") << QString("function() { (a / b) * c; }") << QString("function() {\n    a / b * c;\n}");
-    QTest::newRow("a / (b * c)") << QString("function() { a / (b * c); }") << QString("function() {\n    a / (b * c);\n}");
-    QTest::newRow("a / (b % c)") << QString("function() { a / (b % c); }") << QString("function() {\n    a / (b % c);\n}");
-    QTest::newRow("a && b || c") << QString("function() { a && b || c; }") << QString("function() {\n    a && b || c;\n}");
-    QTest::newRow("a && (b || c)") << QString("function() { a && (b || c); }") << QString("function() {\n    a && (b || c);\n}");
-    QTest::newRow("a & b | c") << QString("function() { a & b | c; }") << QString("function() {\n    a & b | c;\n}");
-    QTest::newRow("a & (b | c)") << QString("function() { a & (b | c); }") << QString("function() {\n    a & (b | c);\n}");
-    QTest::newRow("a & b | c ^ d") << QString("function() { a & b | c ^ d; }") << QString("function() {\n    a & b | c ^ d;\n}");
-    QTest::newRow("a & (b | c ^ d)") << QString("function() { a & (b | c ^ d); }") << QString("function() {\n    a & (b | c ^ d);\n}");
-    QTest::newRow("(a & b | c) ^ d") << QString("function() { (a & b | c) ^ d; }") << QString("function() {\n    (a & b | c) ^ d;\n}");
-    QTest::newRow("a << b + c") << QString("function() { a << b + c; }") << QString("function() {\n    a << b + c;\n}");
-    QTest::newRow("(a << b) + c") << QString("function() { (a << b) + c; }") << QString("function() {\n    (a << b) + c;\n}");
-    QTest::newRow("a >> b + c") << QString("function() { a >> b + c; }") << QString("function() {\n    a >> b + c;\n}");
-    QTest::newRow("(a >> b) + c") << QString("function() { (a >> b) + c; }") << QString("function() {\n    (a >> b) + c;\n}");
-    QTest::newRow("a >>> b + c") << QString("function() { a >>> b + c; }") << QString("function() {\n    a >>> b + c;\n}");
-    QTest::newRow("(a >>> b) + c") << QString("function() { (a >>> b) + c; }") << QString("function() {\n    (a >>> b) + c;\n}");
-    QTest::newRow("a == b || c != d") << QString("function() { a == b || c != d; }") << QString("function() {\n    a == b || c != d;\n}");
-    QTest::newRow("a == (b || c != d)") << QString("function() { a == (b || c != d); }") << QString("function() {\n    a == (b || c != d);\n}");
-    QTest::newRow("a === b || c !== d") << QString("function() { a === b || c !== d; }") << QString("function() {\n    a === b || c !== d;\n}");
-    QTest::newRow("a === (b || c !== d)") << QString("function() { a === (b || c !== d); }") << QString("function() {\n    a === (b || c !== d);\n}");
-    QTest::newRow("a &= b + c") << QString("function() { a &= b + c; }") << QString("function() {\n    a &= b + c;\n}");
-    QTest::newRow("debugger") << QString("function() { debugger }") << QString("function() {\n    debugger;\n}");
+    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("continue") << QString("function() { for (; ; ) { continue label; } }") << QString("function () { for (; ; ) { continue label; } }");
+    QTest::newRow("break") << QString("function() { for (; ; ) { break; } }") << QString("function () { for (; ; ) { break; } }");
+    QTest::newRow("break") << QString("function() { for (; ; ) { break label; } }") << QString("function () { for (; ; ) { break label; } }");
+    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_QScriptValue::prettyPrinter()
@@ -3117,7 +3225,8 @@ void tst_QScriptValue::prettyPrinter()
     QFETCH(QString, function);
     QFETCH(QString, expected);
     QScriptEngine eng;
-    QScriptValue val = eng.evaluate(function);
+    QScriptValue val = eng.evaluate("(" + function + ")");
+    QVERIFY(val.isFunction());
     QString actual = val.toString();
     int count = qMin(actual.size(), expected.size());
 //    qDebug() << actual << expected;
@@ -3139,6 +3248,8 @@ void tst_QScriptValue::engineDeleted()
     QVERIFY(v3.isObject());
     QScriptValue v4 = eng->newQObject(this);
     QVERIFY(v4.isQObject());
+    QScriptValue v5 = "Hello";
+    QVERIFY(v2.isString());
 
     delete eng;
 
@@ -3150,6 +3261,8 @@ void tst_QScriptValue::engineDeleted()
     QVERIFY(v3.engine() == 0);
     QVERIFY(!v4.isValid());
     QVERIFY(v4.engine() == 0);
+    QVERIFY(v5.isValid());
+    QVERIFY(v5.engine() == 0);
 }
 
 void tst_QScriptValue::valueOfWithClosure()
@@ -3189,6 +3302,17 @@ void tst_QScriptValue::objectId()
 
     QVERIFY(eng.objectById(o1.objectId()).strictlyEquals(o1));
     QVERIFY(eng.objectById(o2.objectId()).strictlyEquals(o2));
+
+    qint64 globalObjectId = -1;
+    {
+        QScriptValue global = eng.globalObject();
+        globalObjectId = global.objectId();
+        QVERIFY(globalObjectId != -1);
+        QVERIFY(eng.objectById(globalObjectId).strictlyEquals(global));
+    }
+    QScriptValue obj = eng.objectById(globalObjectId);
+    QVERIFY(obj.isObject());
+    QVERIFY(obj.strictlyEquals(eng.globalObject()));
 }
 
 QTEST_MAIN(tst_QScriptValue)
diff --git a/tests/auto/qscriptvalueiterator/tst_qscriptvalueiterator.cpp b/tests/auto/qscriptvalueiterator/tst_qscriptvalueiterator.cpp
index 45e759623c..48fac1d58b 100644
--- a/tests/auto/qscriptvalueiterator/tst_qscriptvalueiterator.cpp
+++ b/tests/auto/qscriptvalueiterator/tst_qscriptvalueiterator.cpp
@@ -48,6 +48,8 @@
 //TESTED_CLASS=
 //TESTED_FILES=
 
+Q_DECLARE_METATYPE(QScriptValue);
+
 class tst_QScriptValueIterator : public QObject
 {
     Q_OBJECT
@@ -61,15 +63,14 @@ private slots:
     void iterateForward();
     void iterateBackward_data();
     void iterateBackward();
+    void iterateArray_data();
     void iterateArray();
     void iterateBackAndForth();
     void setValue();
     void remove();
     void iterateString();
     void iterateGetterSetter();
-    void iterateArgumentsObject();
     void assignObjectToIterator();
-    void undefinedBehavior();
 };
 
 tst_QScriptValueIterator::tst_QScriptValueIterator()
@@ -207,48 +208,101 @@ void tst_QScriptValueIterator::iterateBackward()
     QCOMPARE(it.hasNext(), false);
 }
 
+void tst_QScriptValueIterator::iterateArray_data()
+{
+    QTest::addColumn<QStringList>("inputPropertyNames");
+    QTest::addColumn<QStringList>("inputPropertyValues");
+    QTest::addColumn<QStringList>("propertyNames");
+    QTest::addColumn<QStringList>("propertyValues");
+    QTest::newRow("no elements") << QStringList() << QStringList() << QStringList() << QStringList();
+
+
+    QTest::newRow("0=foo, 1=barr")
+        << (QStringList() << "0" << "1")
+        << (QStringList() << "foo" << "bar")
+        << (QStringList() << "0" << "1")
+        << (QStringList() << "foo" << "bar");
+
+
+    QTest::newRow("0=foo, 3=barr")
+        << (QStringList() << "0" << "1" << "2" << "3")
+        << (QStringList() << "foo" << "" << "" << "bar")
+        << (QStringList() << "0" << "1" << "2" << "3")
+        << (QStringList() << "foo" << "" << "" << "bar");
+}
+
 void tst_QScriptValueIterator::iterateArray()
 {
+    QFETCH(QStringList, inputPropertyNames);
+    QFETCH(QStringList, inputPropertyValues);
+    QFETCH(QStringList, propertyNames);
+    QFETCH(QStringList, propertyValues);
+
     QScriptEngine engine;
     QScriptValue array = engine.newArray();
-    array.setProperty("0", QScriptValue(&engine, 123));
-    array.setProperty("1", QScriptValue(&engine, 456));
-    array.setProperty("2", QScriptValue(&engine, 789));
+    for (int i = 0; i < inputPropertyNames.size(); ++i) {
+        array.setProperty(inputPropertyNames.at(i), inputPropertyValues.at(i));
+    }
+
     int length = array.property("length").toInt32();
-    QCOMPARE(length, 3);
+    QCOMPARE(length, propertyNames.size());
     QScriptValueIterator it(array);
     for (int i = 0; i < length; ++i) {
         QCOMPARE(it.hasNext(), true);
-        QString indexStr = QScriptValue(&engine, i).toString();
         it.next();
-        QCOMPARE(it.name(), indexStr);
-        QCOMPARE(it.flags(), array.propertyFlags(indexStr));
-        QCOMPARE(it.value().strictlyEquals(array.property(indexStr)), true);
+        QCOMPARE(it.name(), propertyNames.at(i));
+        QCOMPARE(it.flags(), array.propertyFlags(propertyNames.at(i)));
+        QVERIFY(it.value().strictlyEquals(array.property(propertyNames.at(i))));
+        QCOMPARE(it.value().toString(), propertyValues.at(i));
     }
     QCOMPARE(it.hasNext(), false);
 
+    QCOMPARE(it.hasPrevious(), length > 0);
     for (int i = length - 1; i >= 0; --i) {
         it.previous();
-        QString indexStr = QScriptValue(&engine, i).toString();
-        QCOMPARE(it.name(), indexStr);
-        QCOMPARE(it.value().strictlyEquals(array.property(indexStr)), true);
+        QCOMPARE(it.name(), propertyNames.at(i));
+        QCOMPARE(it.flags(), array.propertyFlags(propertyNames.at(i)));
+        QVERIFY(it.value().strictlyEquals(array.property(propertyNames.at(i))));
+        QCOMPARE(it.value().toString(), propertyValues.at(i));
         QCOMPARE(it.hasPrevious(), i > 0);
     }
     QCOMPARE(it.hasPrevious(), false);
 
     // hasNext() and hasPrevious() cache their result; verify that the result is in sync
-    QVERIFY(it.hasNext());
-    it.next();
-    QCOMPARE(it.name(), QString::fromLatin1("0"));
-    QVERIFY(it.hasNext());
-    it.previous();
-    QCOMPARE(it.name(), QString::fromLatin1("0"));
-    QVERIFY(!it.hasPrevious());
-    it.next();
-    QCOMPARE(it.name(), QString::fromLatin1("0"));
-    QVERIFY(it.hasPrevious());
-    it.next();
-    QCOMPARE(it.name(), QString::fromLatin1("1"));
+    if (length > 1) {
+        QVERIFY(it.hasNext());
+        it.next();
+        QCOMPARE(it.name(), QString::fromLatin1("0"));
+        QVERIFY(it.hasNext());
+        it.previous();
+        QCOMPARE(it.name(), QString::fromLatin1("0"));
+        QVERIFY(!it.hasPrevious());
+        it.next();
+        QCOMPARE(it.name(), QString::fromLatin1("0"));
+        QVERIFY(it.hasPrevious());
+        it.next();
+        QCOMPARE(it.name(), QString::fromLatin1("1"));
+    }
+    {
+        // same test as object:
+        QScriptValue originalArray = engine.newArray();
+        for (int i = 0; i < inputPropertyNames.size(); ++i) {
+            originalArray.setProperty(inputPropertyNames.at(i), inputPropertyValues.at(i));
+        }
+        QScriptValue array = originalArray.toObject();
+        int length = array.property("length").toInt32();
+        QCOMPARE(length, propertyNames.size());
+        QScriptValueIterator it(array);
+        for (int i = 0; i < length; ++i) {
+            QCOMPARE(it.hasNext(), true);
+            it.next();
+            QCOMPARE(it.name(), propertyNames.at(i));
+            QCOMPARE(it.flags(), array.propertyFlags(propertyNames.at(i)));
+            QVERIFY(it.value().strictlyEquals(array.property(propertyNames.at(i))));
+            QCOMPARE(it.value().toString(), propertyValues.at(i));
+        }
+        QCOMPARE(it.hasNext(), false);
+    }
 }
 
 void tst_QScriptValueIterator::iterateBackAndForth()
@@ -260,22 +314,31 @@ void tst_QScriptValueIterator::iterateBackAndForth()
         object.setProperty("rab", QScriptValue(&engine, "oof"),
                            QScriptValue::SkipInEnumeration); // should not affect iterator
         QScriptValueIterator it(object);
+        QVERIFY(it.hasNext());
         it.next();
         QCOMPARE(it.name(), QLatin1String("foo"));
+        QVERIFY(it.hasPrevious());
         it.previous();
         QCOMPARE(it.name(), QLatin1String("foo"));
+        QVERIFY(it.hasNext());
         it.next();
         QCOMPARE(it.name(), QLatin1String("foo"));
+        QVERIFY(it.hasPrevious());
         it.previous();
         QCOMPARE(it.name(), QLatin1String("foo"));
+        QVERIFY(it.hasNext());
         it.next();
         QCOMPARE(it.name(), QLatin1String("foo"));
+        QVERIFY(it.hasNext());
         it.next();
         QCOMPARE(it.name(), QLatin1String("rab"));
+        QVERIFY(it.hasPrevious());
         it.previous();
         QCOMPARE(it.name(), QLatin1String("rab"));
+        QVERIFY(it.hasNext());
         it.next();
         QCOMPARE(it.name(), QLatin1String("rab"));
+        QVERIFY(it.hasPrevious());
         it.previous();
         QCOMPARE(it.name(), QLatin1String("rab"));
     }
@@ -359,6 +422,7 @@ void tst_QScriptValueIterator::iterateString()
     }
     QCOMPARE(it.hasNext(), false);
 
+    QVERIFY(it.hasPrevious());
     for (int i = length - 1; i >= 0; --i) {
         it.previous();
         QString indexStr = QScriptValue(&engine, i).toString();
@@ -473,96 +537,6 @@ void tst_QScriptValueIterator::iterateGetterSetter()
     }
 }
 
-static QScriptValue getArgumentsObject(QScriptContext *ctx, QScriptEngine *)
-{
-    return ctx->argumentsObject();
-}
-
-void tst_QScriptValueIterator::iterateArgumentsObject()
-{
-    QScriptEngine eng;
-    QScriptValue fun = eng.newFunction(getArgumentsObject);
-    QScriptValue ret = fun.call(QScriptValue(), QScriptValueList() << QScriptValue(&eng, 123) << QScriptValue(&eng, 456));
-    QCOMPARE(ret.property("length").toInt32(), 2);
-
-    QScriptValueIterator it(ret);
-    QVERIFY(it.hasNext());
-    it.next();
-    QCOMPARE(it.name(), QString::fromLatin1("callee"));
-    QVERIFY(it.value().isFunction());
-    QVERIFY(it.value().strictlyEquals(fun));
-    QVERIFY(it.hasNext());
-
-    it.next();
-    QCOMPARE(it.name(), QString::fromLatin1("length"));
-    QVERIFY(it.value().isNumber());
-    QCOMPARE(it.value().toInt32(), 2);
-    QVERIFY(it.hasNext());
-
-    it.next();
-    QCOMPARE(it.name(), QString::fromLatin1("0"));
-    QVERIFY(it.value().isNumber());
-    QCOMPARE(it.value().toInt32(), 123);
-    QVERIFY(it.hasNext());
-
-    it.next();
-    QCOMPARE(it.name(), QString::fromLatin1("1"));
-    QVERIFY(it.value().isNumber());
-    QCOMPARE(it.value().toInt32(), 456);
-    QVERIFY(!it.hasNext());
-
-    QVERIFY(it.hasPrevious());
-    it.previous();
-    QCOMPARE(it.name(), QString::fromLatin1("1"));
-    QVERIFY(it.value().isNumber());
-    QCOMPARE(it.value().toInt32(), 456);
-    QVERIFY(it.hasPrevious());
-
-    it.previous();
-    QCOMPARE(it.name(), QString::fromLatin1("0"));
-    QVERIFY(it.value().isNumber());
-    QCOMPARE(it.value().toInt32(), 123);
-    QVERIFY(it.hasPrevious());
-
-    it.previous();
-    QCOMPARE(it.name(), QString::fromLatin1("length"));
-    QVERIFY(it.value().isNumber());
-    QCOMPARE(it.value().toInt32(), 2);
-    QVERIFY(it.hasPrevious());
-
-    it.previous();
-    QCOMPARE(it.name(), QString::fromLatin1("callee"));
-    QVERIFY(it.value().isFunction());
-    QVERIFY(it.value().strictlyEquals(fun));
-    QVERIFY(!it.hasPrevious());
-}
-
-void tst_QScriptValueIterator::undefinedBehavior()
-{
-    QScriptEngine eng;
-    QScriptValue obj = eng.newObject();
-    obj.setProperty("foo", QScriptValue(&eng, 123));
-
-    QScriptValueIterator it(obj);
-    QVERIFY(it.hasNext());
-
-    // delete the property
-    obj.setProperty("foo", QScriptValue());
-
-    it.next();
-    QCOMPARE(it.name(), QString::fromLatin1("foo"));
-    QVERIFY(!it.value().isValid());
-
-    QVERIFY(!it.hasNext());
-    // add a property
-    obj.setProperty("bar", QScriptValue(&eng, 123));
-    QVERIFY(it.hasNext());
-
-    it.next();
-    QCOMPARE(it.name(), QString::fromLatin1("bar"));
-    QVERIFY(it.value().isNumber());
-}
-
 void tst_QScriptValueIterator::assignObjectToIterator()
 {
     QScriptEngine eng;
diff --git a/tests/auto/qstringbuilder/qstringbuilder.pro b/tests/auto/qstringbuilder/qstringbuilder.pro
deleted file mode 100644
index c5a26d386c..0000000000
--- a/tests/auto/qstringbuilder/qstringbuilder.pro
+++ /dev/null
@@ -1,5 +0,0 @@
-
-TEMPLATE = subdirs
-SUBDIRS = scenario1.pro scenario2.pro scenario3.pro scenario4.pro
-
-
diff --git a/tests/auto/qstringbuilder/scenario1.pro b/tests/auto/qstringbuilder/scenario1.pro
deleted file mode 100644
index d72451c2ec..0000000000
--- a/tests/auto/qstringbuilder/scenario1.pro
+++ /dev/null
@@ -1,9 +0,0 @@
-load(qttest_p4)
-
-QT = core
-
-SOURCES  += scenario1.cpp
-HEADERS  += tst_qstringbuilder.h
-
-DEFINES += SCENARIO=1
-
diff --git a/tests/auto/qstringbuilder/scenario2.pro b/tests/auto/qstringbuilder/scenario2.pro
deleted file mode 100644
index 78e0c68de3..0000000000
--- a/tests/auto/qstringbuilder/scenario2.pro
+++ /dev/null
@@ -1,8 +0,0 @@
-load(qttest_p4)
-
-QT = core
-
-SOURCES  += scenario2.cpp
-HEADERS  += tst_qstringbuilder.h
-
-DEFINES += SCENARIO=2
diff --git a/tests/auto/qstringbuilder/scenario3.pro b/tests/auto/qstringbuilder/scenario3.pro
deleted file mode 100644
index 7b9e5af180..0000000000
--- a/tests/auto/qstringbuilder/scenario3.pro
+++ /dev/null
@@ -1,8 +0,0 @@
-load(qttest_p4)
-
-QT = core
-
-SOURCES  += scenario3.cpp
-HEADERS  += tst_qstringbuilder.h
-
-DEFINES += SCENARIO=3
diff --git a/tests/auto/qstringbuilder/scenario4.pro b/tests/auto/qstringbuilder/scenario4.pro
deleted file mode 100644
index 1b62b25e37..0000000000
--- a/tests/auto/qstringbuilder/scenario4.pro
+++ /dev/null
@@ -1,8 +0,0 @@
-load(qttest_p4)
-
-QT = core
-
-SOURCES  += scenario4.cpp
-HEADERS  += tst_qstringbuilder.h
-
-DEFINES += SCENARIO=4
diff --git a/tests/auto/qstringbuilder1/qstringbuilder1.pro b/tests/auto/qstringbuilder1/qstringbuilder1.pro
new file mode 100644
index 0000000000..1ca9d456a8
--- /dev/null
+++ b/tests/auto/qstringbuilder1/qstringbuilder1.pro
@@ -0,0 +1,9 @@
+load(qttest_p4)
+
+QT = core
+
+SOURCES  += tst_qstringbuilder1.cpp
+HEADERS  += ../qstringbuilder1/stringbuilder.h
+
+DEFINES += SCENARIO=1
+
diff --git a/tests/auto/qstringbuilder/tst_qstringbuilder.cpp b/tests/auto/qstringbuilder1/stringbuilder.cpp
index ffe77392d9..c26099ae33 100644
--- a/tests/auto/qstringbuilder/tst_qstringbuilder.cpp
+++ b/tests/auto/qstringbuilder1/stringbuilder.cpp
@@ -86,7 +86,7 @@
 #endif
 
 #include <QtTest/QtTest>
-#include "tst_qstringbuilder.h"
+#include "stringbuilder.h"
 
 //TESTED_CLASS=QStringBuilder
 //TESTED_FILES=qstringbuilder.cpp
diff --git a/tests/auto/qstringbuilder/tst_qstringbuilder.h b/tests/auto/qstringbuilder1/stringbuilder.h
index b7e7f5a71b..b7e7f5a71b 100644
--- a/tests/auto/qstringbuilder/tst_qstringbuilder.h
+++ b/tests/auto/qstringbuilder1/stringbuilder.h
diff --git a/tests/auto/qstringbuilder/scenario3.cpp b/tests/auto/qstringbuilder1/tst_qstringbuilder1.cpp
index 915964993a..f6fa7c07ee 100644
--- a/tests/auto/qstringbuilder/scenario3.cpp
+++ b/tests/auto/qstringbuilder1/tst_qstringbuilder1.cpp
@@ -39,4 +39,4 @@
 **
 ****************************************************************************/
 
-#include "tst_qstringbuilder.cpp"
+#include "../qstringbuilder1/stringbuilder.cpp"
diff --git a/tests/auto/qstringbuilder2/qstringbuilder2.pro b/tests/auto/qstringbuilder2/qstringbuilder2.pro
new file mode 100644
index 0000000000..c0b3ebc797
--- /dev/null
+++ b/tests/auto/qstringbuilder2/qstringbuilder2.pro
@@ -0,0 +1,8 @@
+load(qttest_p4)
+
+QT = core
+
+SOURCES  += tst_qstringbuilder2.cpp
+HEADERS  += ../qstringbuilder1/stringbuilder.h
+
+DEFINES += SCENARIO=2
diff --git a/tests/auto/qstringbuilder/scenario1.cpp b/tests/auto/qstringbuilder2/tst_qstringbuilder2.cpp
index 915964993a..f6fa7c07ee 100644
--- a/tests/auto/qstringbuilder/scenario1.cpp
+++ b/tests/auto/qstringbuilder2/tst_qstringbuilder2.cpp
@@ -39,4 +39,4 @@
 **
 ****************************************************************************/
 
-#include "tst_qstringbuilder.cpp"
+#include "../qstringbuilder1/stringbuilder.cpp"
diff --git a/tests/auto/qstringbuilder3/qstringbuilder3.pro b/tests/auto/qstringbuilder3/qstringbuilder3.pro
new file mode 100644
index 0000000000..93d1a39e7e
--- /dev/null
+++ b/tests/auto/qstringbuilder3/qstringbuilder3.pro
@@ -0,0 +1,8 @@
+load(qttest_p4)
+
+QT = core
+
+SOURCES  += tst_qstringbuilder3.cpp
+HEADERS  += ../qstringbuilder1/stringbuilder.h
+
+DEFINES += SCENARIO=3
diff --git a/tests/auto/qstringbuilder/scenario2.cpp b/tests/auto/qstringbuilder3/tst_qstringbuilder3.cpp
index 915964993a..f6fa7c07ee 100644
--- a/tests/auto/qstringbuilder/scenario2.cpp
+++ b/tests/auto/qstringbuilder3/tst_qstringbuilder3.cpp
@@ -39,4 +39,4 @@
 **
 ****************************************************************************/
 
-#include "tst_qstringbuilder.cpp"
+#include "../qstringbuilder1/stringbuilder.cpp"
diff --git a/tests/auto/qstringbuilder4/qstringbuilder4.pro b/tests/auto/qstringbuilder4/qstringbuilder4.pro
new file mode 100644
index 0000000000..eeec447885
--- /dev/null
+++ b/tests/auto/qstringbuilder4/qstringbuilder4.pro
@@ -0,0 +1,8 @@
+load(qttest_p4)
+
+QT = core
+
+SOURCES  += tst_qstringbuilder4.cpp
+HEADERS  += ../qstringbuilder1/stringbuilder.h
+
+DEFINES += SCENARIO=4
diff --git a/tests/auto/qstringbuilder/scenario4.cpp b/tests/auto/qstringbuilder4/tst_qstringbuilder4.cpp
index 25f793261d..480db66506 100644
--- a/tests/auto/qstringbuilder/scenario4.cpp
+++ b/tests/auto/qstringbuilder4/tst_qstringbuilder4.cpp
@@ -39,4 +39,4 @@
 **
 ****************************************************************************/
 
-#include "tst_qstringbuilder.cpp"
+#include "../qstringbuilder1/stringbuilder.cpp"
diff --git a/tests/auto/qtextdocument/tst_qtextdocument.cpp b/tests/auto/qtextdocument/tst_qtextdocument.cpp
index 4643df03a2..cffa4375ca 100644
--- a/tests/auto/qtextdocument/tst_qtextdocument.cpp
+++ b/tests/auto/qtextdocument/tst_qtextdocument.cpp
@@ -2490,6 +2490,25 @@ void tst_QTextDocument::testUndoBlocks()
     QCOMPARE(doc->toPlainText(), QString("Hello WorldOne\nTwo\nThree"));
     doc->undo();
     QCOMPARE(doc->toPlainText(), QString("Hello World"));
+    cursor.insertText("One\nTwo\nThree");
+    cursor.insertText("Trailing text");
+    doc->undo();
+    QCOMPARE(doc->toPlainText(), QString("Hello WorldOne\nTwo\nThree"));
+    doc->undo();
+    QCOMPARE(doc->toPlainText(), QString("Hello World"));
+    doc->undo();
+    QCOMPARE(doc->toPlainText(), QString(""));
+
+    cursor.insertText("quod");
+    cursor.beginEditBlock();
+    cursor.insertText(" erat");
+    cursor.endEditBlock();
+    cursor.insertText(" demonstrandum");
+    QCOMPARE(doc->toPlainText(), QString("quod erat demonstrandum"));
+    doc->undo();
+    QCOMPARE(doc->toPlainText(), QString("quod erat"));
+    doc->undo();
+    QCOMPARE(doc->toPlainText(), QString("quod"));
     doc->undo();
     QCOMPARE(doc->toPlainText(), QString(""));
 }