/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include <qscriptengine.h>

#include <qscriptengineagent.h>

#include <qscriptprogram.h>

#include <qscriptvalueiterator.h>

#include <qgraphicsitem.h>

#include <qstandarditemmodel.h>

#include <QtCore/qnumeric.h>

#include <stdlib.h>

Q_DECLARE_METATYPE(QList<int>)

Q_DECLARE_METATYPE(QObjectList)

Q_DECLARE_METATYPE(QScriptProgram)

//TESTED_CLASS=

//TESTED_FILES=

#if defined(Q_OS_SYMBIAN)

# define STRINGIFY(x) #x

# define TOSTRING(x) STRINGIFY(x)

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

#endif

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

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

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

static void zapSomeStack()

{

    char buf[4096];

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

}

static void collectGarbage_helper(QScriptEngine &eng)

{

    zapSomeStack();

    eng.collectGarbage();

}

class tst_QScriptEngine : public QObject

{

    Q_OBJECT

public:

    tst_QScriptEngine();

    virtual ~tst_QScriptEngine();

private slots:

    void constructWithParent();

    void currentContext();

    void pushPopContext();

    void getSetDefaultPrototype();

    void newFunction();

    void newObject();

    void newArray();

    void newVariant();

    void newRegExp();

    void newDate();

    void newQObject();

    void newQMetaObject();

    void newActivationObject();

    void getSetGlobalObject();

    void globalObjectProperties();

    void globalObjectGetterSetterProperty();

    void builtinFunctionNames_data();

    void builtinFunctionNames();

    void checkSyntax_data();

    void checkSyntax();

    void canEvaluate_data();

    void canEvaluate();

    void evaluate_data();

    void evaluate();

    void nestedEvaluate();

    void uncaughtException();

    void errorMessage_QT679();

    void valueConversion();

    void importExtension();

    void infiniteRecursion();

    void castWithPrototypeChain();

    void castWithMultipleInheritance();

    void collectGarbage();

    void gcWithNestedDataStructure();

    void processEventsWhileRunning();

    void throwErrorFromProcessEvents();

    void stacktrace();

    void numberParsing_data();

    void numberParsing();

    void automaticSemicolonInsertion();

    void abortEvaluation();

    void isEvaluating();

    void printFunctionWithCustomHandler();

    void printThrowsException();

    void errorConstructors();

    void argumentsProperty();

    void numberClass();

    void forInStatement();

    void functionExpression();

    void stringObjects();

    void getterSetterThisObject();

    void continueInSwitch();

    void readOnlyPrototypeProperty();

    void toObject();

    void reservedWords_data();

    void reservedWords();

    void futureReservedWords_data();

    void futureReservedWords();

    void throwInsideWithStatement();

    void getSetAgent();

    void reentrancy();

    void incDecNonObjectProperty();

    void installTranslatorFunctions_data();

    void installTranslatorFunctions();

    void functionScopes();

    void nativeFunctionScopes();

    void evaluateProgram();

    void collectGarbageAfterConnect();

    void qRegExpInport_data();

    void qRegExpInport();

};

tst_QScriptEngine::tst_QScriptEngine()

{

}

tst_QScriptEngine::~tst_QScriptEngine()

{

}

void tst_QScriptEngine::constructWithParent()

{

    QPointer<QScriptEngine> ptr;

    {

        QObject obj;

        QScriptEngine *engine = new QScriptEngine(&obj);

        ptr = engine;

    }

    QVERIFY(ptr == 0);

}

void tst_QScriptEngine::currentContext()

{

    QScriptEngine eng;

    QScriptContext *globalCtx = eng.currentContext();

    QVERIFY(globalCtx != 0);

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

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

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

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

    QVERIFY(!globalCtx->isCalledAsConstructor());

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

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

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

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

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

}

void tst_QScriptEngine::pushPopContext()

{

    QScriptEngine eng;

    QScriptContext *globalCtx = eng.currentContext();

    QScriptContext *ctx = eng.pushContext();

    QVERIFY(ctx != 0);

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

    QVERIFY(!ctx->isCalledAsConstructor());

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

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

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

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

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

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

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

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

    QScriptContext *ctx2 = eng.pushContext();

    QVERIFY(ctx2 != 0);

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

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

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

    eng.popContext();

    eng.popContext();

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

    eng.popContext(); // ignored

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

    eng.popContext(); // ignored

}

static QScriptValue myFunction(QScriptContext *, QScriptEngine *eng)

{

    return eng->nullValue();

}

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

{

    return eng->nullValue();

}

static QScriptValue myThrowingFunction(QScriptContext *ctx, QScriptEngine *)

{

    return ctx->throwError("foo");

}

void tst_QScriptEngine::newFunction()

