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

**

** Copyright (C) 2009 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 <QtScript/qscriptengineagent.h>

#include <QtScript/qscriptengine.h>

#include <qscriptvalueiterator.h>

//TESTED_CLASS=

//TESTED_FILES=

QT_BEGIN_NAMESPACE

extern bool qt_script_isJITEnabled();

QT_END_NAMESPACE

class tst_QScriptEngineAgent : public QObject

{

    Q_OBJECT

    Q_PROPERTY(double testProperty READ testProperty WRITE setTestProperty)

public:

    tst_QScriptEngineAgent();

    virtual ~tst_QScriptEngineAgent();

    double testProperty() const { return m_testProperty; }

    void setTestProperty(double val) { m_testProperty = val; }

public slots:

    double testSlot(double arg) { return arg; }

signals:

    void testSignal(double arg);

private slots:

    void scriptLoadAndUnload_statement();

    void scriptLoadAndUnload();

    void scriptLoadAndUnload_eval();

    void contextPushAndPop();

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

    void hasUncaughtException();

private:

    double m_testProperty;

};

tst_QScriptEngineAgent::tst_QScriptEngineAgent()

{

}

tst_QScriptEngineAgent::~tst_QScriptEngineAgent()

{

}

struct ScriptEngineEvent

{

    enum Type {

        ScriptLoad,

        ScriptUnload,//1

        ContextPush,

        ContextPop,  //3

        FunctionEntry, //4

        FunctionExit, //5

        PositionChange,

        ExceptionThrow,//7

        ExceptionCatch,

        DebuggerInvocationRequest

    };

    Type type;

    qint64 scriptId;

    QString script;

    QString fileName;

    int lineNumber;

    int columnNumber;

    QScriptValue value;

    bool hasExceptionHandler;

    ScriptEngineEvent(qint64 scriptId,

                      const QString &script, const QString &fileName,

                      int lineNumber)

        : type(ScriptLoad), scriptId(scriptId),

          script(script), fileName(fileName),

          lineNumber(lineNumber)

        { }

    ScriptEngineEvent(Type type, qint64 scriptId = -777)

        : type(type), scriptId(scriptId)

        { }

    ScriptEngineEvent(Type type, qint64 scriptId,

                      const QScriptValue &value)

        : type(type), scriptId(scriptId),

          value(value)

        { }

    ScriptEngineEvent(qint64 scriptId,

                      int lineNumber, int columnNumber)

        : type(PositionChange), scriptId(scriptId),

          lineNumber(lineNumber), columnNumber(columnNumber)

        { }

    ScriptEngineEvent(qint64 scriptId,

                      const QScriptValue &exception, bool hasHandler)

        : type(ExceptionThrow), scriptId(scriptId),

          value(exception), hasExceptionHandler(hasHandler)

        { }

    static QString typeToQString(Type t)

    {

        switch (t) {

            case ScriptEngineEvent::ScriptLoad: return "ScriptLoad";

            case ScriptEngineEvent::ScriptUnload: return "ScriptUnload";

            case ScriptEngineEvent::ContextPush: return "ContextPush";

            case ScriptEngineEvent::ContextPop: return "ContextPop";

            case ScriptEngineEvent::FunctionEntry: return "FunctionEntry";

            case ScriptEngineEvent::FunctionExit: return "FunctionExit";

            case ScriptEngineEvent::PositionChange: return "PositionChange";

            case ScriptEngineEvent::ExceptionThrow: return "ExceptionThrow";

            case ScriptEngineEvent::ExceptionCatch: return "ExceptionCatch";

            case ScriptEngineEvent::DebuggerInvocationRequest: return "DebuggerInvocationRequest";

            }

    }

};

class ScriptEngineSpy : public QScriptEngineAgent, public QList<ScriptEngineEvent>

{

public:

    enum IgnoreFlag {

        IgnoreScriptLoad = 0x001,

        IgnoreScriptUnload = 0x002,

        IgnoreFunctionEntry = 0x004,

        IgnoreFunctionExit = 0x008,

        IgnorePositionChange = 0x010,

        IgnoreExceptionThrow = 0x020,

        IgnoreExceptionCatch = 0x040,

        IgnoreContextPush = 0x0100,

        IgnoreContextPop = 0x0200,

        IgnoreDebuggerInvocationRequest = 0x0400

    };

    ScriptEngineSpy(QScriptEngine *engine, int ignores = 0);

    ~ScriptEngineSpy();

    void enableIgnoreFlags(int flags)

        { m_ignores |= flags; }

    void disableIgnoreFlags(int flags)

        { m_ignores &= ~flags; }

protected:

    void scriptLoad(qint64 id, const QString &script,

                    const QString &fileName, int lineNumber);

    void scriptUnload(qint64 id);

    void contextPush();

    void contextPop();

    void functionEntry(qint64 scriptId);

    void functionExit(qint64 scriptId, const QScriptValue &returnValue);

