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

     2 **

     3 ** Copyright (C) 2009 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 <qscriptvalueiterator.h>

    48 

    49 //TESTED_CLASS=

    50 //TESTED_FILES=

    51 

    52 QT_BEGIN_NAMESPACE

    53 extern bool qt_script_isJITEnabled();

    54 QT_END_NAMESPACE

    55 

    56 class tst_QScriptEngineAgent : public QObject

    57 {

    58     Q_OBJECT

    59     Q_PROPERTY(double testProperty READ testProperty WRITE setTestProperty)

    60 

    61 public:

    62     tst_QScriptEngineAgent();

    63     virtual ~tst_QScriptEngineAgent();

    64 

    65     double testProperty() const { return m_testProperty; }

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

    67 

    68 public slots:

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

    70 

    71 signals:

    72     void testSignal(double arg);

    73 

    74 private slots:

    75     void scriptLoadAndUnload_statement();

    76     void scriptLoadAndUnload();

    77     void scriptLoadAndUnload_eval();

    78     void contextPushAndPop();

    79     void functionEntryAndExit_semicolon();

    80     void functionEntryAndExit_expression();

    81     void functionEntryAndExit_functionCall();

    82     void functionEntryAndExit_functionCallWithoutReturn();

    83     void functionEntryAndExit_functionDefinition();

    84     void functionEntryAndExit_native();

    85     void functionEntryAndExit_native2();

    86     void functionEntryAndExit_nativeThrowing();

    87     void functionEntryAndExit_builtin();

    88     void functionEntryAndExit_objects();

    89     void functionEntryAndExit_slots();

    90     void functionEntryAndExit_property_set();

    91     void functionEntryAndExit_property_get();

    92     void functionEntryAndExit_call();

    93     void functionEntryAndExit_functionReturn_construct();

    94     void functionEntryAndExit_functionReturn_call();

    95     void functionEntryAndExit_objectCall();

    96     void positionChange_1();

    97     void positionChange_2();

    98     void exceptionThrowAndCatch();

    99     void eventOrder_assigment();

   100     void eventOrder_functionDefinition();

   101     void eventOrder_throwError();

   102     void eventOrder_throwAndCatch();

   103     void eventOrder_functions();

   104     void eventOrder_throwCatchFinally();

   105     void eventOrder_signalsHandling();

   106     void recursiveObserve();

   107     void multipleAgents();

   108     void syntaxError();

   109     void extension_invoctaion();

   110     void extension();

   111     void isEvaluatingInExtension();

   112     void hasUncaughtException();

   113 

   114 private:

   115     double m_testProperty;

   116 };

   117 

   118 tst_QScriptEngineAgent::tst_QScriptEngineAgent()

   119 {

   120 }

   121 

   122 tst_QScriptEngineAgent::~tst_QScriptEngineAgent()

   123 {

   124 }

   125 

   126 struct ScriptEngineEvent

   127 {

   128     enum Type {

   129         ScriptLoad,

   130         ScriptUnload,//1

   131         ContextPush,

   132         ContextPop,  //3

   133         FunctionEntry, //4

   134         FunctionExit, //5

   135         PositionChange,

   136         ExceptionThrow,//7

   137         ExceptionCatch,

   138         DebuggerInvocationRequest

   139     };

   140 

   141     Type type;

   142 

   143     qint64 scriptId;

   144     QString script;

   145     QString fileName;

   146     int lineNumber;

   147     int columnNumber;

   148     QScriptValue value;

   149     bool hasExceptionHandler;

   150 

   151     ScriptEngineEvent(qint64 scriptId,

   152                       const QString &script, const QString &fileName,

   153                       int lineNumber)

   154         : type(ScriptLoad), scriptId(scriptId),

   155           script(script), fileName(fileName),

   156           lineNumber(lineNumber)

   157         { }

   158 

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

   160         : type(type), scriptId(scriptId)

   161         { }

   162 

   163     ScriptEngineEvent(Type type, qint64 scriptId,

   164                       const QScriptValue &value)

   165         : type(type), scriptId(scriptId),

   166           value(value)

   167         { }

   168 

   169     ScriptEngineEvent(qint64 scriptId,

   170                       int lineNumber, int columnNumber)

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

   172           lineNumber(lineNumber), columnNumber(columnNumber)

   173         { }

   174 

   175     ScriptEngineEvent(qint64 scriptId,

   176                       const QScriptValue &exception, bool hasHandler)

   177         : type(ExceptionThrow), scriptId(scriptId),

   178           value(exception), hasExceptionHandler(hasHandler)

   179         { }

   180 

   181     static QString typeToQString(Type t)

   182     {

   183         switch (t) {

   184             case ScriptEngineEvent::ScriptLoad: return "ScriptLoad";

   185             case ScriptEngineEvent::ScriptUnload: return "ScriptUnload";

   186             case ScriptEngineEvent::ContextPush: return "ContextPush";

   187             case ScriptEngineEvent::ContextPop: return "ContextPop";

   188             case ScriptEngineEvent::FunctionEntry: return "FunctionEntry";

   189             case ScriptEngineEvent::FunctionExit: return "FunctionExit";

   190             case ScriptEngineEvent::PositionChange: return "PositionChange";

   191             case ScriptEngineEvent::ExceptionThrow: return "ExceptionThrow";

   192             case ScriptEngineEvent::ExceptionCatch: return "ExceptionCatch";

   193             case ScriptEngineEvent::DebuggerInvocationRequest: return "DebuggerInvocationRequest";

   194             }

   195     }

   196 };

   197 

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

   199 {

   200 public:

   201     enum IgnoreFlag {

   202         IgnoreScriptLoad = 0x001,

   203         IgnoreScriptUnload = 0x002,

   204         IgnoreFunctionEntry = 0x004,

   205         IgnoreFunctionExit = 0x008,

   206         IgnorePositionChange = 0x010,

   207         IgnoreExceptionThrow = 0x020,

   208         IgnoreExceptionCatch = 0x040,

   209         IgnoreContextPush = 0x0100,

   210         IgnoreContextPop = 0x0200,

   211         IgnoreDebuggerInvocationRequest = 0x0400

   212     };

   213 

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

   215     ~ScriptEngineSpy();

   216 

   217     void enableIgnoreFlags(int flags)

   218         { m_ignores |= flags; }

   219     void disableIgnoreFlags(int flags)

   220         { m_ignores &= ~flags; }

   221 

   222 protected:

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

   224                     const QString &fileName, int lineNumber);

   225     void scriptUnload(qint64 id);

   226 

   227     void contextPush();

   228     void contextPop();

   229 

   230     void functionEntry(qint64 scriptId);

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

   232 

   233     void positionChange(qint64 scriptId,

   234                         int lineNumber, int columnNumber);

   235 

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

   237                         bool hasHandler);

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

   239 

   240     bool supportsExtension(Extension ext) const;

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

   242 

   243 private:

   244     int m_ignores;

   245 };

   246 

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

   248     : QScriptEngineAgent(engine)

   249 {

   250     m_ignores = ignores;

   251     engine->setAgent(this);

   252 }

   253 

   254 ScriptEngineSpy::~ScriptEngineSpy()

   255 {

   256 }

   257 

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

   259                                  const QString &fileName, int lineNumber)

   260 {

   261     if (!(m_ignores & IgnoreScriptLoad))

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

   263 }

   264 

   265 void ScriptEngineSpy::scriptUnload(qint64 id)

   266 {

   267     if (!(m_ignores & IgnoreScriptUnload))

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

   269 }

   270 

   271 void ScriptEngineSpy::contextPush()

   272 {

   273     if (!(m_ignores & IgnoreContextPush))

   274         append(ScriptEngineEvent(ScriptEngineEvent::ContextPush));

   275 }

   276 

   277 void ScriptEngineSpy::contextPop()

   278 {

   279     if (!(m_ignores & IgnoreContextPop))

   280         append(ScriptEngineEvent(ScriptEngineEvent::ContextPop));

   281 }

   282 

   283 void ScriptEngineSpy::functionEntry(qint64 scriptId)

   284 {

   285     if (!(m_ignores & IgnoreFunctionEntry))

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

   287 }

   288 

   289 void ScriptEngineSpy::functionExit(qint64 scriptId,

   290                                    const QScriptValue &returnValue)

   291 {

   292     if (!(m_ignores & IgnoreFunctionExit))

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

   294 }

   295 

   296 void ScriptEngineSpy::positionChange(qint64 scriptId,

   297                                      int lineNumber, int columnNumber)

   298 {

   299     if (!(m_ignores & IgnorePositionChange))

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

   301 }

   302 

   303 void ScriptEngineSpy::exceptionThrow(qint64 scriptId,

   304                                      const QScriptValue &exception, bool hasHandler)

   305 {

   306     if (!(m_ignores & IgnoreExceptionThrow))

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

   308 }

   309 

   310 void ScriptEngineSpy::exceptionCatch(qint64 scriptId,

   311                                      const QScriptValue &exception)

   312 {

   313     if (!(m_ignores & IgnoreExceptionCatch))

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

   315 }

   316 

   317 bool ScriptEngineSpy::supportsExtension(Extension ext) const

   318 {

   319     if (ext == DebuggerInvocationRequest)

   320         return !(m_ignores & IgnoreDebuggerInvocationRequest);

   321     return false;

   322 }

   323 

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

   325 {

   326     if (ext == DebuggerInvocationRequest) {

   327         QVariantList lst = arg.toList();

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

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

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

   331         ScriptEngineEvent evt(scriptId, lineNumber, columnNumber);

   332         evt.type = ScriptEngineEvent::DebuggerInvocationRequest;

   333         append(evt);

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

   335     }

   336     return QVariant();

   337 }

   338 

   339 void tst_QScriptEngineAgent::scriptLoadAndUnload_statement()

   340 {

   341     QScriptEngine eng;

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

   343                                                        | ScriptEngineSpy::IgnoreScriptUnload));

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

   345     {

   346         spy->clear();

   347         QString code = ";";

   348         QString fileName = "foo.qs";

   349         int lineNumber = 123;

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

   351 

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

   353 

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

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

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

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

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

   359 

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

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

   362     }

   363 

   364     {

   365         spy->clear();

   366         QString code = ";";

   367         QString fileName = "bar.qs";

   368         int lineNumber = 456;

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

   370 

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

   372 

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

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

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

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

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

   378 

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

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

   381     }

   382     delete spy;

   383 }

   384 

   385 void tst_QScriptEngineAgent::scriptLoadAndUnload()

   386 {

   387     QScriptEngine eng;

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

   389                                                        | ScriptEngineSpy::IgnoreScriptUnload));

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

   391     {

   392         spy->clear();

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

   394         QString fileName = "baz.qs";

   395         int lineNumber = 789;

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

   397 

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

   399 

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

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

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

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

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

   405 

   406         code = "foo = null";

   407         eng.evaluate(code);

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

   409 

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

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

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

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

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

   415 

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

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

   418 

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

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

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

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

   423     }

   424 

   425     {

   426         spy->clear();

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

   428         QString fileName = "foo.qs";

   429         int lineNumber = 123;

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

   431 

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

   433 

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

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

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

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

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

   439 

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

   441         eng.evaluate(code);

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

   443 

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

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

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

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

   448 

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

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

   451 

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

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

   454 

   455         code = "bar = null";

   456         eng.evaluate(code);

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

   458 

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

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

   461     }

   462     delete spy;

   463 }

   464 

   465 void tst_QScriptEngineAgent::scriptLoadAndUnload_eval()

   466 {

   467     QScriptEngine eng;

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

   469                                                        | ScriptEngineSpy::IgnoreScriptUnload));

   470     {

   471         spy->clear();

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

   473 

   474         QEXPECT_FAIL("","Eval is threaded in different way that in old backend", Abort);

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

   476 

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

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

   479 

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

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

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

   483 

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

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

   486     }

   487     delete spy;

   488 }

   489 

   490 void tst_QScriptEngineAgent::contextPushAndPop()

   491 {

   492     QScriptEngine eng;

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

   494                                                        | ScriptEngineSpy::IgnoreContextPop));

   495 

   496     {

   497         spy->clear();

   498         eng.pushContext();

   499         eng.popContext();

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

   501 

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

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

   504     }

   505 }

   506 

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

   508 {

   509     return ctx->argument(0);

   510 }

   511 

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

   513 {

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

   515 }

   516 

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

   518 {

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

   520 }

   521 

   522 /** check behaiviour of ';' */

   523 void tst_QScriptEngineAgent::functionEntryAndExit_semicolon()

   524 {

   525     QScriptEngine eng;

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

   527                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   528     {

   529         spy->clear();

   530         eng.evaluate(";");

   531 

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

   533 

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

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

   536 

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

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

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

   540     }

   541     delete spy;

   542 }

   543 

   544 /** check behaiviour of expression */

   545 void tst_QScriptEngineAgent::functionEntryAndExit_expression()

   546 {

   547     QScriptEngine eng;

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

   549                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   550     {

   551         spy->clear();

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

   553 

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

   555 

   556         // evaluate() entry

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

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

   559 

   560         // evaluate() exit

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

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

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

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

   565     }

   566     delete spy;

   567 }

   568 

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

   570 void tst_QScriptEngineAgent::functionEntryAndExit_functionCall()

   571 {

   572     QScriptEngine eng;

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

   574                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   575     {

   576         spy->clear();

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

   578 

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

   580 

   581         // evaluate() entry

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

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

   584 

   585         // anonymous function entry

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

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

   588 

   589         // anonymous function exit

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

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

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

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

   594 

   595         // evaluate() exit

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

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

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

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

   600     }

   601     delete spy;

   602 }

   603 

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

   605 void tst_QScriptEngineAgent::functionEntryAndExit_functionCallWithoutReturn()

   606 {

   607     QScriptEngine eng;

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

   609                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   610     {

   611         spy->clear();

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

   613 

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

   615 

   616         // evaluate() entry

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

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

   619 

   620         // anonymous function entry

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

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

   623 

   624         // anonymous function exit

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

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

   627 

   628         // evaluate() exit

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

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

   631     }

   632     delete spy;

   633 }

   634 

   635 /** check behaiviour of function definition */

   636 void tst_QScriptEngineAgent::functionEntryAndExit_functionDefinition()

   637 {

   638     QScriptEngine eng;

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

   640                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   641     {

   642         spy->clear();

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

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

   645 

   646         // evaluate() entry

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

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

   649 

   650         // evaluate() exit

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

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

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

   654 

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

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

   657 

   658         // evaluate() entry

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

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

   661 

   662         // foo() entry

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

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

   665 

   666         // foo() exit

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

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

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

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

   671 

   672         // evaluate() exit

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

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

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

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

   677     }

   678     delete spy;

   679 }

   680 

   681 /** check behaiviour of native function */

   682 void tst_QScriptEngineAgent::functionEntryAndExit_native()

   683 {

   684     QScriptEngine eng;

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

   686                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   687     // native functions

   688     {

   689         QScriptValue fun = eng.newFunction(nativeFunctionReturningArg);

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

   691 

   692         spy->clear();

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

   694 

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

   696 

   697         // evaluate() entry

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

   699 

   700         // native function entry

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

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

   703 

   704         // native function exit

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

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

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

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

   709 

   710         // evaluate() exit

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

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

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

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

   715     }

   716     delete spy;

   717 }

   718 

   719 /** check behaiviour of native function */

   720 void tst_QScriptEngineAgent::functionEntryAndExit_native2()

   721 {

   722     QScriptEngine eng;

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

   724                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   725     {

   726         QScriptValue fun = eng.newFunction(nativeFunctionCallingArg);

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

   728 

   729         spy->clear();

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

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

   732 

   733         // evaluate() entry

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

   735 

   736         // native function entry

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

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

   739 

   740         // script function entry

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

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

   743 

   744         // script function exit

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

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

   747 

   748         // native function exit

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

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

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

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

   753 

   754         // evaluate() exit

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

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

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

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

   759     }

   760     delete spy;

   761 }

   762 

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

   764 void tst_QScriptEngineAgent::functionEntryAndExit_nativeThrowing()

   765 {

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

   767        in exception creation time */

   768 

   769     QScriptEngine eng;

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

   771                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   772     {

   773         QScriptValue fun = eng.newFunction(nativeFunctionThrowingError);

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

   775 

   776         spy->clear();

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

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

   779 

   780         // evaluate() entry

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

   782 

   783         // native function entry

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

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

   786 

   787         // Exception constructor entry

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

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

   790 

   791         // Exception constructor exit

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

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

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

   795 

   796         // native function exit

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

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

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

   800 

   801         // evaluate() exit

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

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

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

   805     }

   806     delete spy;

   807 }

   808 

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

   810 void tst_QScriptEngineAgent::functionEntryAndExit_builtin()

   811 {

   812     QScriptEngine eng;

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

   814                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   815     {

   816         spy->clear();

   817         eng.evaluate("'ciao'.toString()");

   818 

   819         if (qt_script_isJITEnabled())

   820             QEXPECT_FAIL("", "Some events are missing when JIT is enabled", Abort);

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

   822 

   823         // evaluate() entry

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

   825 

   826         // built-in native function entry

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

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

   829 

   830         // built-in native function exit

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

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

   833         QVERIFY(spy->at(2).value.isString());

   834         QCOMPARE(spy->at(2).value.toString(), QString("ciao"));

   835 

   836         // evaluate() exit

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

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

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

   840         QCOMPARE(spy->at(3).value.toString(), QString("ciao"));

   841     }

   842     delete spy;

   843 }

   844 

   845 /** check behaiviour of object creation*/

   846 void tst_QScriptEngineAgent::functionEntryAndExit_objects()

   847 {

   848     QScriptEngine eng;

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

   850                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   851     {

   852         spy->clear();

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

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

   855 

   856         // evaluate() entry

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

   858 

   859         // Array constructor entry

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

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

   862 

   863         // Array constructor exit

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

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

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

   867 

   868         // Boolean constructor entry

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

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

   871 

   872         // Boolean constructor exit

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

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

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

   876 

   877         // Date constructor entry

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

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

   880 

   881         // Date constructor exit

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

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

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

   885 

   886         // Function constructor entry

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

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

   889 

   890         // Function constructor exit

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

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

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

   894 

   895         // Number constructor entry

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

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

   898 

   899         // Number constructor exit

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

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

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

   903 

   904         // Object constructor entry

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

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

   907 

   908         // Object constructor exit

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

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

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

   912 

   913         // RegExp constructor entry

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

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

   916 

   917         // RegExp constructor exit

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

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

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

   921 

   922         // String constructor entry

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

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

   925 

   926         // String constructor exit

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

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

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

   930 

   931         // evaluate() exit

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

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

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

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

   936     }

   937     delete spy;

   938 }

   939 

   940 /** check behaiviour of slots*/

   941 void tst_QScriptEngineAgent::functionEntryAndExit_slots()

   942 {

   943     QScriptEngine eng;

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

   945                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   946     // slots

   947     {

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

   949         spy->clear();

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

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

   952         // evaluate() entry

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

   954         // testSlot() entry

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

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

   957         // testSlot() exit

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

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

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

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

   962         // evaluate() exit

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

   964     }

   965     delete spy;

   966 }

   967 

   968 /** check behaiviour of property accessors*/

   969 void tst_QScriptEngineAgent::functionEntryAndExit_property_set()

   970 {

   971     QScriptEngine eng;

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

   973                                                        | ScriptEngineSpy::IgnoreFunctionExit));

   974     // property accessors

   975     {

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

   977         // set

   978         spy->clear();

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

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

   981         // evaluate() entry

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

   983         // setTestProperty() entry

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

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

   986         // setTestProperty() exit

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

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

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

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

   991         // evaluate() exit

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

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

   994     }

   995     delete spy;

   996 }

   997 

   998 /** check behaiviour of property accessors*/

   999 void tst_QScriptEngineAgent::functionEntryAndExit_property_get()

  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         eng.evaluate("qobj.testProperty = 456");

  1009         // get

  1010         spy->clear();

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

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

  1013         // evaluate() entry

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

  1015         // testProperty() entry

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

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

  1018         // testProperty() exit

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

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

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

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

  1023         // evaluate() exit

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

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

  1026     }

  1027     delete spy;

  1028 }

  1029 

  1030 

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

  1032 void tst_QScriptEngineAgent::functionEntryAndExit_call()

  1033 {

  1034     QScriptEngine eng;

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

  1036                                                        | ScriptEngineSpy::IgnoreFunctionExit));

  1037     // calling script functions from C++

  1038 

  1039     {

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

  1041         QVERIFY(fun.isFunction());

  1042 

  1043         spy->clear();

  1044         fun.call();

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

  1046 

  1047         // entry

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

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

  1050 

  1051         // exit

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

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

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

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

  1056     }

  1057     delete spy;

  1058 }

  1059 

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

  1061 void tst_QScriptEngineAgent::functionEntryAndExit_functionReturn_call()

  1062 {

  1063     QScriptEngine eng;

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

  1065                                                        | ScriptEngineSpy::IgnoreFunctionExit));

  1066     {

  1067         QScriptValue fun = eng.newFunction(nativeFunctionReturningArg);

  1068 

  1069         spy->clear();

  1070         QScriptValueList args;

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

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

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

  1074 

  1075         // entry

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

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

  1078 

  1079         // exit

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

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

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

  1083     }

  1084     delete spy;

  1085 }

  1086 

  1087 void tst_QScriptEngineAgent::functionEntryAndExit_functionReturn_construct()

  1088 {

  1089     QScriptEngine eng;

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

  1091                                                        | ScriptEngineSpy::IgnoreFunctionExit));

  1092     {

  1093         QScriptValue fun = eng.newFunction(nativeFunctionReturningArg);

  1094 

  1095         spy->clear();

  1096         QScriptValueList args;

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

  1098         QScriptValue obj = fun.construct(args);

  1099 

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

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

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

  1103 

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

  1105 

  1106         // entry

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

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

  1109 

  1110         // exit

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

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

  1113 

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

  1115     }

  1116 

  1117     delete spy;

  1118 }

  1119 

  1120 /** check behaiviour of object creation with args (?)*/

  1121 void tst_QScriptEngineAgent::functionEntryAndExit_objectCall()

  1122 {

  1123     QScriptEngine eng;

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

  1125                                                        | ScriptEngineSpy::IgnoreFunctionExit));

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

  1127         QScriptValue fun = eng.evaluate("Boolean");

  1128 

  1129         QVERIFY(!fun.isError());

  1130 

  1131         spy->clear();

  1132         QScriptValueList args;

  1133         args << QScriptValue(&eng, true);

  1134         if (x)