{

    QScriptEngine eng;

    {

        QScriptValue fun = eng.newFunction(myFunction);

        QCOMPARE(fun.isValid(), true);

        QCOMPARE(fun.isFunction(), true);

        QCOMPARE(fun.isObject(), true);

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

        // a prototype property is automatically constructed

        {

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

            QVERIFY(prot.isObject());

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

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

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

        }

        // prototype should be Function.prototype

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

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

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

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

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

    }

    // the overload that takes a void*

    {

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

        QVERIFY(fun.isFunction());

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

        // a prototype property is automatically constructed

        {

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

            QVERIFY(prot.isObject());

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

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

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

        }

        // prototype should be Function.prototype

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

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

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

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

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

    }

    // the overload that takes a prototype

    {

        QScriptValue proto = eng.newObject();

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

        QCOMPARE(fun.isValid(), true);

        QCOMPARE(fun.isFunction(), true);

        QCOMPARE(fun.isObject(), true);

        // internal prototype should be Function.prototype

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

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

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

        // public prototype should be the one we passed

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

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

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

        QCOMPARE(proto.propertyFlags("constructor"),

                 QScriptValue::Undeletable | QScriptValue::SkipInEnumeration);

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

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

    }

}

void tst_QScriptEngine::newObject()

{

    QScriptEngine eng;

    QScriptValue object = eng.newObject();

    QCOMPARE(object.isValid(), true);

    QCOMPARE(object.isObject(), true);

    QCOMPARE(object.isFunction(), false);

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

    // prototype should be Object.prototype

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

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

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

}

void tst_QScriptEngine::newArray()

{

    QScriptEngine eng;

    QScriptValue array = eng.newArray();

    QCOMPARE(array.isValid(), true);

    QCOMPARE(array.isArray(), true);

    QCOMPARE(array.isObject(), true);

    QVERIFY(!array.isFunction());

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

    // prototype should be Array.prototype

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

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

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

    // task 218092

    {

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

        QVERIFY(ret.isArray());

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

    }

    {

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

        QVERIFY(ret.isArray());

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

    }

    {

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

        QVERIFY(ret.isArray());

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

    }

    {

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

        QVERIFY(ret.isArray());

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

    }

    {

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

        QVERIFY(ret.isArray());

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

    }

    // task 233836

    {

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

        QVERIFY(ret.isNumber());

        QCOMPARE(ret.toInt32(), 0);

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

    }

    {

        QScriptValue ret = eng.newArray(0xFFFFFFFF);

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

        ret.setProperty(0xFFFFFFFF, 123);

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

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

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

        ret.setProperty(123, 456);

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

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

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

    }

}

void tst_QScriptEngine::newVariant()

{

    QScriptEngine eng;

    {

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

        QCOMPARE(opaque.isValid(), true);

        QCOMPARE(opaque.isVariant(), true);

        QVERIFY(!opaque.isFunction());

        QCOMPARE(opaque.isObject(), true);

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

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

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

    }

    // default prototype should be set automatically

    {

        QScriptValue proto = eng.newObject();

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

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

        QVERIFY(ret.isVariant());

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

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

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

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

        QVERIFY(ret2.isVariant());

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

    }

    // "promote" plain object to variant

    {

        QScriptValue object = eng.newObject();

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

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

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

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

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

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

        QVERIFY(ret.isValid());

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

        QVERIFY(ret.isVariant());

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

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

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

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

    }

    // replace value of existing object

    {

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

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

        QVERIFY(ret.isValid());

        QVERIFY(ret.strictlyEquals(object));

        QVERIFY(ret.isVariant());

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

    }

    // valueOf() and toString()

    {

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

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

        QVERIFY(value.isNumber());

        QCOMPARE(value.toInt32(), 123);

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

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

    }

    {

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

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

        QVERIFY(value.isString());

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

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

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

    }

    {

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

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

        QVERIFY(value.isBoolean());

        QCOMPARE(value.toBoolean(), false);

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

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

    }

    {

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

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

        QVERIFY(value.isObject());

        QVERIFY(value.strictlyEquals(object));

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

    }

}

void tst_QScriptEngine::newRegExp()

{

    QScriptEngine eng;

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

        QScriptValue rexp;

        if (x == 0)

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

        else

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

        QCOMPARE(rexp.isValid(), true);

        QCOMPARE(rexp.isRegExp(), true);

        QCOMPARE(rexp.isObject(), true);

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

        // prototype should be RegExp.prototype

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

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

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

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

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

    }

    {

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

        QVERIFY(r.isRegExp());

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

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

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

        QVERIFY(r2.isRegExp());

        QVERIFY(r2.strictlyEquals(r));

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

        QVERIFY(r3.isError());

        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());

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

        QVERIFY(r5.isRegExp());

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

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

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