    void positionChange(qint64 scriptId,

                        int lineNumber, int columnNumber);

    void exceptionThrow(qint64 scriptId, const QScriptValue &exception,

                        bool hasHandler);

    void exceptionCatch(qint64 scriptId, const QScriptValue &exception);

    bool supportsExtension(Extension ext) const;

    QVariant extension(Extension ext, const QVariant &arg);

private:

    int m_ignores;

};

ScriptEngineSpy::ScriptEngineSpy(QScriptEngine *engine, int ignores)

    : QScriptEngineAgent(engine)

{

    m_ignores = ignores;

    engine->setAgent(this);

}

ScriptEngineSpy::~ScriptEngineSpy()

{

}

void ScriptEngineSpy::scriptLoad(qint64 id, const QString &script,

                                 const QString &fileName, int lineNumber)

{

    if (!(m_ignores & IgnoreScriptLoad))

        append(ScriptEngineEvent(id, script, fileName, lineNumber));

}

void ScriptEngineSpy::scriptUnload(qint64 id)

{

    if (!(m_ignores & IgnoreScriptUnload))

        append(ScriptEngineEvent(ScriptEngineEvent::ScriptUnload, id));

}

void ScriptEngineSpy::contextPush()

{

    if (!(m_ignores & IgnoreContextPush))

        append(ScriptEngineEvent(ScriptEngineEvent::ContextPush));

}

void ScriptEngineSpy::contextPop()

{

    if (!(m_ignores & IgnoreContextPop))

        append(ScriptEngineEvent(ScriptEngineEvent::ContextPop));

}

void ScriptEngineSpy::functionEntry(qint64 scriptId)

{

    if (!(m_ignores & IgnoreFunctionEntry))

        append(ScriptEngineEvent(ScriptEngineEvent::FunctionEntry, scriptId));

}

void ScriptEngineSpy::functionExit(qint64 scriptId,

                                   const QScriptValue &returnValue)

{

    if (!(m_ignores & IgnoreFunctionExit))

        append(ScriptEngineEvent(ScriptEngineEvent::FunctionExit, scriptId, returnValue));

}

void ScriptEngineSpy::positionChange(qint64 scriptId,

                                     int lineNumber, int columnNumber)

{

    if (!(m_ignores & IgnorePositionChange))

        append(ScriptEngineEvent(scriptId, lineNumber, columnNumber));

}

void ScriptEngineSpy::exceptionThrow(qint64 scriptId,

                                     const QScriptValue &exception, bool hasHandler)

{

    if (!(m_ignores & IgnoreExceptionThrow))

        append(ScriptEngineEvent(scriptId, exception, hasHandler));

}

void ScriptEngineSpy::exceptionCatch(qint64 scriptId,

                                     const QScriptValue &exception)

{

    if (!(m_ignores & IgnoreExceptionCatch))

        append(ScriptEngineEvent(ScriptEngineEvent::ExceptionCatch, scriptId, exception));

}

bool ScriptEngineSpy::supportsExtension(Extension ext) const

{

    if (ext == DebuggerInvocationRequest)

        return !(m_ignores & IgnoreDebuggerInvocationRequest);

    return false;

}

QVariant ScriptEngineSpy::extension(Extension ext, const QVariant &arg)

{

    if (ext == DebuggerInvocationRequest) {

        QVariantList lst = arg.toList();

        qint64 scriptId = lst.at(0).toLongLong();

        int lineNumber = lst.at(1).toInt();

        int columnNumber = lst.at(2).toInt();

        ScriptEngineEvent evt(scriptId, lineNumber, columnNumber);

        evt.type = ScriptEngineEvent::DebuggerInvocationRequest;

        append(evt);

        return QString::fromLatin1("extension(DebuggerInvocationRequest)");

    }

    return QVariant();

}

void tst_QScriptEngineAgent::scriptLoadAndUnload_statement()

