1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QtTest/QtTest>

    44 

    45 #include <QtScript/qscriptengineagent.h>

    46 #include <QtScript/qscriptengine.h>

    47 #include <QtScript/qscriptprogram.h>

    48 #include <qscriptvalueiterator.h>

    49 

    50 //TESTED_CLASS=

    51 //TESTED_FILES=

    52 

    53 QT_BEGIN_NAMESPACE

    54 extern bool qt_script_isJITEnabled();

    55 QT_END_NAMESPACE

    56 

    57 class tst_QScriptEngineAgent : public QObject

    58 {

    59     Q_OBJECT

    60     Q_PROPERTY(double testProperty READ testProperty WRITE setTestProperty)

    61 

    62 public:

    63     tst_QScriptEngineAgent();

    64     virtual ~tst_QScriptEngineAgent();

    65 

    66     double testProperty() const { return m_testProperty; }

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

    68 

    69 public slots:

    70     double testSlot(double arg) { return arg; }

    71 

    72 signals:

    73     void testSignal(double arg);

    74 

    75 private slots:

    76     void scriptLoadAndUnload_statement();

    77     void scriptLoadAndUnload();

    78     void scriptLoadAndUnload_eval();

    79     void contextPushAndPop();

    80     void functionEntryAndExit_semicolon();

    81     void functionEntryAndExit_expression();

    82     void functionEntryAndExit_functionCall();

    83     void functionEntryAndExit_functionCallWithoutReturn();

    84     void functionEntryAndExit_functionDefinition();

    85     void functionEntryAndExit_native();

    86     void functionEntryAndExit_native2();

    87     void functionEntryAndExit_nativeThrowing();

    88     void functionEntryAndExit_builtin_data();

    89     void functionEntryAndExit_builtin();

    90     void functionEntryAndExit_objects();

    91     void functionEntryAndExit_slots();

    92     void functionEntryAndExit_property_set();

    93     void functionEntryAndExit_property_get();

    94     void functionEntryAndExit_call();

    95     void functionEntryAndExit_functionReturn_construct();

    96     void functionEntryAndExit_functionReturn_call();

    97     void functionEntryAndExit_objectCall();

    98     void positionChange_1();

    99     void positionChange_2();

   100     void exceptionThrowAndCatch();

   101     void eventOrder_assigment();

   102     void eventOrder_functionDefinition();

   103     void eventOrder_throwError();

   104     void eventOrder_throwAndCatch();

   105     void eventOrder_functions();

   106     void eventOrder_throwCatchFinally();

   107     void eventOrder_signalsHandling();

   108     void recursiveObserve();

   109     void multipleAgents();

   110     void syntaxError();

   111     void extension_invoctaion();

   112     void extension();

   113     void isEvaluatingInExtension();

   114     void hasUncaughtException();

   115     void evaluateProgram();

   116     void evaluateProgram_SyntaxError();

   117     void evaluateNullProgram();

   118     void QTBUG6108();

   119 

   120 private:

   121     double m_testProperty;

   122 };

   123 

   124 tst_QScriptEngineAgent::tst_QScriptEngineAgent()

   125 {

   126 }

   127 

   128 tst_QScriptEngineAgent::~tst_QScriptEngineAgent()

   129 {

   130 }

   131 

   132 struct ScriptEngineEvent

   133 {

   134     enum Type {

   135         ScriptLoad,

   136         ScriptUnload,//1

   137         ContextPush,

   138         ContextPop,  //3

   139         FunctionEntry, //4

   140         FunctionExit, //5

   141         PositionChange,

   142         ExceptionThrow,//7

   143         ExceptionCatch,

   144         DebuggerInvocationRequest

   145     };

   146 

   147     Type type;

   148 

   149     qint64 scriptId;

   150     QString script;

   151     QString fileName;

   152     int lineNumber;

   153     int columnNumber;

   154     QScriptValue value;

   155     bool hasExceptionHandler;

   156 

   157     ScriptEngineEvent(qint64 scriptId,

   158                       const QString &script, const QString &fileName,

   159                       int lineNumber)

   160         : type(ScriptLoad), scriptId(scriptId),

   161           script(script), fileName(fileName),

   162           lineNumber(lineNumber)

   163         { }

   164 

   165     ScriptEngineEvent(Type type, qint64 scriptId = -777)

   166         : type(type), scriptId(scriptId)

   167         { }

   168 

   169     ScriptEngineEvent(Type type, qint64 scriptId,

   170                       const QScriptValue &value)

   171         : type(type), scriptId(scriptId),

   172           value(value)

   173         { }

   174 

   175     ScriptEngineEvent(qint64 scriptId,

   176                       int lineNumber, int columnNumber)

   177         : type(PositionChange), scriptId(scriptId),

   178           lineNumber(lineNumber), columnNumber(columnNumber)

   179         { }

   180 

   181     ScriptEngineEvent(qint64 scriptId,

   182                       const QScriptValue &exception, bool hasHandler)

   183         : type(ExceptionThrow), scriptId(scriptId),

   184           value(exception), hasExceptionHandler(hasHandler)

   185         { }

   186 

   187     static QString typeToQString(Type t)

   188     {

   189         switch (t) {

   190             case ScriptEngineEvent::ScriptLoad: return "ScriptLoad";

   191             case ScriptEngineEvent::ScriptUnload: return "ScriptUnload";

   192             case ScriptEngineEvent::ContextPush: return "ContextPush";

   193             case ScriptEngineEvent::ContextPop: return "ContextPop";

   194             case ScriptEngineEvent::FunctionEntry: return "FunctionEntry";

   195             case ScriptEngineEvent::FunctionExit: return "FunctionExit";

   196             case ScriptEngineEvent::PositionChange: return "PositionChange";

   197             case ScriptEngineEvent::ExceptionThrow: return "ExceptionThrow";

   198             case ScriptEngineEvent::ExceptionCatch: return "ExceptionCatch";

   199             case ScriptEngineEvent::DebuggerInvocationRequest: return "DebuggerInvocationRequest";

   200             }

   201     }

   202 };

   203 

   204 class ScriptEngineSpy : public QScriptEngineAgent, public QList<ScriptEngineEvent>

   205 {

   206 public:

   207     enum IgnoreFlag {

   208         IgnoreScriptLoad = 0x001,

   209         IgnoreScriptUnload = 0x002,

   210         IgnoreFunctionEntry = 0x004,

   211         IgnoreFunctionExit = 0x008,

   212         IgnorePositionChange = 0x010,

   213         IgnoreExceptionThrow = 0x020,

   214         IgnoreExceptionCatch = 0x040,

   215         IgnoreContextPush = 0x0100,

   216         IgnoreContextPop = 0x0200,

   217         IgnoreDebuggerInvocationRequest = 0x0400

   218     };

   219 

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

   221     ~ScriptEngineSpy();

   222 

   223     void enableIgnoreFlags(int flags)

   224         { m_ignores |= flags; }

   225     void disableIgnoreFlags(int flags)

   226         { m_ignores &= ~flags; }

   227 

   228 protected:

   229     void scriptLoad(qint64 id, const QString &script,

   230                     const QString &fileName, int lineNumber);

   231     void scriptUnload(qint64 id);

   232 

   233     void contextPush();

   234     void contextPop();

   235 

   236     void functionEntry(qint64 scriptId);

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

   238 

   239     void positionChange(qint64 scriptId,

   240                         int lineNumber, int columnNumber);

   241 

   242     void exceptionThrow(qint64 scriptId, const QScriptValue &exception,

   243                         bool hasHandler);

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

   245 

   246     bool supportsExtension(Extension ext) const;

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

   248 

   249 private:

   250     int m_ignores;

   251 };

   252 

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

   254     : QScriptEngineAgent(engine)

   255 {

   256     m_ignores = ignores;

   257     engine->setAgent(this);

   258 }

   259 

   260 ScriptEngineSpy::~ScriptEngineSpy()

   261 {

   262 }

   263 

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

   265                                  const QString &fileName, int lineNumber)

   266 {

   267     if (!(m_ignores & IgnoreScriptLoad))

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

   269 }

   270 

   271 void ScriptEngineSpy::scriptUnload(qint64 id)

   272 {

   273     if (!(m_ignores & IgnoreScriptUnload))

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

   275 }

   276 

   277 void ScriptEngineSpy::contextPush()

   278 {

   279     if (!(m_ignores & IgnoreContextPush))

   280         append(ScriptEngineEvent(ScriptEngineEvent::ContextPush));

   281 }

   282 

   283 void ScriptEngineSpy::contextPop()

   284 {

   285     if (!(m_ignores & IgnoreContextPop))

   286         append(ScriptEngineEvent(ScriptEngineEvent::ContextPop));

   287 }

   288 

   289 void ScriptEngineSpy::functionEntry(qint64 scriptId)

   290 {

   291     if (!(m_ignores & IgnoreFunctionEntry))

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

   293 }

   294 

   295 void ScriptEngineSpy::functionExit(qint64 scriptId,

   296                                    const QScriptValue &returnValue)

   297 {

   298     if (!(m_ignores & IgnoreFunctionExit))

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

   300 }

   301 

   302 void ScriptEngineSpy::positionChange(qint64 scriptId,

   303                                      int lineNumber, int columnNumber)

   304 {

   305     if (!(m_ignores & IgnorePositionChange))

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

   307 }

   308 

   309 void ScriptEngineSpy::exceptionThrow(qint64 scriptId,

   310                                      const QScriptValue &exception, bool hasHandler)

   311 {

   312     if (!(m_ignores & IgnoreExceptionThrow))

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

   314 }

   315 

   316 void ScriptEngineSpy::exceptionCatch(qint64 scriptId,

   317                                      const QScriptValue &exception)

   318 {

   319     if (!(m_ignores & IgnoreExceptionCatch))

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

   321 }

   322 

   323 bool ScriptEngineSpy::supportsExtension(Extension ext) const

   324 {

   325     if (ext == DebuggerInvocationRequest)

   326         return !(m_ignores & IgnoreDebuggerInvocationRequest);

   327     return false;

   328 }

   329 

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

   331 {

   332     if (ext == DebuggerInvocationRequest) {

   333         QVariantList lst = arg.toList();

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

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

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

   337         ScriptEngineEvent evt(scriptId, lineNumber, columnNumber);

   338         evt.type = ScriptEngineEvent::DebuggerInvocationRequest;

   339         append(evt);

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

   341     }

   342     return QVariant();

   343 }

   344 

   345 void tst_QScriptEngineAgent::scriptLoadAndUnload_statement()

   346 {

   347     QScriptEngine eng;

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

   349                                                        | ScriptEngineSpy::IgnoreScriptUnload));

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

   351     {

   352         spy->clear();

   353         QString code = ";";

   354         QString fileName = "foo.qs";

   355         int lineNumber = 123;

   356         eng.evaluate(code, fileName, lineNumber);

   357 

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

   359 

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

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

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

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

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

   365 

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

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

   368     }

   369 

   370     {

   371         spy->clear();

   372         QString code = ";";

   373         QString fileName = "bar.qs";

   374         int lineNumber = 456;

   375         eng.evaluate(code, fileName, lineNumber);

   376 

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

   378 

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

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

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

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

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

   384 

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

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

   387     }

   388     delete spy;

   389 }

   390 

   391 void tst_QScriptEngineAgent::scriptLoadAndUnload()

   392 {

   393     QScriptEngine eng;

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

   395                                                        | ScriptEngineSpy::IgnoreScriptUnload));

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

   397     {

   398         spy->clear();

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

   400         QString fileName = "baz.qs";

   401         int lineNumber = 789;

   402         eng.evaluate(code, fileName, lineNumber);

   403 

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

   405 

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

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

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

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

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

   411 

   412         code = "foo = null";

   413         eng.evaluate(code);

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

   415 

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

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

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

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

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

   421 

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

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

   424 

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

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

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

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

   429     }

   430 

   431     {

   432         spy->clear();

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

   434         QString fileName = "foo.qs";

   435         int lineNumber = 123;

   436         eng.evaluate(code, fileName, lineNumber);

   437 

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

   439 

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

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

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

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

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

   445 

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

   447         eng.evaluate(code);

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

   449 

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

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

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

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

   454 

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

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

   457 

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

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

   460 

   461         code = "bar = null";

   462         eng.evaluate(code);

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

   464 

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

   466         QCOMPARE(spy->count(), 6);

   467     }

   468     delete spy;

   469 }

   470 

   471 void tst_QScriptEngineAgent::scriptLoadAndUnload_eval()

   472 {

   473     QScriptEngine eng;

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

   475                                                        | ScriptEngineSpy::IgnoreScriptUnload));

   476     {

   477         spy->clear();

   478         eng.evaluate("eval('function foo() { print(123); }')");

   479 

   480         QEXPECT_FAIL("","QTBUG-6140 Eval is threaded in different way that in old backend", Abort);

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

   482 

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

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

   485 

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

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

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

   489 

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

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

   492     }

   493     delete spy;

   494 }

   495 

   496 void tst_QScriptEngineAgent::contextPushAndPop()

   497 {

   498     QScriptEngine eng;

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

   500                                                        | ScriptEngineSpy::IgnoreContextPop));

   501 

   502     {

   503         spy->clear();

   504         eng.pushContext();

   505         eng.popContext();

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

   507 

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

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

   510     }

   511 }

   512 

   513 static QScriptValue nativeFunctionReturningArg(QScriptContext *ctx, QScriptEngine *)

   514 {

   515     return ctx->argument(0);

   516 }

   517 

   518 static QScriptValue nativeFunctionThrowingError(QScriptContext *ctx, QScriptEngine *)

   519 {

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

   521 }

   522 

   523 static QScriptValue nativeFunctionCallingArg(QScriptContext *ctx, QScriptEngine *)

   524 {

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

   526 }

   527 

   528 /** check behaiviour of ';' */

   529 void tst_QScriptEngineAgent::functionEntryAndExit_semicolon()

   530 {

   531     QScriptEngine eng;

   532     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

   533                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   534     {

   535         spy->clear();

   536         eng.evaluate(";");

   537 

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

   539 

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

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

   542 

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

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

   545         QVERIFY(spy->at(1).value.isUndefined());

   546     }

   547     delete spy;

   548 }

   549 

   550 /** check behaiviour of expression */

   551 void tst_QScriptEngineAgent::functionEntryAndExit_expression()

   552 {

   553     QScriptEngine eng;

   554     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

   555                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   556     {

   557         spy->clear();

   558         eng.evaluate("1 + 2");

   559 

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

   561 

   562         // evaluate() entry

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

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

   565 

   566         // evaluate() exit

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

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

   569         QVERIFY(spy->at(1).value.isNumber());

   570         QCOMPARE(spy->at(1).value.toNumber(), qsreal(3));

   571     }

   572     delete spy;

   573 }

   574 

   575 /** check behaiviour of standard function call */

   576 void tst_QScriptEngineAgent::functionEntryAndExit_functionCall()

   577 {

   578     QScriptEngine eng;

   579     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

   580                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   581     {

   582         spy->clear();

   583         QVERIFY(eng.evaluate("(function() { return 123; } )()").toNumber()==123);

   584 

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

   586 

   587         // evaluate() entry

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

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

   590 

   591         // anonymous function entry

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

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

   594 

   595         // anonymous function exit

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

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

   598         QVERIFY(spy->at(2).value.isNumber());

   599         QCOMPARE(spy->at(2).value.toNumber(), qsreal(123));

   600 

   601         // evaluate() exit

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

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

   604         QVERIFY(spy->at(3).value.isNumber());

   605         QCOMPARE(spy->at(3).value.toNumber(), qsreal(123));

   606     }

   607     delete spy;

   608 }

   609 

   610 /** check behaiviour of standard function call */

   611 void tst_QScriptEngineAgent::functionEntryAndExit_functionCallWithoutReturn()

   612 {

   613     QScriptEngine eng;

   614     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

   615                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   616     {

   617         spy->clear();

   618         eng.evaluate("(function() { var a = 123; } )()");

   619 

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

   621 

   622         // evaluate() entry

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

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

   625 

   626         // anonymous function entry

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

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

   629 

   630         // anonymous function exit

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

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

   633 

   634         // evaluate() exit

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

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

   637     }

   638     delete spy;

   639 }

   640 

   641 /** check behaiviour of function definition */

   642 void tst_QScriptEngineAgent::functionEntryAndExit_functionDefinition()

   643 {

   644     QScriptEngine eng;

   645     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

   646                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   647     {

   648         spy->clear();

   649         eng.evaluate("function foo() { return 456; }");

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

   651 

   652         // evaluate() entry

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

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

   655 

   656         // evaluate() exit

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

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

   659         QVERIFY(spy->at(1).value.isUndefined());

   660 

   661         eng.evaluate("foo()");

   662         QCOMPARE(spy->count(), 6);

   663 

   664         // evaluate() entry

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

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

   667 

   668         // foo() entry

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

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

   671 

   672         // foo() exit

   673         QCOMPARE(spy->at(4).type, ScriptEngineEvent::FunctionExit);

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

   675         QVERIFY(spy->at(4).value.isNumber());

   676         QCOMPARE(spy->at(4).value.toNumber(), qsreal(456));

   677 

   678         // evaluate() exit

   679         QCOMPARE(spy->at(5).type, ScriptEngineEvent::FunctionExit);

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

   681         QVERIFY(spy->at(5).value.isNumber());

   682         QCOMPARE(spy->at(5).value.toNumber(), qsreal(456));

   683     }

   684     delete spy;

   685 }

   686 

   687 /** check behaiviour of native function */

   688 void tst_QScriptEngineAgent::functionEntryAndExit_native()

   689 {

   690     QScriptEngine eng;

   691     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

   692                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   693     // native functions

   694     {

   695         QScriptValue fun = eng.newFunction(nativeFunctionReturningArg);

   696         eng.globalObject().setProperty("nativeFunctionReturningArg", fun);

   697 

   698         spy->clear();

   699         eng.evaluate("nativeFunctionReturningArg(123)");

   700 

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

   702 

   703         // evaluate() entry

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

   705 

   706         // native function entry

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

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

   709 

   710         // native function exit

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

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

   713         QVERIFY(spy->at(2).value.isNumber());

   714         QCOMPARE(spy->at(2).value.toNumber(), qsreal(123));

   715 

   716         // evaluate() exit

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

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

   719         QVERIFY(spy->at(3).value.isNumber());

   720         QCOMPARE(spy->at(3).value.toNumber(), qsreal(123));

   721     }

   722     delete spy;

   723 }

   724 

   725 /** check behaiviour of native function */

   726 void tst_QScriptEngineAgent::functionEntryAndExit_native2()

   727 {

   728     QScriptEngine eng;

   729     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

   730                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   731     {

   732         QScriptValue fun = eng.newFunction(nativeFunctionCallingArg);

   733         eng.globalObject().setProperty("nativeFunctionCallingArg", fun);

   734 

   735         spy->clear();

   736         eng.evaluate("nativeFunctionCallingArg(function() { return 123; })");

   737         QCOMPARE(spy->count(), 6);

   738 

   739         // evaluate() entry

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

   741 

   742         // native function entry

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

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

   745 

   746         // script function entry

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

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

   749 

   750         // script function exit

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

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

   753 

   754         // native function exit

   755         QCOMPARE(spy->at(4).type, ScriptEngineEvent::FunctionExit);

   756         QCOMPARE(spy->at(4).scriptId, qint64(-1));

   757         QVERIFY(spy->at(4).value.isNumber());

   758         QCOMPARE(spy->at(4).value.toNumber(), qsreal(123));

   759 

   760         // evaluate() exit

   761         QCOMPARE(spy->at(5).type, ScriptEngineEvent::FunctionExit);

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

   763         QVERIFY(spy->at(5).value.isNumber());

   764         QCOMPARE(spy->at(5).value.toNumber(), qsreal(123));

   765     }

   766     delete spy;

   767 }

   768 

   769 /** check behaiviour of native function throwing error*/

   770 void tst_QScriptEngineAgent::functionEntryAndExit_nativeThrowing()

   771 {

   772     /* This function was changed from old backend. JSC return more Entrys / Exits, (exactly +1)

   773        in exception creation time */

   774 

   775     QScriptEngine eng;

   776     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

   777                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   778     {

   779         QScriptValue fun = eng.newFunction(nativeFunctionThrowingError);

   780         eng.globalObject().setProperty("nativeFunctionThrowingError", fun);

   781 

   782         spy->clear();

   783         eng.evaluate("nativeFunctionThrowingError('ciao')");

   784         QCOMPARE(spy->count(), 6);

   785 

   786         // evaluate() entry

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

   788 

   789         // native function entry

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

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

   792 

   793         // Exception constructor entry

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

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

   796 

   797         // Exception constructor exit

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

   799         QCOMPARE(spy->at(3).scriptId, qint64(-1));

   800         QVERIFY(spy->at(3).value.isError());

   801 

   802         // native function exit

   803         QCOMPARE(spy->at(4).type, ScriptEngineEvent::FunctionExit);

   804         QCOMPARE(spy->at(4).scriptId, qint64(-1));

   805         QVERIFY(spy->at(4).value.isError());

   806 

   807         // evaluate() exit

   808         QCOMPARE(spy->at(5).type, ScriptEngineEvent::FunctionExit);

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

   810         QVERIFY(spy->at(5).value.isError());

   811     }

   812     delete spy;

   813 }

   814 

   815 void tst_QScriptEngineAgent::functionEntryAndExit_builtin_data()

   816 {

   817   QTest::addColumn<QString>("script");

   818   QTest::addColumn<QString>("result");

   819 

   820   QTest::newRow("string native") << "'ciao'.toString()" << "ciao";

   821   QTest::newRow("string object") << "String('ciao').toString()" << "ciao";

   822   QTest::newRow("number native") << "(123).toString()" << "123";

   823   QTest::newRow("number object") << "Number(123).toString()" << "123";

   824   QTest::newRow("array native") << "['s','a'].toString()" << "s, a";

   825   QTest::newRow("array object") << "Array('s', 'a').toString()" << "s,a";

   826   QTest::newRow("boolean native") << "false.toString()" << "false";

   827   QTest::newRow("boolean object") << "Boolean(true).toString()" << "true";

   828   QTest::newRow("regexp native") << "/a/.toString()" << "/a/";

   829   QTest::newRow("regexp object") << "RegExp('a').toString()" << "/a/";

   830 }

   831 

   832 /** check behaiviour of built-in function */

   833 void tst_QScriptEngineAgent::functionEntryAndExit_builtin()

   834 {

   835     QSKIP("The test fails on platforms others than Linux. The issue will be fixed with next JSC update", SkipAll);

   836     QFETCH(QString, script);

   837     QFETCH(QString, result);

   838     QScriptEngine eng;

   839     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

   840                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   841     {

   842         spy->clear();

   843         eng.evaluate(script);

   844 

   845         if (qt_script_isJITEnabled()) {

   846             QEXPECT_FAIL("string native", "QTBUG-6187 Some events are missing when JIT is enabled", Abort);

   847             QEXPECT_FAIL("number native", "QTBUG-6187 Some events are missing when JIT is enabled", Abort);

   848             QEXPECT_FAIL("array native", "QTBUG-6187 Some events are missing when JIT is enabled", Abort);

   849             QEXPECT_FAIL("boolean native", "QTBUG-6187 Some events are missing when JIT is enabled", Abort);

   850             QEXPECT_FAIL("regexp native", "QTBUG-6187 Some events are missing when JIT is enabled", Abort);

   851         }

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

   853 

   854         // evaluate() entry

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

   856 

   857         // built-in native function entry

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

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

   860 

   861         // built-in native function exit

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

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

   864         QCOMPARE(spy->at(2).value.toString(), QString(result));

   865 

   866         // evaluate() exit

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

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

   869         QVERIFY(spy->at(3).value.isString());

   870         QCOMPARE(spy->at(3).value.toString(), QString(result));

   871     }

   872     delete spy;

   873 }

   874 

   875 /** check behaiviour of object creation*/

   876 void tst_QScriptEngineAgent::functionEntryAndExit_objects()

   877 {

   878     QScriptEngine eng;

   879     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

   880                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   881     {

   882         spy->clear();

   883         eng.evaluate("Array(); Boolean(); Date(); Function(); Number(); Object(); RegExp(); String()");

   884         QCOMPARE(spy->count(), 18);

   885 

   886         // evaluate() entry

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

   888 

   889         // Array constructor entry

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

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

   892 

   893         // Array constructor exit

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

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

   896         QVERIFY(spy->at(2).value.isArray());

   897 

   898         // Boolean constructor entry

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

   900         QCOMPARE(spy->at(3).scriptId, qint64(-1));

   901 

   902         // Boolean constructor exit

   903         QCOMPARE(spy->at(4).type, ScriptEngineEvent::FunctionExit);

   904         QCOMPARE(spy->at(4).scriptId, qint64(-1));

   905         QVERIFY(spy->at(4).value.isBoolean());

   906 

   907         // Date constructor entry

   908         QCOMPARE(spy->at(5).type, ScriptEngineEvent::FunctionEntry);

   909         QCOMPARE(spy->at(5).scriptId, qint64(-1));

   910 

   911         // Date constructor exit

   912         QCOMPARE(spy->at(6).type, ScriptEngineEvent::FunctionExit);

   913         QCOMPARE(spy->at(6).scriptId, qint64(-1));

   914         QVERIFY(spy->at(6).value.isString());

   915 

   916         // Function constructor entry

   917         QCOMPARE(spy->at(7).type, ScriptEngineEvent::FunctionEntry);

   918         QCOMPARE(spy->at(7).scriptId, qint64(-1));

   919 

   920         // Function constructor exit

   921         QCOMPARE(spy->at(8).type, ScriptEngineEvent::FunctionExit);

   922         QCOMPARE(spy->at(8).scriptId, qint64(-1));

   923         QVERIFY(spy->at(8).value.isFunction());

   924 

   925         // Number constructor entry

   926         QCOMPARE(spy->at(9).type, ScriptEngineEvent::FunctionEntry);

   927         QCOMPARE(spy->at(9).scriptId, qint64(-1));

   928 

   929         // Number constructor exit

   930         QCOMPARE(spy->at(10).type, ScriptEngineEvent::FunctionExit);

   931         QCOMPARE(spy->at(10).scriptId, qint64(-1));

   932         QVERIFY(spy->at(10).value.isNumber());

   933 

   934         // Object constructor entry

   935         QCOMPARE(spy->at(11).type, ScriptEngineEvent::FunctionEntry);

   936         QCOMPARE(spy->at(11).scriptId, qint64(-1));

   937 

   938         // Object constructor exit

   939         QCOMPARE(spy->at(12).type, ScriptEngineEvent::FunctionExit);

   940         QCOMPARE(spy->at(12).scriptId, qint64(-1));

   941         QVERIFY(spy->at(12).value.isObject());

   942 

   943         // RegExp constructor entry

   944         QCOMPARE(spy->at(13).type, ScriptEngineEvent::FunctionEntry);

   945         QCOMPARE(spy->at(13).scriptId, qint64(-1));

   946 

   947         // RegExp constructor exit

   948         QCOMPARE(spy->at(14).type, ScriptEngineEvent::FunctionExit);

   949         QCOMPARE(spy->at(14).scriptId, qint64(-1));

   950         QVERIFY(spy->at(14).value.isRegExp());

   951 

   952         // String constructor entry

   953         QCOMPARE(spy->at(15).type, ScriptEngineEvent::FunctionEntry);

   954         QCOMPARE(spy->at(15).scriptId, qint64(-1));

   955 

   956         // String constructor exit

   957         QCOMPARE(spy->at(16).type, ScriptEngineEvent::FunctionExit);

   958         QCOMPARE(spy->at(16).scriptId, qint64(-1));

   959         QVERIFY(spy->at(16).value.isString());

   960 

   961         // evaluate() exit

   962         QCOMPARE(spy->at(17).type, ScriptEngineEvent::FunctionExit);

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

   964         QVERIFY(spy->at(17).value.isString());

   965         QCOMPARE(spy->at(17).value.toString(), QString());

   966     }

   967     delete spy;

   968 }

   969 

   970 /** check behaiviour of slots*/

   971 void tst_QScriptEngineAgent::functionEntryAndExit_slots()

   972 {

   973     QScriptEngine eng;

   974     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

   975                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   976     // slots

   977     {

   978         eng.globalObject().setProperty("qobj", eng.newQObject(this));

   979         spy->clear();

   980         eng.evaluate("qobj.testSlot(123)");

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

   982         // evaluate() entry

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

   984         // testSlot() entry

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

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

   987         // testSlot() exit

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

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

   990         QVERIFY(spy->at(2).value.isNumber());

   991         QCOMPARE(spy->at(2).value.toNumber(), qsreal(123));

   992         // evaluate() exit

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

   994     }

   995     delete spy;

   996 }

   997 

   998 /** check behaiviour of property accessors*/

   999 void tst_QScriptEngineAgent::functionEntryAndExit_property_set()

  1000 {

  1001     QScriptEngine eng;

  1002     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

  1003                                                        | ScriptEngineSpy::IgnoreFunctionExit));

  1004     // property accessors

  1005     {

  1006         eng.globalObject().setProperty("qobj", eng.newQObject(this));

  1007         // set

  1008         spy->clear();

  1009         eng.evaluate("qobj.testProperty = 456");

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

  1011         // evaluate() entry

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

  1013         // setTestProperty() entry

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

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

  1016         // setTestProperty() exit

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

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

  1019         QVERIFY(spy->at(2).value.isNumber());

  1020         QCOMPARE(spy->at(2).value.toNumber(), testProperty());

  1021         // evaluate() exit

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

  1023         QVERIFY(spy->at(3).value.strictlyEquals(spy->at(2).value));

  1024     }

  1025     delete spy;

  1026 }

  1027 

  1028 /** check behaiviour of property accessors*/

  1029 void tst_QScriptEngineAgent::functionEntryAndExit_property_get()

  1030 {

  1031     QScriptEngine eng;

  1032     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

  1033                                                        | ScriptEngineSpy::IgnoreFunctionExit));

  1034     // property accessors

  1035     {

  1036         eng.globalObject().setProperty("qobj", eng.newQObject(this));

  1037         // set

  1038         eng.evaluate("qobj.testProperty = 456");

  1039         // get

  1040         spy->clear();

  1041         eng.evaluate("qobj.testProperty");

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

  1043         // evaluate() entry

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

  1045         // testProperty() entry

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

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

  1048         // testProperty() exit

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

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

  1051         QVERIFY(spy->at(2).value.isNumber());

  1052         QCOMPARE(spy->at(2).value.toNumber(), testProperty());

  1053         // evaluate() exit

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

  1055         QVERIFY(spy->at(3).value.strictlyEquals(spy->at(2).value));

  1056     }

  1057     delete spy;

  1058 }

  1059 

  1060 

  1061 /** check behaiviour of calling script functions from c++*/

  1062 void tst_QScriptEngineAgent::functionEntryAndExit_call()

  1063 {

  1064     QScriptEngine eng;

  1065     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

  1066                                                        | ScriptEngineSpy::IgnoreFunctionExit));

  1067     // calling script functions from C++

  1068 

  1069     {

  1070         QScriptValue fun = eng.evaluate("function foo() { return 123; }; foo");

  1071         QVERIFY(fun.isFunction());

  1072 

  1073         spy->clear();

  1074         fun.call();

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

  1076 

  1077         // entry

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

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

  1080 

  1081         // exit

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

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

  1084         QVERIFY(spy->at(1).value.isNumber());

  1085         QCOMPARE(spy->at(1).value.toNumber(), qsreal(123));

  1086     }

  1087     delete spy;

  1088 }

  1089 

  1090 /** check behaiviour of native function returnning arg*/

  1091 void tst_QScriptEngineAgent::functionEntryAndExit_functionReturn_call()

  1092 {

  1093     QScriptEngine eng;

  1094     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

  1095                                                        | ScriptEngineSpy::IgnoreFunctionExit));

  1096     {

  1097         QScriptValue fun = eng.newFunction(nativeFunctionReturningArg);

  1098 

  1099         spy->clear();

  1100         QScriptValueList args;

  1101         args << QScriptValue(&eng, 123);

  1102         fun.call(QScriptValue(), args);

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

  1104 

  1105         // entry

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

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

  1108 

  1109         // exit

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

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

  1112         QVERIFY(spy->at(1).value.strictlyEquals(args.at(0)));

  1113     }

  1114     delete spy;

  1115 }

  1116 

  1117 void tst_QScriptEngineAgent::functionEntryAndExit_functionReturn_construct()

  1118 {

  1119     QScriptEngine eng;

  1120     ScriptEngineSpy *spy = new ScriptEngineSpy(&eng, ~(ScriptEngineSpy::IgnoreFunctionEntry

  1121                                                        | ScriptEngineSpy::IgnoreFunctionExit));

  1122     {

  1123         QScriptValue fun = eng.newFunction(nativeFunctionReturningArg);

  1124 

  1125         spy->clear();

  1126         QScriptValueList args;

  1127         args << QScriptValue(&eng, 123);

  1128         QScriptValue obj = fun.construct(args);

  1129 

  1130         QVERIFY(args.at(0).isValid());

  1131         QVERIFY(args.at(0).isNumber());

  1132         QVERIFY(args.at(0).toNumber() == 123);

  1133 

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

  1135