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 #include "tst_qscriptvalue.h"

    43 

    44 #define DEFINE_TEST_VALUE(expr) m_values.insert(QString::fromLatin1(#expr), expr)

    45 

    46 void tst_QScriptValue::initScriptValues()

    47 {

    48     m_values.clear();

    49     if (engine) 

    50         delete engine;

    51     engine = new QScriptEngine;

    52     DEFINE_TEST_VALUE(QScriptValue());

    53     DEFINE_TEST_VALUE(QScriptValue(QScriptValue::UndefinedValue));

    54     DEFINE_TEST_VALUE(QScriptValue(QScriptValue::NullValue));

    55     DEFINE_TEST_VALUE(QScriptValue(true));

    56     DEFINE_TEST_VALUE(QScriptValue(false));

    57     DEFINE_TEST_VALUE(QScriptValue(int(122)));

    58     DEFINE_TEST_VALUE(QScriptValue(uint(124)));

    59     DEFINE_TEST_VALUE(QScriptValue(0));

    60     DEFINE_TEST_VALUE(QScriptValue(0.0));

    61     DEFINE_TEST_VALUE(QScriptValue(123.0));

    62     DEFINE_TEST_VALUE(QScriptValue(6.37e-8));

    63     DEFINE_TEST_VALUE(QScriptValue(-6.37e-8));

    64     DEFINE_TEST_VALUE(QScriptValue(0x43211234));

    65     DEFINE_TEST_VALUE(QScriptValue(0x10000));

    66     DEFINE_TEST_VALUE(QScriptValue(0x10001));

    67     DEFINE_TEST_VALUE(QScriptValue(qSNaN()));

    68     DEFINE_TEST_VALUE(QScriptValue(qQNaN()));

    69     DEFINE_TEST_VALUE(QScriptValue(qInf()));

    70     DEFINE_TEST_VALUE(QScriptValue(-qInf()));

    71     DEFINE_TEST_VALUE(QScriptValue("NaN"));

    72     DEFINE_TEST_VALUE(QScriptValue("Infinity"));

    73     DEFINE_TEST_VALUE(QScriptValue("-Infinity"));

    74     DEFINE_TEST_VALUE(QScriptValue("ciao"));

    75     DEFINE_TEST_VALUE(QScriptValue(QString::fromLatin1("ciao")));

    76     DEFINE_TEST_VALUE(QScriptValue(QString("")));

    77     DEFINE_TEST_VALUE(QScriptValue(QString()));

    78     DEFINE_TEST_VALUE(QScriptValue(QString("0")));

    79     DEFINE_TEST_VALUE(QScriptValue(QString("123")));

    80     DEFINE_TEST_VALUE(QScriptValue(QString("12.4")));

    81     DEFINE_TEST_VALUE(QScriptValue(0, QScriptValue::UndefinedValue));

    82     DEFINE_TEST_VALUE(QScriptValue(0, QScriptValue::NullValue));

    83     DEFINE_TEST_VALUE(QScriptValue(0, true));

    84     DEFINE_TEST_VALUE(QScriptValue(0, false));

    85     DEFINE_TEST_VALUE(QScriptValue(0, int(122)));

    86     DEFINE_TEST_VALUE(QScriptValue(0, uint(124)));

    87     DEFINE_TEST_VALUE(QScriptValue(0, 0));

    88     DEFINE_TEST_VALUE(QScriptValue(0, 0.0));

    89     DEFINE_TEST_VALUE(QScriptValue(0, 123.0));

    90     DEFINE_TEST_VALUE(QScriptValue(0, 6.37e-8));

    91     DEFINE_TEST_VALUE(QScriptValue(0, -6.37e-8));

    92     DEFINE_TEST_VALUE(QScriptValue(0, 0x43211234));

    93     DEFINE_TEST_VALUE(QScriptValue(0, 0x10000));

    94     DEFINE_TEST_VALUE(QScriptValue(0, 0x10001));

    95     DEFINE_TEST_VALUE(QScriptValue(0, qSNaN()));

    96     DEFINE_TEST_VALUE(QScriptValue(0, qQNaN()));

    97     DEFINE_TEST_VALUE(QScriptValue(0, qInf()));

    98     DEFINE_TEST_VALUE(QScriptValue(0, -qInf()));

    99     DEFINE_TEST_VALUE(QScriptValue(0, "NaN"));

   100     DEFINE_TEST_VALUE(QScriptValue(0, "Infinity"));

   101     DEFINE_TEST_VALUE(QScriptValue(0, "-Infinity"));

   102     DEFINE_TEST_VALUE(QScriptValue(0, "ciao"));

   103     DEFINE_TEST_VALUE(QScriptValue(0, QString::fromLatin1("ciao")));

   104     DEFINE_TEST_VALUE(QScriptValue(0, QString("")));

   105     DEFINE_TEST_VALUE(QScriptValue(0, QString()));

   106     DEFINE_TEST_VALUE(QScriptValue(0, QString("0")));

   107     DEFINE_TEST_VALUE(QScriptValue(0, QString("123")));

   108     DEFINE_TEST_VALUE(QScriptValue(0, QString("12.3")));

   109     DEFINE_TEST_VALUE(QScriptValue(engine, QScriptValue::UndefinedValue));

   110     DEFINE_TEST_VALUE(QScriptValue(engine, QScriptValue::NullValue));

   111     DEFINE_TEST_VALUE(QScriptValue(engine, true));

   112     DEFINE_TEST_VALUE(QScriptValue(engine, false));

   113     DEFINE_TEST_VALUE(QScriptValue(engine, int(122)));

   114     DEFINE_TEST_VALUE(QScriptValue(engine, uint(124)));

   115     DEFINE_TEST_VALUE(QScriptValue(engine, 0));

   116     DEFINE_TEST_VALUE(QScriptValue(engine, 0.0));

   117     DEFINE_TEST_VALUE(QScriptValue(engine, 123.0));

   118     DEFINE_TEST_VALUE(QScriptValue(engine, 6.37e-8));

   119     DEFINE_TEST_VALUE(QScriptValue(engine, -6.37e-8));

   120     DEFINE_TEST_VALUE(QScriptValue(engine, 0x43211234));

   121     DEFINE_TEST_VALUE(QScriptValue(engine, 0x10000));

   122     DEFINE_TEST_VALUE(QScriptValue(engine, 0x10001));

   123     DEFINE_TEST_VALUE(QScriptValue(engine, qSNaN()));

   124     DEFINE_TEST_VALUE(QScriptValue(engine, qQNaN()));

   125     DEFINE_TEST_VALUE(QScriptValue(engine, qInf()));

   126     DEFINE_TEST_VALUE(QScriptValue(engine, -qInf()));

   127     DEFINE_TEST_VALUE(QScriptValue(engine, "NaN"));

   128     DEFINE_TEST_VALUE(QScriptValue(engine, "Infinity"));

   129     DEFINE_TEST_VALUE(QScriptValue(engine, "-Infinity"));

   130     DEFINE_TEST_VALUE(QScriptValue(engine, "ciao"));

   131     DEFINE_TEST_VALUE(QScriptValue(engine, QString::fromLatin1("ciao")));

   132     DEFINE_TEST_VALUE(QScriptValue(engine, QString("")));

   133     DEFINE_TEST_VALUE(QScriptValue(engine, QString()));

   134     DEFINE_TEST_VALUE(QScriptValue(engine, QString("0")));

   135     DEFINE_TEST_VALUE(QScriptValue(engine, QString("123")));

   136     DEFINE_TEST_VALUE(QScriptValue(engine, QString("1.23")));

   137     DEFINE_TEST_VALUE(engine->evaluate("[]"));

   138     DEFINE_TEST_VALUE(engine->evaluate("{}"));

   139     DEFINE_TEST_VALUE(engine->evaluate("Object.prototype"));

   140     DEFINE_TEST_VALUE(engine->evaluate("Date.prototype"));

   141     DEFINE_TEST_VALUE(engine->evaluate("Array.prototype"));

   142     DEFINE_TEST_VALUE(engine->evaluate("Function.prototype"));

   143     DEFINE_TEST_VALUE(engine->evaluate("Error.prototype"));

   144     DEFINE_TEST_VALUE(engine->evaluate("Object"));

   145     DEFINE_TEST_VALUE(engine->evaluate("Array"));

   146     DEFINE_TEST_VALUE(engine->evaluate("Number"));

   147     DEFINE_TEST_VALUE(engine->evaluate("Function"));

   148     DEFINE_TEST_VALUE(engine->evaluate("(function() { return 1; })"));

   149     DEFINE_TEST_VALUE(engine->evaluate("(function() { return 'ciao'; })"));

   150     DEFINE_TEST_VALUE(engine->evaluate("(function() { throw new Error('foo'); })"));

   151     DEFINE_TEST_VALUE(engine->evaluate("/foo/"));

   152     DEFINE_TEST_VALUE(engine->evaluate("new Object()"));

   153     DEFINE_TEST_VALUE(engine->evaluate("new Array()"));

   154     DEFINE_TEST_VALUE(engine->evaluate("new Error()"));

   155     DEFINE_TEST_VALUE(engine->nullValue());

   156     DEFINE_TEST_VALUE(engine->undefinedValue());

   157 }

   158 

   159 

   160 void tst_QScriptValue::isValid_initData()

   161 {

   162     QTest::addColumn<bool>("expected");

   163     initScriptValues();

   164 }

   165 

   166 void tst_QScriptValue::isValid_makeData(const char* expr)

   167 {

   168     static QSet<QString> isValid;

   169     if (isValid.isEmpty()) {

   170         isValid << "QScriptValue(QScriptValue::UndefinedValue)"

   171                 << "QScriptValue(QScriptValue::NullValue)"

   172                 << "QScriptValue(true)"

   173                 << "QScriptValue(false)"

   174                 << "QScriptValue(int(122))"

   175                 << "QScriptValue(uint(124))"

   176                 << "QScriptValue(0)"

   177                 << "QScriptValue(0.0)"

   178                 << "QScriptValue(123.0)"

   179                 << "QScriptValue(6.37e-8)"

   180                 << "QScriptValue(-6.37e-8)"

   181                 << "QScriptValue(0x43211234)"

   182                 << "QScriptValue(0x10000)"

   183                 << "QScriptValue(0x10001)"

   184                 << "QScriptValue(qSNaN())"

   185                 << "QScriptValue(qQNaN())"

   186                 << "QScriptValue(qInf())"

   187                 << "QScriptValue(-qInf())"

   188                 << "QScriptValue(\"NaN\")"

   189                 << "QScriptValue(\"Infinity\")"

   190                 << "QScriptValue(\"-Infinity\")"

   191                 << "QScriptValue(\"ciao\")"

   192                 << "QScriptValue(QString::fromLatin1(\"ciao\"))"

   193                 << "QScriptValue(QString(\"\"))"

   194                 << "QScriptValue(QString())"

   195                 << "QScriptValue(QString(\"0\"))"

   196                 << "QScriptValue(QString(\"123\"))"

   197                 << "QScriptValue(QString(\"12.4\"))"

   198                 << "QScriptValue(0, QScriptValue::UndefinedValue)"

   199                 << "QScriptValue(0, QScriptValue::NullValue)"

   200                 << "QScriptValue(0, true)"

   201                 << "QScriptValue(0, false)"

   202                 << "QScriptValue(0, int(122))"

   203                 << "QScriptValue(0, uint(124))"

   204                 << "QScriptValue(0, 0)"

   205                 << "QScriptValue(0, 0.0)"

   206                 << "QScriptValue(0, 123.0)"

   207                 << "QScriptValue(0, 6.37e-8)"

   208                 << "QScriptValue(0, -6.37e-8)"

   209                 << "QScriptValue(0, 0x43211234)"

   210                 << "QScriptValue(0, 0x10000)"

   211                 << "QScriptValue(0, 0x10001)"

   212                 << "QScriptValue(0, qSNaN())"

   213                 << "QScriptValue(0, qQNaN())"

   214                 << "QScriptValue(0, qInf())"

   215                 << "QScriptValue(0, -qInf())"

   216                 << "QScriptValue(0, \"NaN\")"

   217                 << "QScriptValue(0, \"Infinity\")"

   218                 << "QScriptValue(0, \"-Infinity\")"

   219                 << "QScriptValue(0, \"ciao\")"

   220                 << "QScriptValue(0, QString::fromLatin1(\"ciao\"))"

   221                 << "QScriptValue(0, QString(\"\"))"

   222                 << "QScriptValue(0, QString())"

   223                 << "QScriptValue(0, QString(\"0\"))"

   224                 << "QScriptValue(0, QString(\"123\"))"

   225                 << "QScriptValue(0, QString(\"12.3\"))"

   226                 << "QScriptValue(engine, QScriptValue::UndefinedValue)"

   227                 << "QScriptValue(engine, QScriptValue::NullValue)"

   228                 << "QScriptValue(engine, true)"

   229                 << "QScriptValue(engine, false)"

   230                 << "QScriptValue(engine, int(122))"

   231                 << "QScriptValue(engine, uint(124))"

   232                 << "QScriptValue(engine, 0)"

   233                 << "QScriptValue(engine, 0.0)"

   234                 << "QScriptValue(engine, 123.0)"

   235                 << "QScriptValue(engine, 6.37e-8)"

   236                 << "QScriptValue(engine, -6.37e-8)"

   237                 << "QScriptValue(engine, 0x43211234)"

   238                 << "QScriptValue(engine, 0x10000)"

   239                 << "QScriptValue(engine, 0x10001)"

   240                 << "QScriptValue(engine, qSNaN())"

   241                 << "QScriptValue(engine, qQNaN())"

   242                 << "QScriptValue(engine, qInf())"

   243                 << "QScriptValue(engine, -qInf())"

   244                 << "QScriptValue(engine, \"NaN\")"

   245                 << "QScriptValue(engine, \"Infinity\")"

   246                 << "QScriptValue(engine, \"-Infinity\")"

   247                 << "QScriptValue(engine, \"ciao\")"

   248                 << "QScriptValue(engine, QString::fromLatin1(\"ciao\"))"

   249                 << "QScriptValue(engine, QString(\"\"))"

   250                 << "QScriptValue(engine, QString())"

   251                 << "QScriptValue(engine, QString(\"0\"))"

   252                 << "QScriptValue(engine, QString(\"123\"))"

   253                 << "QScriptValue(engine, QString(\"1.23\"))"

   254                 << "engine->evaluate(\"[]\")"

   255                 << "engine->evaluate(\"{}\")"

   256                 << "engine->evaluate(\"Object.prototype\")"

   257                 << "engine->evaluate(\"Date.prototype\")"

   258                 << "engine->evaluate(\"Array.prototype\")"

   259                 << "engine->evaluate(\"Function.prototype\")"

   260                 << "engine->evaluate(\"Error.prototype\")"

   261                 << "engine->evaluate(\"Object\")"

   262                 << "engine->evaluate(\"Array\")"

   263                 << "engine->evaluate(\"Number\")"

   264                 << "engine->evaluate(\"Function\")"

   265                 << "engine->evaluate(\"(function() { return 1; })\")"

   266                 << "engine->evaluate(\"(function() { return 'ciao'; })\")"

   267                 << "engine->evaluate(\"(function() { throw new Error('foo'); })\")"

   268                 << "engine->evaluate(\"/foo/\")"

   269                 << "engine->evaluate(\"new Object()\")"

   270                 << "engine->evaluate(\"new Array()\")"

   271                 << "engine->evaluate(\"new Error()\")"

   272                 << "engine->nullValue()"

   273                 << "engine->undefinedValue()"

   274                ;

   275     }

   276     newRow(expr) << isValid.contains(expr);

   277 }

   278 

   279 void tst_QScriptValue::isValid_test(const char*, const QScriptValue& value)

   280 {

   281     QFETCH(bool, expected);

   282     QCOMPARE(value.isValid(), expected);

   283 }

   284 

   285 DEFINE_TEST_FUNCTION(isValid)

   286 

   287 

   288 void tst_QScriptValue::isBool_initData()

   289 {

   290     QTest::addColumn<bool>("expected");

   291     initScriptValues();

   292 }

   293 

   294 void tst_QScriptValue::isBool_makeData(const char* expr)

   295 {

   296     static QSet<QString> isBool;

   297     if (isBool.isEmpty()) {

   298         isBool << "QScriptValue(true)"

   299                 << "QScriptValue(false)"

   300                 << "QScriptValue(0, true)"

   301                 << "QScriptValue(0, false)"

   302                 << "QScriptValue(engine, true)"

   303                 << "QScriptValue(engine, false)"

   304                ;

   305     }

   306     newRow(expr) << isBool.contains(expr);

   307 }

   308 

   309 void tst_QScriptValue::isBool_test(const char*, const QScriptValue& value)

   310 {

   311     QFETCH(bool, expected);

   312     QCOMPARE(value.isBool(), expected);

   313 }

   314 

   315 DEFINE_TEST_FUNCTION(isBool)

   316 

   317 

   318 void tst_QScriptValue::isBoolean_initData()

   319 {

   320     QTest::addColumn<bool>("expected");

   321     initScriptValues();

   322 }

   323 

   324 void tst_QScriptValue::isBoolean_makeData(const char* expr)

   325 {

   326     static QSet<QString> isBoolean;

   327     if (isBoolean.isEmpty()) {

   328         isBoolean << "QScriptValue(true)"

   329                 << "QScriptValue(false)"

   330                 << "QScriptValue(0, true)"

   331                 << "QScriptValue(0, false)"

   332                 << "QScriptValue(engine, true)"

   333                 << "QScriptValue(engine, false)"

   334                ;

   335     }

   336     newRow(expr) << isBoolean.contains(expr);

   337 }

   338 

   339 void tst_QScriptValue::isBoolean_test(const char*, const QScriptValue& value)

   340 {

   341     QFETCH(bool, expected);

   342     QCOMPARE(value.isBoolean(), expected);

   343 }

   344 

   345 DEFINE_TEST_FUNCTION(isBoolean)

   346 

   347 

   348 void tst_QScriptValue::isNumber_initData()

   349 {

   350     QTest::addColumn<bool>("expected");

   351     initScriptValues();

   352 }

   353 

   354 void tst_QScriptValue::isNumber_makeData(const char* expr)

   355 {

   356     static QSet<QString> isNumber;

   357     if (isNumber.isEmpty()) {

   358         isNumber << "QScriptValue(int(122))"

   359                 << "QScriptValue(uint(124))"

   360                 << "QScriptValue(0)"

   361                 << "QScriptValue(0.0)"

   362                 << "QScriptValue(123.0)"

   363                 << "QScriptValue(6.37e-8)"

   364                 << "QScriptValue(-6.37e-8)"

   365                 << "QScriptValue(0x43211234)"

   366                 << "QScriptValue(0x10000)"

   367                 << "QScriptValue(0x10001)"

   368                 << "QScriptValue(qSNaN())"

   369                 << "QScriptValue(qQNaN())"

   370                 << "QScriptValue(qInf())"

   371                 << "QScriptValue(-qInf())"

   372                 << "QScriptValue(0, int(122))"

   373                 << "QScriptValue(0, uint(124))"

   374                 << "QScriptValue(0, 0)"

   375                 << "QScriptValue(0, 0.0)"

   376                 << "QScriptValue(0, 123.0)"

   377                 << "QScriptValue(0, 6.37e-8)"

   378                 << "QScriptValue(0, -6.37e-8)"

   379                 << "QScriptValue(0, 0x43211234)"

   380                 << "QScriptValue(0, 0x10000)"

   381                 << "QScriptValue(0, 0x10001)"

   382                 << "QScriptValue(0, qSNaN())"

   383                 << "QScriptValue(0, qQNaN())"

   384                 << "QScriptValue(0, qInf())"

   385                 << "QScriptValue(0, -qInf())"

   386                 << "QScriptValue(engine, int(122))"

   387                 << "QScriptValue(engine, uint(124))"

   388                 << "QScriptValue(engine, 0)"

   389                 << "QScriptValue(engine, 0.0)"

   390                 << "QScriptValue(engine, 123.0)"

   391                 << "QScriptValue(engine, 6.37e-8)"

   392                 << "QScriptValue(engine, -6.37e-8)"

   393                 << "QScriptValue(engine, 0x43211234)"

   394                 << "QScriptValue(engine, 0x10000)"

   395                 << "QScriptValue(engine, 0x10001)"

   396                 << "QScriptValue(engine, qSNaN())"

   397                 << "QScriptValue(engine, qQNaN())"

   398                 << "QScriptValue(engine, qInf())"

   399                 << "QScriptValue(engine, -qInf())"

   400                ;

   401     }

   402     newRow(expr) << isNumber.contains(expr);

   403 }

   404 

   405 void tst_QScriptValue::isNumber_test(const char*, const QScriptValue& value)

   406 {

   407     QFETCH(bool, expected);

   408     QCOMPARE(value.isNumber(), expected);

   409 }

   410 

   411 DEFINE_TEST_FUNCTION(isNumber)

   412 

   413 

   414 void tst_QScriptValue::isFunction_initData()

   415 {

   416     QTest::addColumn<bool>("expected");

   417     initScriptValues();

   418 }

   419 

   420 void tst_QScriptValue::isFunction_makeData(const char* expr)

   421 {

   422     static QSet<QString> isFunction;

   423     if (isFunction.isEmpty()) {

   424         isFunction << "engine->evaluate(\"Function.prototype\")"

   425                 << "engine->evaluate(\"Object\")"

   426                 << "engine->evaluate(\"Array\")"

   427                 << "engine->evaluate(\"Number\")"

   428                 << "engine->evaluate(\"Function\")"

   429                 << "engine->evaluate(\"(function() { return 1; })\")"

   430                 << "engine->evaluate(\"(function() { return 'ciao'; })\")"

   431                 << "engine->evaluate(\"(function() { throw new Error('foo'); })\")"

   432                 << "engine->evaluate(\"/foo/\")"

   433                ;

   434     }

   435     newRow(expr) << isFunction.contains(expr);

   436 }

   437 

   438 void tst_QScriptValue::isFunction_test(const char*, const QScriptValue& value)

   439 {

   440     QFETCH(bool, expected);

   441     QCOMPARE(value.isFunction(), expected);

   442 }

   443 

   444 DEFINE_TEST_FUNCTION(isFunction)

   445 

   446 

   447 void tst_QScriptValue::isNull_initData()

   448 {

   449     QTest::addColumn<bool>("expected");

   450     initScriptValues();

   451 }

   452 

   453 void tst_QScriptValue::isNull_makeData(const char* expr)

   454 {

   455     static QSet<QString> isNull;

   456     if (isNull.isEmpty()) {

   457         isNull << "QScriptValue(QScriptValue::NullValue)"

   458                 << "QScriptValue(0, QScriptValue::NullValue)"

   459                 << "QScriptValue(engine, QScriptValue::NullValue)"

   460                 << "engine->nullValue()"

   461                ;

   462     }

   463     newRow(expr) << isNull.contains(expr);

   464 }

   465 

   466 void tst_QScriptValue::isNull_test(const char*, const QScriptValue& value)

   467 {

   468     QFETCH(bool, expected);

   469     QCOMPARE(value.isNull(), expected);

   470 }

   471 

   472 DEFINE_TEST_FUNCTION(isNull)

   473 

   474 

   475 void tst_QScriptValue::isString_initData()

   476 {

   477     QTest::addColumn<bool>("expected");

   478     initScriptValues();

   479 }

   480 

   481 void tst_QScriptValue::isString_makeData(const char* expr)

   482 {

   483     static QSet<QString> isString;

   484     if (isString.isEmpty()) {

   485         isString << "QScriptValue(\"NaN\")"

   486                 << "QScriptValue(\"Infinity\")"

   487                 << "QScriptValue(\"-Infinity\")"

   488                 << "QScriptValue(\"ciao\")"

   489                 << "QScriptValue(QString::fromLatin1(\"ciao\"))"

   490                 << "QScriptValue(QString(\"\"))"

   491                 << "QScriptValue(QString())"

   492                 << "QScriptValue(QString(\"0\"))"

   493                 << "QScriptValue(QString(\"123\"))"

   494                 << "QScriptValue(QString(\"12.4\"))"

   495                 << "QScriptValue(0, \"NaN\")"

   496                 << "QScriptValue(0, \"Infinity\")"

   497                 << "QScriptValue(0, \"-Infinity\")"

   498                 << "QScriptValue(0, \"ciao\")"

   499                 << "QScriptValue(0, QString::fromLatin1(\"ciao\"))"

   500                 << "QScriptValue(0, QString(\"\"))"

   501                 << "QScriptValue(0, QString())"

   502                 << "QScriptValue(0, QString(\"0\"))"

   503                 << "QScriptValue(0, QString(\"123\"))"

   504                 << "QScriptValue(0, QString(\"12.3\"))"

   505                 << "QScriptValue(engine, \"NaN\")"

   506                 << "QScriptValue(engine, \"Infinity\")"

   507                 << "QScriptValue(engine, \"-Infinity\")"

   508                 << "QScriptValue(engine, \"ciao\")"

   509                 << "QScriptValue(engine, QString::fromLatin1(\"ciao\"))"

   510                 << "QScriptValue(engine, QString(\"\"))"

   511                 << "QScriptValue(engine, QString())"

   512                 << "QScriptValue(engine, QString(\"0\"))"

   513                 << "QScriptValue(engine, QString(\"123\"))"

   514                 << "QScriptValue(engine, QString(\"1.23\"))"

   515                ;

   516     }

   517     newRow(expr) << isString.contains(expr);

   518 }

   519 

   520 void tst_QScriptValue::isString_test(const char*, const QScriptValue& value)

   521 {

   522     QFETCH(bool, expected);

   523     QCOMPARE(value.isString(), expected);

   524 }

   525 

   526 DEFINE_TEST_FUNCTION(isString)

   527 

   528 

   529 void tst_QScriptValue::isUndefined_initData()

   530 {

   531     QTest::addColumn<bool>("expected");

   532     initScriptValues();

   533 }

   534 

   535 void tst_QScriptValue::isUndefined_makeData(const char* expr)

   536 {

   537     static QSet<QString> isUndefined;

   538     if (isUndefined.isEmpty()) {

   539         isUndefined << "QScriptValue(QScriptValue::UndefinedValue)"

   540                 << "QScriptValue(0, QScriptValue::UndefinedValue)"

   541                 << "QScriptValue(engine, QScriptValue::UndefinedValue)"

   542                 << "engine->evaluate(\"{}\")"

   543                 << "engine->undefinedValue()"

   544                ;

   545     }

   546     newRow(expr) << isUndefined.contains(expr);

   547 }

   548 

   549 void tst_QScriptValue::isUndefined_test(const char*, const QScriptValue& value)

   550 {

   551     QFETCH(bool, expected);

   552     QCOMPARE(value.isUndefined(), expected);

   553 }

   554 

   555 DEFINE_TEST_FUNCTION(isUndefined)

   556 

   557 

   558 

   559 

   560 

   561 void tst_QScriptValue::isObject_initData()

   562 {

   563     QTest::addColumn<bool>("expected");

   564     initScriptValues();

   565 }

   566 

   567 void tst_QScriptValue::isObject_makeData(const char* expr)

   568 {

   569     static QSet<QString> isObject;

   570     if (isObject.isEmpty()) {

   571         isObject << "engine->evaluate(\"[]\")"

   572                 << "engine->evaluate(\"Object.prototype\")"

   573                 << "engine->evaluate(\"Date.prototype\")"

   574                 << "engine->evaluate(\"Array.prototype\")"

   575                 << "engine->evaluate(\"Function.prototype\")"

   576                 << "engine->evaluate(\"Error.prototype\")"

   577                 << "engine->evaluate(\"Object\")"

   578                 << "engine->evaluate(\"Array\")"

   579                 << "engine->evaluate(\"Number\")"

   580                 << "engine->evaluate(\"Function\")"

   581                 << "engine->evaluate(\"(function() { return 1; })\")"

   582                 << "engine->evaluate(\"(function() { return 'ciao'; })\")"

   583                 << "engine->evaluate(\"(function() { throw new Error('foo'); })\")"

   584                 << "engine->evaluate(\"/foo/\")"

   585                 << "engine->evaluate(\"new Object()\")"

   586                 << "engine->evaluate(\"new Array()\")"

   587                 << "engine->evaluate(\"new Error()\")"

   588                ;

   589     }

   590     newRow(expr) << isObject.contains(expr);

   591 }

   592 

   593 void tst_QScriptValue::isObject_test(const char*, const QScriptValue& value)

   594 {

   595     QFETCH(bool, expected);

   596     QCOMPARE(value.isObject(), expected);

   597 }

   598 

   599 DEFINE_TEST_FUNCTION(isObject)

   600 

   601 

   602 void tst_QScriptValue::isDate_initData()

   603 {

   604     QTest::addColumn<bool>("expected");

   605     initScriptValues();

   606 }

   607 

   608 void tst_QScriptValue::isDate_makeData(const char* expr)

   609 {

   610     static QSet<QString> isDate;

   611     if (isDate.isEmpty()) {

   612         isDate << "engine->evaluate(\"Date.prototype\")"

   613                ;

   614     }

   615     newRow(expr) << isDate.contains(expr);

   616 }

   617 

   618 void tst_QScriptValue::isDate_test(const char*, const QScriptValue& value)

   619 {

   620     QFETCH(bool, expected);

   621     QCOMPARE(value.isDate(), expected);

   622 }

   623 

   624 DEFINE_TEST_FUNCTION(isDate)

   625 

   626 

   627 void tst_QScriptValue::isRegExp_initData()

   628 {

   629     QTest::addColumn<bool>("expected");

   630     initScriptValues();

   631 }

   632 

   633 void tst_QScriptValue::isRegExp_makeData(const char* expr)

   634 {

   635     static QSet<QString> isRegExp;

   636     if (isRegExp.isEmpty()) {

   637         isRegExp << "engine->evaluate(\"/foo/\")"

   638                ;

   639     }

   640     newRow(expr) << isRegExp.contains(expr);

   641 }

   642 

   643 void tst_QScriptValue::isRegExp_test(const char*, const QScriptValue& value)

   644 {

   645     QFETCH(bool, expected);

   646     QCOMPARE(value.isRegExp(), expected);

   647 }

   648 

   649 DEFINE_TEST_FUNCTION(isRegExp)

   650 

   651 

   652 void tst_QScriptValue::isArray_initData()

   653 {

   654     QTest::addColumn<bool>("expected");

   655     initScriptValues();

   656 }

   657 

   658 void tst_QScriptValue::isArray_makeData(const char* expr)

   659 {

   660     static QSet<QString> isArray;

   661     if (isArray.isEmpty()) {

   662         isArray << "engine->evaluate(\"[]\")"

   663                 << "engine->evaluate(\"Array.prototype\")"

   664                 << "engine->evaluate(\"new Array()\")"

   665                ;

   666     }

   667     newRow(expr) << isArray.contains(expr);

   668 }

   669 

   670 void tst_QScriptValue::isArray_test(const char*, const QScriptValue& value)

   671 {

   672     QFETCH(bool, expected);

   673     QCOMPARE(value.isArray(), expected);

   674 }

   675 

   676 DEFINE_TEST_FUNCTION(isArray)

   677 

   678 

   679 void tst_QScriptValue::isError_initData()

   680 {

   681     QTest::addColumn<bool>("expected");

   682     initScriptValues();

   683 }

   684 

   685 void tst_QScriptValue::isError_makeData(const char* expr)

   686 {

   687     static QSet<QString> isError;

   688     if (isError.isEmpty()) {

   689         isError << "engine->evaluate(\"Error.prototype\")"

   690                 << "engine->evaluate(\"new Error()\")"

   691                ;

   692     }

   693     newRow(expr) << isError.contains(expr);

   694 }

   695 

   696 void tst_QScriptValue::isError_test(const char*, const QScriptValue& value)

   697 {

   698     QFETCH(bool, expected);

   699     QCOMPARE(value.isError(), expected);

   700 }

   701 

   702 DEFINE_TEST_FUNCTION(isError)

   703 

   704 

   705 

   706 void tst_QScriptValue::toString_initData()

   707 {

   708     QTest::addColumn<QString>("expected");

   709     initScriptValues();

   710 }

   711 

   712 void tst_QScriptValue::toString_makeData(const char* expr)

   713 {

   714     static QHash<QString, QString> toString;

   715     if (toString.isEmpty()) {

   716         toString.insert("QScriptValue()", "");

   717         toString.insert("QScriptValue(QScriptValue::UndefinedValue)", "undefined");

   718         toString.insert("QScriptValue(QScriptValue::NullValue)", "null");

   719         toString.insert("QScriptValue(true)", "true");

   720         toString.insert("QScriptValue(false)", "false");

   721         toString.insert("QScriptValue(int(122))", "122");

   722         toString.insert("QScriptValue(uint(124))", "124");

   723         toString.insert("QScriptValue(0)", "0");

   724         toString.insert("QScriptValue(0.0)", "0");

   725         toString.insert("QScriptValue(123.0)", "123");

   726         toString.insert("QScriptValue(6.37e-8)", "6.37e-8");

   727         toString.insert("QScriptValue(-6.37e-8)", "-6.37e-8");

   728         toString.insert("QScriptValue(0x43211234)", "1126240820");

   729         toString.insert("QScriptValue(0x10000)", "65536");

   730         toString.insert("QScriptValue(0x10001)", "65537");

   731         toString.insert("QScriptValue(qSNaN())", "NaN");

   732         toString.insert("QScriptValue(qQNaN())", "NaN");

   733         toString.insert("QScriptValue(qInf())", "Infinity");

   734         toString.insert("QScriptValue(-qInf())", "-Infinity");

   735         toString.insert("QScriptValue(\"NaN\")", "NaN");

   736         toString.insert("QScriptValue(\"Infinity\")", "Infinity");

   737         toString.insert("QScriptValue(\"-Infinity\")", "-Infinity");

   738         toString.insert("QScriptValue(\"ciao\")", "ciao");

   739         toString.insert("QScriptValue(QString::fromLatin1(\"ciao\"))", "ciao");

   740         toString.insert("QScriptValue(QString(\"\"))", "");

   741         toString.insert("QScriptValue(QString())", "");

   742         toString.insert("QScriptValue(QString(\"0\"))", "0");

   743         toString.insert("QScriptValue(QString(\"123\"))", "123");

   744         toString.insert("QScriptValue(QString(\"12.4\"))", "12.4");

   745         toString.insert("QScriptValue(0, QScriptValue::UndefinedValue)", "undefined");

   746         toString.insert("QScriptValue(0, QScriptValue::NullValue)", "null");

   747         toString.insert("QScriptValue(0, true)", "true");

   748         toString.insert("QScriptValue(0, false)", "false");

   749         toString.insert("QScriptValue(0, int(122))", "122");

   750         toString.insert("QScriptValue(0, uint(124))", "124");

   751         toString.insert("QScriptValue(0, 0)", "0");

   752         toString.insert("QScriptValue(0, 0.0)", "0");

   753         toString.insert("QScriptValue(0, 123.0)", "123");

   754         toString.insert("QScriptValue(0, 6.37e-8)", "6.37e-8");

   755         toString.insert("QScriptValue(0, -6.37e-8)", "-6.37e-8");

   756         toString.insert("QScriptValue(0, 0x43211234)", "1126240820");

   757         toString.insert("QScriptValue(0, 0x10000)", "65536");

   758         toString.insert("QScriptValue(0, 0x10001)", "65537");

   759         toString.insert("QScriptValue(0, qSNaN())", "NaN");

   760         toString.insert("QScriptValue(0, qQNaN())", "NaN");

   761         toString.insert("QScriptValue(0, qInf())", "Infinity");

   762         toString.insert("QScriptValue(0, -qInf())", "-Infinity");

   763         toString.insert("QScriptValue(0, \"NaN\")", "NaN");

   764         toString.insert("QScriptValue(0, \"Infinity\")", "Infinity");

   765         toString.insert("QScriptValue(0, \"-Infinity\")", "-Infinity");

   766         toString.insert("QScriptValue(0, \"ciao\")", "ciao");

   767         toString.insert("QScriptValue(0, QString::fromLatin1(\"ciao\"))", "ciao");

   768         toString.insert("QScriptValue(0, QString(\"\"))", "");

   769         toString.insert("QScriptValue(0, QString())", "");

   770         toString.insert("QScriptValue(0, QString(\"0\"))", "0");

   771         toString.insert("QScriptValue(0, QString(\"123\"))", "123");

   772         toString.insert("QScriptValue(0, QString(\"12.3\"))", "12.3");

   773         toString.insert("QScriptValue(engine, QScriptValue::UndefinedValue)", "undefined");

   774         toString.insert("QScriptValue(engine, QScriptValue::NullValue)", "null");

   775         toString.insert("QScriptValue(engine, true)", "true");

   776         toString.insert("QScriptValue(engine, false)", "false");

   777         toString.insert("QScriptValue(engine, int(122))", "122");

   778         toString.insert("QScriptValue(engine, uint(124))", "124");

   779         toString.insert("QScriptValue(engine, 0)", "0");

   780         toString.insert("QScriptValue(engine, 0.0)", "0");

   781         toString.insert("QScriptValue(engine, 123.0)", "123");

   782         toString.insert("QScriptValue(engine, 6.37e-8)", "6.37e-8");

   783         toString.insert("QScriptValue(engine, -6.37e-8)", "-6.37e-8");

   784         toString.insert("QScriptValue(engine, 0x43211234)", "1126240820");

   785         toString.insert("QScriptValue(engine, 0x10000)", "65536");

   786         toString.insert("QScriptValue(engine, 0x10001)", "65537");

   787         toString.insert("QScriptValue(engine, qSNaN())", "NaN");

   788         toString.insert("QScriptValue(engine, qQNaN())", "NaN");

   789         toString.insert("QScriptValue(engine, qInf())", "Infinity");

   790         toString.insert("QScriptValue(engine, -qInf())", "-Infinity");

   791         toString.insert("QScriptValue(engine, \"NaN\")", "NaN");

   792         toString.insert("QScriptValue(engine, \"Infinity\")", "Infinity");

   793         toString.insert("QScriptValue(engine, \"-Infinity\")", "-Infinity");

   794         toString.insert("QScriptValue(engine, \"ciao\")", "ciao");

   795         toString.insert("QScriptValue(engine, QString::fromLatin1(\"ciao\"))", "ciao");

   796         toString.insert("QScriptValue(engine, QString(\"\"))", "");

   797         toString.insert("QScriptValue(engine, QString())", "");

   798         toString.insert("QScriptValue(engine, QString(\"0\"))", "0");

   799         toString.insert("QScriptValue(engine, QString(\"123\"))", "123");

   800         toString.insert("QScriptValue(engine, QString(\"1.23\"))", "1.23");

   801         toString.insert("engine->evaluate(\"[]\")", "");

   802         toString.insert("engine->evaluate(\"{}\")", "undefined");

   803         toString.insert("engine->evaluate(\"Object.prototype\")", "[object Object]");

   804         toString.insert("engine->evaluate(\"Date.prototype\")", "Invalid Date");

   805         toString.insert("engine->evaluate(\"Array.prototype\")", "");

   806         toString.insert("engine->evaluate(\"Function.prototype\")", "function () {\n    [native code]\n}");

   807         toString.insert("engine->evaluate(\"Error.prototype\")", "Error: Unknown error");

   808         toString.insert("engine->evaluate(\"Object\")", "function Object() {\n    [native code]\n}");

   809         toString.insert("engine->evaluate(\"Array\")", "function Array() {\n    [native code]\n}");

   810         toString.insert("engine->evaluate(\"Number\")", "function Number() {\n    [native code]\n}");

   811         toString.insert("engine->evaluate(\"Function\")", "function Function() {\n    [native code]\n}");

   812         toString.insert("engine->evaluate(\"(function() { return 1; })\")", "function () { return 1; }");

   813         toString.insert("engine->evaluate(\"(function() { return 'ciao'; })\")", "function () { return 'ciao'; }");

   814         toString.insert("engine->evaluate(\"(function() { throw new Error('foo'); })\")", "function () { throw new Error('foo'); }");

   815         toString.insert("engine->evaluate(\"/foo/\")", "/foo/");

   816         toString.insert("engine->evaluate(\"new Object()\")", "[object Object]");

   817         toString.insert("engine->evaluate(\"new Array()\")", "");

   818         toString.insert("engine->evaluate(\"new Error()\")", "Error: Unknown error");

   819         toString.insert("engine->nullValue()", "null");

   820         toString.insert("engine->undefinedValue()", "undefined");

   821     }

   822     newRow(expr) << toString.value(expr);

   823 }

   824 

   825 void tst_QScriptValue::toString_test(const char*, const QScriptValue& value)

   826 {

   827     QFETCH(QString, expected);

   828     QCOMPARE(value.toString(), expected);

   829 }

   830 

   831 DEFINE_TEST_FUNCTION(toString)

   832 

   833 

   834 void tst_QScriptValue::toNumber_initData()

   835 {

   836     QTest::addColumn<qsreal>("expected");

   837     initScriptValues();

   838 }

   839 

   840 void tst_QScriptValue::toNumber_makeData(const char* expr)

   841 {

   842     static QHash<QString, qsreal> toNumber;

   843     if (toNumber.isEmpty()) {

   844         toNumber.insert("QScriptValue()", 0);

   845         toNumber.insert("QScriptValue(QScriptValue::UndefinedValue)", qQNaN());

   846         toNumber.insert("QScriptValue(QScriptValue::NullValue)", 0);

   847         toNumber.insert("QScriptValue(true)", 1);

   848         toNumber.insert("QScriptValue(false)", 0);

   849         toNumber.insert("QScriptValue(int(122))", 122);

   850         toNumber.insert("QScriptValue(uint(124))", 124);

   851         toNumber.insert("QScriptValue(0)", 0);

   852         toNumber.insert("QScriptValue(0.0)", 0);

   853         toNumber.insert("QScriptValue(123.0)", 123);

   854         toNumber.insert("QScriptValue(6.37e-8)", 6.369999999999999e-08);

   855         toNumber.insert("QScriptValue(-6.37e-8)", -6.369999999999999e-08);

   856         toNumber.insert("QScriptValue(0x43211234)", 1126240820);

   857         toNumber.insert("QScriptValue(0x10000)", 65536);

   858         toNumber.insert("QScriptValue(0x10001)", 65537);

   859         toNumber.insert("QScriptValue(qSNaN())", qQNaN());

   860         toNumber.insert("QScriptValue(qQNaN())", qQNaN());

   861         toNumber.insert("QScriptValue(qInf())", qInf());

   862         toNumber.insert("QScriptValue(-qInf())", qInf());

   863         toNumber.insert("QScriptValue(\"NaN\")", qQNaN());

   864         toNumber.insert("QScriptValue(\"Infinity\")", qInf());

   865         toNumber.insert("QScriptValue(\"-Infinity\")", qInf());

   866         toNumber.insert("QScriptValue(\"ciao\")", qQNaN());

   867         toNumber.insert("QScriptValue(QString::fromLatin1(\"ciao\"))", qQNaN());

   868         toNumber.insert("QScriptValue(QString(\"\"))", 0);

   869         toNumber.insert("QScriptValue(QString())", 0);

   870         toNumber.insert("QScriptValue(QString(\"0\"))", 0);

   871         toNumber.insert("QScriptValue(QString(\"123\"))", 123);

   872         toNumber.insert("QScriptValue(QString(\"12.4\"))", 12.4);

   873         toNumber.insert("QScriptValue(0, QScriptValue::UndefinedValue)", qQNaN());

   874         toNumber.insert("QScriptValue(0, QScriptValue::NullValue)", 0);

   875         toNumber.insert("QScriptValue(0, true)", 1);

   876         toNumber.insert("QScriptValue(0, false)", 0);

   877         toNumber.insert("QScriptValue(0, int(122))", 122);

   878         toNumber.insert("QScriptValue(0, uint(124))", 124);

   879         toNumber.insert("QScriptValue(0, 0)", 0);

   880         toNumber.insert("QScriptValue(0, 0.0)", 0);

   881         toNumber.insert("QScriptValue(0, 123.0)", 123);

   882         toNumber.insert("QScriptValue(0, 6.37e-8)", 6.369999999999999e-08);

   883         toNumber.insert("QScriptValue(0, -6.37e-8)", -6.369999999999999e-08);

   884         toNumber.insert("QScriptValue(0, 0x43211234)", 1126240820);

   885         toNumber.insert("QScriptValue(0, 0x10000)", 65536);

   886         toNumber.insert("QScriptValue(0, 0x10001)", 65537);

   887         toNumber.insert("QScriptValue(0, qSNaN())", qQNaN());

   888         toNumber.insert("QScriptValue(0, qQNaN())", qQNaN());

   889         toNumber.insert("QScriptValue(0, qInf())", qInf());

   890         toNumber.insert("QScriptValue(0, -qInf())", qInf());

   891         toNumber.insert("QScriptValue(0, \"NaN\")", qQNaN());

   892         toNumber.insert("QScriptValue(0, \"Infinity\")", qInf());

   893         toNumber.insert("QScriptValue(0, \"-Infinity\")", qInf());

   894         toNumber.insert("QScriptValue(0, \"ciao\")", qQNaN());

   895         toNumber.insert("QScriptValue(0, QString::fromLatin1(\"ciao\"))", qQNaN());

   896         toNumber.insert("QScriptValue(0, QString(\"\"))", 0);

   897         toNumber.insert("QScriptValue(0, QString())", 0);

   898         toNumber.insert("QScriptValue(0, QString(\"0\"))", 0);

   899         toNumber.insert("QScriptValue(0, QString(\"123\"))", 123);

   900         toNumber.insert("QScriptValue(0, QString(\"12.3\"))", 12.3);

   901         toNumber.insert("QScriptValue(engine, QScriptValue::UndefinedValue)", qQNaN());

   902         toNumber.insert("QScriptValue(engine, QScriptValue::NullValue)", 0);

   903         toNumber.insert("QScriptValue(engine, true)", 1);

   904         toNumber.insert("QScriptValue(engine, false)", 0);

   905         toNumber.insert("QScriptValue(engine, int(122))", 122);

   906         toNumber.insert("QScriptValue(engine, uint(124))", 124);

   907         toNumber.insert("QScriptValue(engine, 0)", 0);

   908         toNumber.insert("QScriptValue(engine, 0.0)", 0);

   909         toNumber.insert("QScriptValue(engine, 123.0)", 123);

   910         toNumber.insert("QScriptValue(engine, 6.37e-8)", 6.369999999999999e-08);

   911         toNumber.insert("QScriptValue(engine, -6.37e-8)", -6.369999999999999e-08);

   912         toNumber.insert("QScriptValue(engine, 0x43211234)", 1126240820);

   913         toNumber.insert("QScriptValue(engine, 0x10000)", 65536);

   914         toNumber.insert("QScriptValue(engine, 0x10001)", 65537);

   915         toNumber.insert("QScriptValue(engine, qSNaN())", qQNaN());

   916         toNumber.insert("QScriptValue(engine, qQNaN())", qQNaN());

   917         toNumber.insert("QScriptValue(engine, qInf())", qInf());

   918         toNumber.insert("QScriptValue(engine, -qInf())", qInf());

   919         toNumber.insert("QScriptValue(engine, \"NaN\")", qQNaN());

   920         toNumber.insert("QScriptValue(engine, \"Infinity\")", qInf());

   921         toNumber.insert("QScriptValue(engine, \"-Infinity\")", qInf());

   922         toNumber.insert("QScriptValue(engine, \"ciao\")", qQNaN());

   923         toNumber.insert("QScriptValue(engine, QString::fromLatin1(\"ciao\"))", qQNaN());

   924         toNumber.insert("QScriptValue(engine, QString(\"\"))", 0);

   925         toNumber.insert("QScriptValue(engine, QString())", 0);

   926         toNumber.insert("QScriptValue(engine, QString(\"0\"))", 0);

   927         toNumber.insert("QScriptValue(engine, QString(\"123\"))", 123);

   928         toNumber.insert("QScriptValue(engine, QString(\"1.23\"))", 1.23);

   929         toNumber.insert("engine->evaluate(\"[]\")", 0);

   930         toNumber.insert("engine->evaluate(\"{}\")", qQNaN());

   931         toNumber.insert("engine->evaluate(\"Object.prototype\")", qQNaN());

   932         toNumber.insert("engine->evaluate(\"Date.prototype\")", qQNaN());

   933         toNumber.insert("engine->evaluate(\"Array.prototype\")", 0);

   934         toNumber.insert("engine->evaluate(\"Function.prototype\")", qQNaN());

   935         toNumber.insert("engine->evaluate(\"Error.prototype\")", qQNaN());

   936         toNumber.insert("engine->evaluate(\"Object\")", qQNaN());

   937         toNumber.insert("engine->evaluate(\"Array\")", qQNaN());

   938         toNumber.insert("engine->evaluate(\"Number\")", qQNaN());

   939         toNumber.insert("engine->evaluate(\"Function\")", qQNaN());

   940         toNumber.insert("engine->evaluate(\"(function() { return 1; })\")", qQNaN());

   941         toNumber.insert("engine->evaluate(\"(function() { return 'ciao'; })\")", qQNaN());

   942         toNumber.insert("engine->evaluate(\"(function() { throw new Error('foo'); })\")", qQNaN());

   943         toNumber.insert("engine->evaluate(\"/foo/\")", qQNaN());

   944         toNumber.insert("engine->evaluate(\"new Object()\")", qQNaN());

   945         toNumber.insert("engine->evaluate(\"new Array()\")", 0);

   946         toNumber.insert("engine->evaluate(\"new Error()\")", qQNaN());

   947         toNumber.insert("engine->nullValue()", 0);

   948         toNumber.insert("engine->undefinedValue()", qQNaN());

   949     }

   950     newRow(expr) << toNumber.value(expr);

   951 }

   952 

   953 void tst_QScriptValue::toNumber_test(const char*, const QScriptValue& value)

   954 {

   955     QFETCH(qsreal, expected);

   956     if (qIsNaN(expected)) {

   957         QVERIFY(qIsNaN(value.toNumber()));

   958         return;

   959     }

   960     if (qIsInf(expected)) {

   961         QVERIFY(qIsInf(value.toNumber()));

   962         return;

   963     }

   964     QCOMPARE(value.toNumber(), expected);

   965 }

   966 

   967 DEFINE_TEST_FUNCTION(toNumber)

   968 

   969 

   970 void tst_QScriptValue::toBool_initData()

   971 {

   972     QTest::addColumn<bool>("expected");

   973     initScriptValues();

   974 }

   975 

   976 void tst_QScriptValue::toBool_makeData(const char* expr)

   977 {

   978     static QHash<QString, bool> toBool;

   979     if (toBool.isEmpty()) {

   980         toBool.insert("QScriptValue()", false);

   981         toBool.insert("QScriptValue(QScriptValue::UndefinedValue)", false);

   982         toBool.insert("QScriptValue(QScriptValue::NullValue)", false);

   983         toBool.insert("QScriptValue(true)", true);

   984         toBool.insert("QScriptValue(false)", false);

   985         toBool.insert("QScriptValue(int(122))", true);

   986         toBool.insert("QScriptValue(uint(124))", true);

   987         toBool.insert("QScriptValue(0)", false);

   988         toBool.insert("QScriptValue(0.0)", false);

   989         toBool.insert("QScriptValue(123.0)", true);

   990         toBool.insert("QScriptValue(6.37e-8)", true);

   991         toBool.insert("QScriptValue(-6.37e-8)", true);

   992         toBool.insert("QScriptValue(0x43211234)", true);

   993         toBool.insert("QScriptValue(0x10000)", true);

   994         toBool.insert("QScriptValue(0x10001)", true);

   995         toBool.insert("QScriptValue(qSNaN())", false);

   996         toBool.insert("QScriptValue(qQNaN())", false);

   997         toBool.insert("QScriptValue(qInf())", true);

   998         toBool.insert("QScriptValue(-qInf())", true);

   999         toBool.insert("QScriptValue(\"NaN\")", true);

  1000         toBool.insert("QScriptValue(\"Infinity\")", true);

  1001         toBool.insert("QScriptValue(\"-Infinity\")", true);

  1002         toBool.insert("QScriptValue(\"ciao\")", true);

  1003         toBool.insert("QScriptValue(QString::fromLatin1(\"ciao\"))", true);

  1004         toBool.insert("QScriptValue(QString(\"\"))", false);

  1005         toBool.insert("QScriptValue(QString())", false);

  1006         toBool.insert("QScriptValue(QString(\"0\"))", true);

  1007         toBool.insert("QScriptValue(QString(\"123\"))", true);

  1008         toBool.insert("QScriptValue(QString(\"12.4\"))", true);

  1009         toBool.insert("QScriptValue(0, QScriptValue::UndefinedValue)", false);

  1010         toBool.insert("QScriptValue(0, QScriptValue::NullValue)", false);

  1011         toBool.insert("QScriptValue(0, true)", true);

  1012         toBool.insert("QScriptValue(0, false)", false);

  1013         toBool.insert("QScriptValue(0, int(122))", true);

  1014         toBool.insert("QScriptValue(0, uint(124))", true);

  1015         toBool.insert("QScriptValue(0, 0)", false);

  1016         toBool.insert("QScriptValue(0, 0.0)", false);

  1017         toBool.insert("QScriptValue(0, 123.0)", true);

  1018         toBool.insert("QScriptValue(0, 6.37e-8)", true);

  1019         toBool.insert("QScriptValue(0, -6.37e-8)", true);

  1020         toBool.insert("QScriptValue(0, 0x43211234)", true);

  1021         toBool.insert("QScriptValue(0, 0x10000)", true);

  1022         toBool.insert("QScriptValue(0, 0x10001)", true);

  1023         toBool.insert("QScriptValue(0, qSNaN())", false);

  1024         toBool.insert("QScriptValue(0, qQNaN())", false);

  1025         toBool.insert("QScriptValue(0, qInf())", true);

  1026         toBool.insert("QScriptValue(0, -qInf())", true);

  1027         toBool.insert("QScriptValue(0, \"NaN\")", true);

  1028         toBool.insert("QScriptValue(0, \"Infinity\")", true);

  1029         toBool.insert("QScriptValue(0, \"-Infinity\")", true);

  1030         toBool.insert("QScriptValue(0, \"ciao\")", true);

  1031         toBool.insert("QScriptValue(0, QString::fromLatin1(\"ciao\"))", true);

  1032         toBool.insert("QScriptValue(0, QString(\"\"))", false);

  1033         toBool.insert("QScriptValue(0, QString())", false);

  1034         toBool.insert("QScriptValue(0, QString(\"0\"))", true);

  1035         toBool.insert("QScriptValue(0, QString(\"123\"))", true);

  1036         toBool.insert("QScriptValue(0, QString(\"12.3\"))", true);

  1037         toBool.insert("QScriptValue(engine, QScriptValue::UndefinedValue)", false);

  1038         toBool.insert("QScriptValue(engine, QScriptValue::NullValue)", false);

  1039         toBool.insert("QScriptValue(engine, true)", true);

  1040         toBool.insert("QScriptValue(engine, false)", false);

  1041         toBool.insert("QScriptValue(engine, int(122))", true);

  1042         toBool.insert("QScriptValue(engine, uint(124))", true);

  1043         toBool.insert("QScriptValue(engine, 0)", false);

  1044         toBool.insert("QScriptValue(engine, 0.0)", false);

  1045         toBool.insert("QScriptValue(engine, 123.0)", true);

  1046         toBool.insert("QScriptValue(engine, 6.37e-8)", true);

  1047         toBool.insert("QScriptValue(engine, -6.37e-8)", true);

  1048         toBool.insert("QScriptValue(engine, 0x43211234)", true);

  1049         toBool.insert("QScriptValue(engine, 0x10000)", true);

  1050         toBool.insert("QScriptValue(engine, 0x10001)", true);

  1051         toBool.insert("QScriptValue(engine, qSNaN())", false);

  1052         toBool.insert("QScriptValue(engine, qQNaN())", false);

  1053         toBool.insert("QScriptValue(engine, qInf())", true);

  1054         toBool.insert("QScriptValue(engine, -qInf())", true);

  1055         toBool.insert("QScriptValue(engine, \"NaN\")", true);

  1056         toBool.insert("QScriptValue(engine, \"Infinity\")", true);

  1057         toBool.insert("QScriptValue(engine, \"-Infinity\")", true);

  1058         toBool.insert("QScriptValue(engine, \"ciao\")", true);

  1059         toBool.insert("QScriptValue(engine, QString::fromLatin1(\"ciao\"))", true);

  1060         toBool.insert("QScriptValue(engine, QString(\"\"))", false);

  1061         toBool.insert("QScriptValue(engine, QString())", false);

  1062         toBool.insert("QScriptValue(engine, QString(\"0\"))", true);

  1063         toBool.insert("QScriptValue(engine, QString(\"123\"))", true);

  1064         toBool.insert("QScriptValue(engine, QString(\"1.23\"))", true);

  1065         toBool.insert("engine->evaluate(\"[]\")", true);

  1066         toBool.insert("engine->evaluate(\"{}\")", false);

  1067         toBool.insert("engine->evaluate(\"Object.prototype\")", true);

  1068         toBool.insert("engine->evaluate(\"Date.prototype\")", true);

  1069         toBool.insert("engine->evaluate(\"Array.prototype\")", true);

  1070         toBool.insert("engine->evaluate(\"Function.prototype\")", true);

  1071         toBool.insert("engine->evaluate(\"Error.prototype\")", true);

  1072         toBool.insert("engine->evaluate(\"Object\")", true);

  1073         toBool.insert("engine->evaluate(\"Array\")", true);

  1074         toBool.insert("engine->evaluate(\"Number\")", true);

  1075         toBool.insert("engine->evaluate(\"Function\")", true);

  1076         toBool.insert("engine->evaluate(\"(function() { return 1; })\")", true);

  1077         toBool.insert("engine->evaluate(\"(function() { return 'ciao'; })\")", true);

  1078         toBool.insert("engine->evaluate(\"(function() { throw new Error('foo'); })\")", true);

  1079         toBool.insert("engine->evaluate(\"/foo/\")", true);

  1080         toBool.insert("engine->evaluate(\"new Object()\")", true);

  1081         toBool.insert("engine->evaluate(\"new Array()\")", true);

  1082         toBool.insert("engine->evaluate(\"new Error()\")", true);

  1083         toBool.insert("engine->nullValue()", false);

  1084         toBool.insert("engine->undefinedValue()", false);

  1085     }

  1086     newRow(expr) << toBool.value(expr);

  1087 }

  1088 

  1089 void tst_QScriptValue::toBool_test(const char*, const QScriptValue& value)

  1090 {

  1091     QFETCH(bool, expected);

  1092     QCOMPARE(value.toBool(), expected);

  1093 }

  1094 

  1095 DEFINE_TEST_FUNCTION(toBool)

  1096 

  1097 

  1098 void tst_QScriptValue::toBoolean_initData()

  1099 {

  1100     QTest::addColumn<bool>("expected");

  1101     initScriptValues();

  1102 }

  1103 

  1104 void tst_QScriptValue::toBoolean_makeData(const char* expr)

  1105 {

  1106     static QHash<QString, bool> toBoolean;

  1107     if (toBoolean.isEmpty()) {

  1108         toBoolean.insert("QScriptValue()", false);

  1109         toBoolean.insert("QScriptValue(QScriptValue::UndefinedValue)", false);

  1110         toBoolean.insert("QScriptValue(QScriptValue::NullValue)", false);

  1111         toBoolean.insert("QScriptValue(true)", true);

  1112         toBoolean.insert("QScriptValue(false)", false);

  1113         toBoolean.insert("QScriptValue(int(122))", true);

  1114         toBoolean.insert("QScriptValue(uint(124))", true);

  1115         toBoolean.insert("QScriptValue(0)", false);

  1116         toBoolean.insert("QScriptValue(0.0)", false);

  1117         toBoolean.insert("QScriptValue(123.0)", true);

  1118         toBoolean.insert("QScriptValue(6.37e-8)", true);

  1119         toBoolean.insert("QScriptValue(-6.37e-8)", true);

  1120         toBoolean.insert("QScriptValue(0x43211234)", true);

  1121         toBoolean.insert("QScriptValue(0x10000)", true);

  1122         toBoolean.insert("QScriptValue(0x10001)", true);

  1123         toBoolean.insert("QScriptValue(qSNaN())", false);

  1124         toBoolean.insert("QScriptValue(qQNaN())", false);

  1125         toBoolean.insert("QScriptValue(qInf())", true);

  1126         toBoolean.insert("QScriptValue(-qInf())", true);

  1127         toBoolean.insert("QScriptValue(\"NaN\")", true);

  1128         toBoolean.insert("QScriptValue(\"Infinity\")", true);

  1129         toBoolean.insert("QScriptValue(\"-Infinity\")", true);

  1130         toBoolean.insert("QScriptValue(\"ciao\")", true);

  1131         toBoolean.insert("QScriptValue(QString::fromLatin1(\"ciao\"))", true);

  1132         toBoolean.insert("QScriptValue(QString(\"\"))", false);

  1133         toBoolean.insert("QScriptValue(QString())", false);

  1134         toBoolean.insert("QScriptValue(QString(\"0\"))", true);

  1135         toBoolean.insert("QScriptValue(QString(\"123\"))", true);