{

    QScriptEngine eng;

    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreScriptLoad

                                                       | ScriptEngineSpy::IgnoreScriptUnload));

    QCOMPARE(eng.agent(), (QScriptEngineAgent*)spy);

    {

        spy->clear();

        QString code = ";";

        QString fileName = "foo.qs";

        int lineNumber = 123;

        eng.evaluate(code, fileName, lineNumber);

        QCOMPARE(spy->count(), 2);

        QCOMPARE(spy->at(0).type, ScriptEngineEvent::ScriptLoad);

        QVERIFY(spy->at(0).scriptId != -1);

        QCOMPARE(spy->at(0).script, code);

        QCOMPARE(spy->at(0).fileName, fileName);

        QCOMPARE(spy->at(0).lineNumber, lineNumber);

        QCOMPARE(spy->at(1).type, ScriptEngineEvent::ScriptUnload);

        QCOMPARE(spy->at(1).scriptId, spy->at(0).scriptId);

    }

    {

        spy->clear();

        QString code = ";";

        QString fileName = "bar.qs";

        int lineNumber = 456;

        eng.evaluate(code, fileName, lineNumber);

        QCOMPARE(spy->count(), 2);

        QCOMPARE(spy->at(0).type, ScriptEngineEvent::ScriptLoad);

        QVERIFY(spy->at(0).scriptId != -1);

        QCOMPARE(spy->at(0).script, code);

        QCOMPARE(spy->at(0).fileName, fileName);

        QCOMPARE(spy->at(0).lineNumber, lineNumber);

        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'); }";

        QString fileName = "baz.qs";

        int lineNumber = 789;

        eng.evaluate(code, fileName, lineNumber);

        QCOMPARE(spy->count(), 1);

        QCOMPARE(spy->at(0).type, ScriptEngineEvent::ScriptLoad);

        QVERIFY(spy->at(0).scriptId != -1);

        QCOMPARE(spy->at(0).script, code);

        QCOMPARE(spy->at(0).fileName, fileName);

        QCOMPARE(spy->at(0).lineNumber, lineNumber);

        code = "foo = null";

        eng.evaluate(code);

        QCOMPARE(spy->count(), 3);

        QCOMPARE(spy->at(1).type, ScriptEngineEvent::ScriptLoad);

        QVERIFY(spy->at(1).scriptId != -1);

        QVERIFY(spy->at(1).scriptId != spy->at(0).scriptId);

        QCOMPARE(spy->at(1).script, code);

        QCOMPARE(spy->at(1).lineNumber, 1);

        QCOMPARE(spy->at(2).type, ScriptEngineEvent::ScriptUnload);

        QCOMPARE(spy->at(2).scriptId, spy->at(1).scriptId);

        eng.collectGarbage(); // foo() is GC'ed

        QCOMPARE(spy->count(), 4);

        QCOMPARE(spy->at(3).type, ScriptEngineEvent::ScriptUnload);

        QCOMPARE(spy->at(3).scriptId, spy->at(0).scriptId);

    }

    {

        spy->clear();

        QString code = "function foo() { return function() { print('ciao'); } }";

        QString fileName = "foo.qs";

        int lineNumber = 123;

        eng.evaluate(code, fileName, lineNumber);

        QCOMPARE(spy->count(), 1);

        QCOMPARE(spy->at(0).type, ScriptEngineEvent::ScriptLoad);

        QVERIFY(spy->at(0).scriptId != -1);

        QCOMPARE(spy->at(0).script, code);

        QCOMPARE(spy->at(0).fileName, fileName);

        QCOMPARE(spy->at(0).lineNumber, lineNumber);

        code = "bar = foo(); foo = null";

        eng.evaluate(code);

        QCOMPARE(spy->count(), 3);

        QCOMPARE(spy->at(1).type, ScriptEngineEvent::ScriptLoad);

        QVERIFY(spy->at(1).scriptId != -1);

        QVERIFY(spy->at(1).scriptId != spy->at(0).scriptId);

        QCOMPARE(spy->at(1).script, code);

        QCOMPARE(spy->at(2).type, ScriptEngineEvent::ScriptUnload);

        QCOMPARE(spy->at(2).scriptId, spy->at(1).scriptId);

        eng.collectGarbage(); // foo() is not GC'ed

        QCOMPARE(spy->count(), 3);

        code = "bar = null";

        eng.evaluate(code);

        QCOMPARE(spy->count(), 5);

        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); }')");

        QCOMPARE(spy->count(), 3);

        QCOMPARE(spy->at(0).type, ScriptEngineEvent::ScriptLoad);

        QVERIFY(spy->at(0).scriptId != -1);

        QCOMPARE(spy->at(1).type, ScriptEngineEvent::ScriptLoad);

        QVERIFY(spy->at(1).scriptId != -1);

        QVERIFY(spy->at(1).scriptId != spy->at(0).scriptId);

        QCOMPARE(spy->at(2).type, ScriptEngineEvent::ScriptUnload);

        QCOMPARE(spy->at(2).scriptId, spy->at(0).scriptId);

    }

    delete spy;

}

void tst_QScriptEngineAgent::contextPushAndPop()

{

    QScriptEngine eng;

    ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreContextPush

                                                       | ScriptEngineSpy::IgnoreContextPop));

    {

        spy->clear();

        eng.pushContext();

        eng.popContext();

        QCOMPARE(spy->count(), 2);

        QCOMPARE(spy->at(0).type, ScriptEngineEvent::ContextPush);

        QCOMPARE(spy->at(1).type, ScriptEngineEvent::ContextPop);

    }

}

static QScriptValue nativeFunctionReturningArg(QScriptContext *ctx, QScriptEngine *)

{

    return ctx->argument(0);

}

static QScriptValue nativeFunctionThrowingError(QScriptContext *ctx, QScriptEngine *)

{

    return ctx->throwError(ctx->argument(0).toString());

}

static QScriptValue nativeFunctionCallingArg(QScriptContext *ctx, QScriptEngine *)

{

    return ctx->argument(0).call();

}