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 #include <QtGui/QPushButton>

    44 

    45 //TESTED_CLASS=

    46 //TESTED_FILES=

    47 

    48 QT_BEGIN_NAMESPACE

    49 extern bool qt_script_isJITEnabled();

    50 QT_END_NAMESPACE

    51 

    52 tst_QScriptValue::tst_QScriptValue()

    53     : engine(0)

    54 {

    55 }

    56 

    57 tst_QScriptValue::~tst_QScriptValue()

    58 {

    59     delete engine;

    60 }

    61 

    62 void tst_QScriptValue::dataHelper(InitDataFunction init, DefineDataFunction define)

    63 {

    64     QTest::addColumn<QString>("__expression__");

    65     (this->*init)();

    66     QHash<QString,QScriptValue>::const_iterator it;

    67     for (it = m_values.constBegin(); it != m_values.constEnd(); ++it) {

    68         m_currentExpression = it.key();

    69         (this->*define)(it.key().toLatin1());

    70     }

    71     m_currentExpression = QString();

    72 }

    73 

    74 QTestData &tst_QScriptValue::newRow(const char *tag)

    75 {

    76     return QTest::newRow(tag) << m_currentExpression;

    77 }

    78 

    79 void tst_QScriptValue::testHelper(TestFunction fun)

    80 {

    81     QFETCH(QString, __expression__);

    82     QScriptValue value = m_values.value(__expression__);

    83     (this->*fun)(__expression__.toLatin1(), value);

    84 }

    85 

    86 void tst_QScriptValue::assignAndCopyConstruct_initData()

    87 {

    88     QTest::addColumn<int>("dummy");

    89     initScriptValues();

    90 }

    91 

    92 void tst_QScriptValue::assignAndCopyConstruct_makeData(const char *expr)

    93 {

    94     newRow(expr) << 0;

    95 }

    96 

    97 void tst_QScriptValue::assignAndCopyConstruct_test(const char *, const QScriptValue &value)

    98 {

    99     QScriptValue copy(value);

   100     QCOMPARE(copy.strictlyEquals(value), !value.isNumber() || !qIsNaN(value.toNumber()));

   101     QCOMPARE(copy.engine(), value.engine());

   102 

   103     QScriptValue assigned = copy;

   104     QCOMPARE(assigned.strictlyEquals(value), !copy.isNumber() || !qIsNaN(copy.toNumber()));

   105     QCOMPARE(assigned.engine(), assigned.engine());

   106 

   107     QScriptValue other(!value.toBool());

   108     assigned = other;

   109     QVERIFY(!assigned.strictlyEquals(copy));

   110     QVERIFY(assigned.strictlyEquals(other));

   111     QCOMPARE(assigned.engine(), other.engine());

   112 }

   113 

   114 DEFINE_TEST_FUNCTION(assignAndCopyConstruct)

   115 

   116 void tst_QScriptValue::ctor()

   117 {

   118     QScriptEngine eng;

   119     {

   120         QScriptValue v;

   121         QCOMPARE(v.isValid(), false);

   122         QCOMPARE(v.engine(), (QScriptEngine *)0);

   123     }

   124     {

   125         QScriptValue v(&eng, QScriptValue::UndefinedValue);

   126         QCOMPARE(v.isValid(), true);

   127         QCOMPARE(v.isUndefined(), true);

   128         QCOMPARE(v.isObject(), false);

   129         QCOMPARE(v.engine(), &eng);

   130     }

   131     {

   132         QScriptValue v(&eng, QScriptValue::NullValue);

   133         QCOMPARE(v.isValid(), true);

   134         QCOMPARE(v.isNull(), true);

   135         QCOMPARE(v.isObject(), false);

   136         QCOMPARE(v.engine(), &eng);

   137     }

   138     {

   139         QScriptValue v(&eng, false);

   140         QCOMPARE(v.isValid(), true);

   141         QCOMPARE(v.isBoolean(), true);

   142         QCOMPARE(v.isBool(), true);

   143         QCOMPARE(v.isObject(), false);

   144         QCOMPARE(v.toBoolean(), false);

   145         QCOMPARE(v.engine(), &eng);

   146     }

   147     {

   148         QScriptValue v(&eng, int(1));

   149         QCOMPARE(v.isValid(), true);

   150         QCOMPARE(v.isNumber(), true);

   151         QCOMPARE(v.isObject(), false);

   152         QCOMPARE(v.toNumber(), 1.0);

   153         QCOMPARE(v.engine(), &eng);

   154     }

   155     {

   156         QScriptValue v(int(0x43211234));

   157         QVERIFY(v.isNumber());

   158         QCOMPARE(v.toInt32(), 0x43211234);

   159     }

   160     {

   161         QScriptValue v(&eng, uint(1));

   162         QCOMPARE(v.isValid(), true);

   163         QCOMPARE(v.isNumber(), true);

   164         QCOMPARE(v.isObject(), false);

   165         QCOMPARE(v.toNumber(), 1.0);

   166         QCOMPARE(v.engine(), &eng);

   167     }

   168     {

   169         QScriptValue v(uint(0x43211234));

   170         QVERIFY(v.isNumber());

   171         QCOMPARE(v.toUInt32(), uint(0x43211234));

   172     }

   173     {

   174         QScriptValue v(&eng, 1.0);

   175         QCOMPARE(v.isValid(), true);

   176         QCOMPARE(v.isNumber(), true);

   177         QCOMPARE(v.isObject(), false);

   178         QCOMPARE(v.toNumber(), 1.0);

   179         QCOMPARE(v.engine(), &eng);

   180     }

   181     {

   182         QScriptValue v(12345678910.5);

   183         QVERIFY(v.isNumber());

   184         QCOMPARE(v.toNumber(), 12345678910.5);

   185     }

   186     {

   187         QScriptValue v(&eng, "ciao");

   188         QCOMPARE(v.isValid(), true);

   189         QCOMPARE(v.isString(), true);

   190         QCOMPARE(v.isObject(), false);

   191         QCOMPARE(v.toString(), QLatin1String("ciao"));

   192         QCOMPARE(v.engine(), &eng);

   193     }

   194     {

   195         QScriptValue v(&eng, QString("ciao"));

   196         QCOMPARE(v.isValid(), true);

   197         QCOMPARE(v.isString(), true);

   198         QCOMPARE(v.isObject(), false);

   199         QCOMPARE(v.toString(), QLatin1String("ciao"));

   200         QCOMPARE(v.engine(), &eng);

   201     }

   202     // copy constructor, operator=

   203     {

   204         QScriptValue v(&eng, 1.0);

   205         QScriptValue v2(v);

   206         QCOMPARE(v2.strictlyEquals(v), true);

   207         QCOMPARE(v2.engine(), &eng);

   208 

   209         QScriptValue v3(v);

   210         QCOMPARE(v3.strictlyEquals(v), true);

   211         QCOMPARE(v3.strictlyEquals(v2), true);

   212         QCOMPARE(v3.engine(), &eng);

   213 

   214         QScriptValue v4(&eng, 2.0);

   215         QCOMPARE(v4.strictlyEquals(v), false);

   216         v3 = v4;

   217         QCOMPARE(v3.strictlyEquals(v), false);

   218         QCOMPARE(v3.strictlyEquals(v4), true);

   219 

   220         v2 = QScriptValue();

   221         QCOMPARE(v2.strictlyEquals(v), false);

   222         QCOMPARE(v.toNumber(), 1.0);

   223 

   224         QScriptValue v5(v);

   225         QCOMPARE(v5.strictlyEquals(v), true);

   226         v = QScriptValue();

   227         QCOMPARE(v5.strictlyEquals(v), false);

   228         QCOMPARE(v5.toNumber(), 1.0);

   229     }

   230 

   231     // constructors that take no engine argument

   232     {

   233         QScriptValue v(QScriptValue::UndefinedValue);

   234         QCOMPARE(v.isValid(), true);

   235         QCOMPARE(v.isUndefined(), true);

   236         QCOMPARE(v.isObject(), false);

   237         QCOMPARE(v.engine(), (QScriptEngine *)0);

   238     }

   239     {

   240         QScriptValue v(QScriptValue::NullValue);

   241         QCOMPARE(v.isValid(), true);

   242         QCOMPARE(v.isNull(), true);

   243         QCOMPARE(v.isObject(), false);

   244         QCOMPARE(v.engine(), (QScriptEngine *)0);

   245     }

   246     {

   247         QScriptValue v(false);

   248         QCOMPARE(v.isValid(), true);

   249         QCOMPARE(v.isBoolean(), true);

   250         QCOMPARE(v.isBool(), true);

   251         QCOMPARE(v.isObject(), false);

   252         QCOMPARE(v.toBoolean(), false);

   253         QCOMPARE(v.engine(), (QScriptEngine *)0);

   254     }

   255     {

   256         QScriptValue v(int(1));

   257         QCOMPARE(v.isValid(), true);

   258         QCOMPARE(v.isNumber(), true);

   259         QCOMPARE(v.isObject(), false);

   260         QCOMPARE(v.toNumber(), 1.0);

   261         QCOMPARE(v.engine(), (QScriptEngine *)0);

   262     }

   263     {

   264         QScriptValue v(uint(1));

   265         QCOMPARE(v.isValid(), true);

   266         QCOMPARE(v.isNumber(), true);

   267         QCOMPARE(v.isObject(), false);

   268         QCOMPARE(v.toNumber(), 1.0);

   269         QCOMPARE(v.engine(), (QScriptEngine *)0);

   270     }

   271     {

   272         QScriptValue v(1.0);

   273         QCOMPARE(v.isValid(), true);

   274         QCOMPARE(v.isNumber(), true);

   275         QCOMPARE(v.isObject(), false);

   276         QCOMPARE(v.toNumber(), 1.0);

   277         QCOMPARE(v.engine(), (QScriptEngine *)0);

   278     }

   279     {

   280         QScriptValue v("ciao");

   281         QCOMPARE(v.isValid(), true);

   282         QCOMPARE(v.isString(), true);

   283         QCOMPARE(v.isObject(), false);

   284         QCOMPARE(v.toString(), QLatin1String("ciao"));

   285         QCOMPARE(v.engine(), (QScriptEngine *)0);

   286     }

   287     {

   288         QScriptValue v(QString("ciao"));

   289         QCOMPARE(v.isValid(), true);

   290         QCOMPARE(v.isString(), true);

   291         QCOMPARE(v.isObject(), false);

   292         QCOMPARE(v.toString(), QLatin1String("ciao"));

   293         QCOMPARE(v.engine(), (QScriptEngine *)0);

   294     }

   295     // copy constructor, operator=

   296     {

   297         QScriptValue v(1.0);

   298         QScriptValue v2(v);

   299         QCOMPARE(v2.strictlyEquals(v), true);

   300         QCOMPARE(v2.engine(), (QScriptEngine *)0);

   301 

   302         QScriptValue v3(v);

   303         QCOMPARE(v3.strictlyEquals(v), true);

   304         QCOMPARE(v3.strictlyEquals(v2), true);

   305         QCOMPARE(v3.engine(), (QScriptEngine *)0);

   306 

   307         QScriptValue v4(2.0);

   308         QCOMPARE(v4.strictlyEquals(v), false);

   309         v3 = v4;

   310         QCOMPARE(v3.strictlyEquals(v), false);

   311         QCOMPARE(v3.strictlyEquals(v4), true);

   312 

   313         v2 = QScriptValue();

   314         QCOMPARE(v2.strictlyEquals(v), false);

   315         QCOMPARE(v.toNumber(), 1.0);

   316 

   317         QScriptValue v5(v);

   318         QCOMPARE(v5.strictlyEquals(v), true);

   319         v = QScriptValue();

   320         QCOMPARE(v5.strictlyEquals(v), false);

   321         QCOMPARE(v5.toNumber(), 1.0);

   322     }

   323 

   324     // 0 engine

   325     QVERIFY(QScriptValue(0, QScriptValue::UndefinedValue).isUndefined());

   326     QVERIFY(QScriptValue(0, QScriptValue::NullValue).isNull());

   327     QVERIFY(QScriptValue(0, false).isBool());

   328     QVERIFY(QScriptValue(0, int(1)).isNumber());

   329     QVERIFY(QScriptValue(0, uint(1)).isNumber());

   330     QVERIFY(QScriptValue(0, 1.0).isNumber());

   331     QVERIFY(QScriptValue(0, "ciao").isString());

   332     QVERIFY(QScriptValue(0, QString("ciao")).isString());

   333 }

   334 

   335 static QScriptValue myFunction(QScriptContext *, QScriptEngine *eng)

   336 {

   337     return eng->undefinedValue();

   338 }

   339 

   340 void tst_QScriptValue::toString_old()

   341 {

   342     QScriptEngine eng;

   343 

   344     QScriptValue undefined = eng.undefinedValue();

   345     QCOMPARE(undefined.toString(), QString("undefined"));

   346     QCOMPARE(qscriptvalue_cast<QString>(undefined), QString());

   347 

   348     QScriptValue null = eng.nullValue();

   349     QCOMPARE(null.toString(), QString("null"));

   350     QCOMPARE(qscriptvalue_cast<QString>(null), QString());

   351 

   352     {

   353         QScriptValue falskt = QScriptValue(&eng, false);

   354         QCOMPARE(falskt.toString(), QString("false"));

   355         QCOMPARE(qscriptvalue_cast<QString>(falskt), QString("false"));

   356 

   357         QScriptValue sant = QScriptValue(&eng, true);

   358         QCOMPARE(sant.toString(), QString("true"));

   359         QCOMPARE(qscriptvalue_cast<QString>(sant), QString("true"));

   360     }

   361     {

   362         QScriptValue number = QScriptValue(&eng, 123);

   363         QCOMPARE(number.toString(), QString("123"));

   364         QCOMPARE(qscriptvalue_cast<QString>(number), QString("123"));

   365     }

   366     {

   367         QScriptValue number = QScriptValue(&eng, 6.37e-8);

   368         QCOMPARE(number.toString(), QString("6.37e-8"));

   369     }

   370     {

   371         QScriptValue number = QScriptValue(&eng, -6.37e-8);

   372         QCOMPARE(number.toString(), QString("-6.37e-8"));

   373 

   374         QScriptValue str = QScriptValue(&eng, QString("ciao"));

   375         QCOMPARE(str.toString(), QString("ciao"));

   376         QCOMPARE(qscriptvalue_cast<QString>(str), QString("ciao"));

   377     }

   378 

   379     QScriptValue object = eng.newObject();

   380     QCOMPARE(object.toString(), QString("[object Object]"));

   381     QCOMPARE(qscriptvalue_cast<QString>(object), QString("[object Object]"));

   382 

   383     QScriptValue fun = eng.newFunction(myFunction);

   384     QCOMPARE(fun.toString(), QString("function () {\n    [native code]\n}"));

   385     QCOMPARE(qscriptvalue_cast<QString>(fun), QString("function () {\n    [native code]\n}"));

   386 

   387     // toString() that throws exception

   388     {

   389         QScriptValue objectObject = eng.evaluate(

   390             "(function(){"

   391             "  o = { };"

   392             "  o.toString = function() { throw new Error('toString'); };"

   393             "  return o;"

   394             "})()");

   395         QCOMPARE(objectObject.toString(), QLatin1String("Error: toString"));

   396         QVERIFY(eng.hasUncaughtException());

   397         QCOMPARE(eng.uncaughtException().toString(), QLatin1String("Error: toString"));

   398     }

   399     {

   400         eng.clearExceptions();

   401         QScriptValue objectObject = eng.evaluate(

   402             "(function(){"

   403             "  var f = function() {};"

   404             "  f.prototype = Date;"

   405             "  return new f;"

   406             "})()");

   407         QVERIFY(!eng.hasUncaughtException());

   408         QVERIFY(objectObject.isObject());

   409         QCOMPARE(objectObject.toString(), QString::fromLatin1("TypeError: Function.prototype.toString called on incompatible object"));

   410         QVERIFY(eng.hasUncaughtException());

   411         eng.clearExceptions();

   412     }

   413 

   414     QScriptValue inv = QScriptValue();

   415     QCOMPARE(inv.toString(), QString());

   416 

   417     // V2 constructors

   418     {

   419         QScriptValue falskt = QScriptValue(false);

   420         QCOMPARE(falskt.toString(), QString("false"));

   421         QCOMPARE(qscriptvalue_cast<QString>(falskt), QString("false"));

   422 

   423         QScriptValue sant = QScriptValue(true);

   424         QCOMPARE(sant.toString(), QString("true"));

   425         QCOMPARE(qscriptvalue_cast<QString>(sant), QString("true"));

   426 

   427         QScriptValue number = QScriptValue(123);

   428         QCOMPARE(number.toString(), QString("123"));

   429         QCOMPARE(qscriptvalue_cast<QString>(number), QString("123"));

   430 

   431         QScriptValue number2(int(0x43211234));

   432         QCOMPARE(number2.toString(), QString("1126240820"));

   433 

   434         QScriptValue str = QScriptValue(QString("ciao"));

   435         QCOMPARE(str.toString(), QString("ciao"));

   436         QCOMPARE(qscriptvalue_cast<QString>(str), QString("ciao"));

   437     }

   438 

   439     // variant should use internal valueOf(), then fall back to QVariant::toString(),

   440     // then fall back to "QVariant(typename)"

   441     QScriptValue variant = eng.newVariant(123);

   442     QVERIFY(variant.isVariant());

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

   444     variant = eng.newVariant(QByteArray("hello"));

   445     QVERIFY(variant.isVariant());

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

   447     variant = eng.newVariant(QVariant(QPoint(10, 20)));

   448     QVERIFY(variant.isVariant());

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

   450     variant = eng.newVariant(QUrl());

   451     QVERIFY(variant.toString().isEmpty());

   452 }

   453 

   454 void tst_QScriptValue::toNumber_old()

   455 {

   456     QScriptEngine eng;

   457 

   458     QScriptValue undefined = eng.undefinedValue();

   459     QCOMPARE(qIsNaN(undefined.toNumber()), true);

   460     QCOMPARE(qIsNaN(qscriptvalue_cast<qsreal>(undefined)), true);

   461 

   462     QScriptValue null = eng.nullValue();

   463     QCOMPARE(null.toNumber(), 0.0);

   464     QCOMPARE(qscriptvalue_cast<qsreal>(null), 0.0);

   465 

   466     {

   467         QScriptValue falskt = QScriptValue(&eng, false);

   468         QCOMPARE(falskt.toNumber(), 0.0);

   469         QCOMPARE(qscriptvalue_cast<qsreal>(falskt), 0.0);

   470 

   471         QScriptValue sant = QScriptValue(&eng, true);

   472         QCOMPARE(sant.toNumber(), 1.0);

   473         QCOMPARE(qscriptvalue_cast<qsreal>(sant), 1.0);

   474 

   475         QScriptValue number = QScriptValue(&eng, 123.0);

   476         QCOMPARE(number.toNumber(), 123.0);

   477         QCOMPARE(qscriptvalue_cast<qsreal>(number), 123.0);

   478 

   479         QScriptValue str = QScriptValue(&eng, QString("ciao"));

   480         QCOMPARE(qIsNaN(str.toNumber()), true);

   481         QCOMPARE(qIsNaN(qscriptvalue_cast<qsreal>(str)), true);

   482 

   483         QScriptValue str2 = QScriptValue(&eng, QString("123"));

   484         QCOMPARE(str2.toNumber(), 123.0);

   485         QCOMPARE(qscriptvalue_cast<qsreal>(str2), 123.0);

   486     }

   487 

   488     QScriptValue object = eng.newObject();

   489     QCOMPARE(qIsNaN(object.toNumber()), true);

   490     QCOMPARE(qIsNaN(qscriptvalue_cast<qsreal>(object)), true);

   491 

   492     QScriptValue fun = eng.newFunction(myFunction);

   493     QCOMPARE(qIsNaN(fun.toNumber()), true);

   494     QCOMPARE(qIsNaN(qscriptvalue_cast<qsreal>(fun)), true);

   495 

   496     QScriptValue inv = QScriptValue();

   497     QCOMPARE(inv.toNumber(), 0.0);

   498     QCOMPARE(qscriptvalue_cast<qsreal>(inv), 0.0);

   499 

   500     // V2 constructors

   501     {

   502         QScriptValue falskt = QScriptValue(false);

   503         QCOMPARE(falskt.toNumber(), 0.0);

   504         QCOMPARE(qscriptvalue_cast<qsreal>(falskt), 0.0);

   505 

   506         QScriptValue sant = QScriptValue(true);

   507         QCOMPARE(sant.toNumber(), 1.0);

   508         QCOMPARE(qscriptvalue_cast<qsreal>(sant), 1.0);

   509 

   510         QScriptValue number = QScriptValue(123.0);

   511         QCOMPARE(number.toNumber(), 123.0);

   512         QCOMPARE(qscriptvalue_cast<qsreal>(number), 123.0);

   513 

   514         QScriptValue number2(int(0x43211234));

   515         QCOMPARE(number2.toNumber(), 1126240820.0);

   516 

   517         QScriptValue str = QScriptValue(QString("ciao"));

   518         QCOMPARE(qIsNaN(str.toNumber()), true);

   519         QCOMPARE(qIsNaN(qscriptvalue_cast<qsreal>(str)), true);

   520 

   521         QScriptValue str2 = QScriptValue(QString("123"));

   522         QCOMPARE(str2.toNumber(), 123.0);

   523         QCOMPARE(qscriptvalue_cast<qsreal>(str2), 123.0);

   524     }

   525 }

   526 

   527 void tst_QScriptValue::toBoolean_old() // deprecated

   528 {

   529     QScriptEngine eng;

   530 

   531     QScriptValue undefined = eng.undefinedValue();

   532     QCOMPARE(undefined.toBoolean(), false);

   533     QCOMPARE(qscriptvalue_cast<bool>(undefined), false);

   534 

   535     QScriptValue null = eng.nullValue();

   536     QCOMPARE(null.toBoolean(), false);

   537     QCOMPARE(qscriptvalue_cast<bool>(null), false);

   538 

   539     {

   540         QScriptValue falskt = QScriptValue(&eng, false);

   541         QCOMPARE(falskt.toBoolean(), false);

   542         QCOMPARE(qscriptvalue_cast<bool>(falskt), false);

   543 

   544         QScriptValue sant = QScriptValue(&eng, true);

   545         QCOMPARE(sant.toBoolean(), true);

   546         QCOMPARE(qscriptvalue_cast<bool>(sant), true);

   547 

   548         QScriptValue number = QScriptValue(&eng, 0.0);

   549         QCOMPARE(number.toBoolean(), false);

   550         QCOMPARE(qscriptvalue_cast<bool>(number), false);

   551 

   552         QScriptValue number2 = QScriptValue(&eng, qSNaN());

   553         QCOMPARE(number2.toBoolean(), false);

   554         QCOMPARE(qscriptvalue_cast<bool>(number2), false);

   555 

   556         QScriptValue number3 = QScriptValue(&eng, 123.0);

   557         QCOMPARE(number3.toBoolean(), true);

   558         QCOMPARE(qscriptvalue_cast<bool>(number3), true);

   559 

   560         QScriptValue number4 = QScriptValue(&eng, -456.0);

   561         QCOMPARE(number4.toBoolean(), true);

   562         QCOMPARE(qscriptvalue_cast<bool>(number4), true);

   563 

   564         QScriptValue str = QScriptValue(&eng, QString(""));

   565         QCOMPARE(str.toBoolean(), false);

   566         QCOMPARE(qscriptvalue_cast<bool>(str), false);

   567 

   568         QScriptValue str2 = QScriptValue(&eng, QString("123"));

   569         QCOMPARE(str2.toBoolean(), true);

   570         QCOMPARE(qscriptvalue_cast<bool>(str2), true);

   571     }

   572 

   573     QScriptValue object = eng.newObject();

   574     QCOMPARE(object.toBoolean(), true);

   575     QCOMPARE(qscriptvalue_cast<bool>(object), true);

   576 

   577     QScriptValue fun = eng.newFunction(myFunction);

   578     QCOMPARE(fun.toBoolean(), true);

   579     QCOMPARE(qscriptvalue_cast<bool>(fun), true);

   580 

   581     QScriptValue inv = QScriptValue();

   582     QCOMPARE(inv.toBoolean(), false);

   583     QCOMPARE(qscriptvalue_cast<bool>(inv), false);

   584 

   585     // V2 constructors

   586     {

   587         QScriptValue falskt = QScriptValue(false);

   588         QCOMPARE(falskt.toBoolean(), false);

   589         QCOMPARE(qscriptvalue_cast<bool>(falskt), false);

   590 

   591         QScriptValue sant = QScriptValue(true);

   592         QCOMPARE(sant.toBoolean(), true);

   593         QCOMPARE(qscriptvalue_cast<bool>(sant), true);

   594 

   595         QScriptValue number = QScriptValue(0.0);

   596         QCOMPARE(number.toBoolean(), false);

   597         QCOMPARE(qscriptvalue_cast<bool>(number), false);

   598 

   599         QScriptValue number2 = QScriptValue(qSNaN());

   600         QCOMPARE(number2.toBoolean(), false);

   601         QCOMPARE(qscriptvalue_cast<bool>(number2), false);

   602 

   603         QScriptValue number3 = QScriptValue(123.0);

   604         QCOMPARE(number3.toBoolean(), true);

   605         QCOMPARE(qscriptvalue_cast<bool>(number3), true);

   606 

   607         QScriptValue number4 = QScriptValue(-456.0);

   608         QCOMPARE(number4.toBoolean(), true);

   609         QCOMPARE(qscriptvalue_cast<bool>(number4), true);

   610 

   611         QScriptValue number5 = QScriptValue(0x43211234);

   612         QCOMPARE(number5.toBoolean(), true);

   613 

   614         QScriptValue str = QScriptValue(QString(""));

   615         QCOMPARE(str.toBoolean(), false);

   616         QCOMPARE(qscriptvalue_cast<bool>(str), false);

   617 

   618         QScriptValue str2 = QScriptValue(QString("123"));

   619         QCOMPARE(str2.toBoolean(), true);

   620         QCOMPARE(qscriptvalue_cast<bool>(str2), true);

   621     }

   622 }

   623 

   624 void tst_QScriptValue::toBool_old()

   625 {

   626     QScriptEngine eng;

   627 

   628     QScriptValue undefined = eng.undefinedValue();

   629     QCOMPARE(undefined.toBool(), false);

   630     QCOMPARE(qscriptvalue_cast<bool>(undefined), false);

   631 

   632     QScriptValue null = eng.nullValue();

   633     QCOMPARE(null.toBool(), false);

   634     QCOMPARE(qscriptvalue_cast<bool>(null), false);

   635 

   636     {

   637         QScriptValue falskt = QScriptValue(&eng, false);

   638         QCOMPARE(falskt.toBool(), false);

   639         QCOMPARE(qscriptvalue_cast<bool>(falskt), false);

   640 

   641         QScriptValue sant = QScriptValue(&eng, true);

   642         QCOMPARE(sant.toBool(), true);

   643         QCOMPARE(qscriptvalue_cast<bool>(sant), true);

   644 

   645         QScriptValue number = QScriptValue(&eng, 0.0);

   646         QCOMPARE(number.toBool(), false);

   647         QCOMPARE(qscriptvalue_cast<bool>(number), false);

   648 

   649         QScriptValue number2 = QScriptValue(&eng, qSNaN());

   650         QCOMPARE(number2.toBool(), false);

   651         QCOMPARE(qscriptvalue_cast<bool>(number2), false);

   652 

   653         QScriptValue number3 = QScriptValue(&eng, 123.0);

   654         QCOMPARE(number3.toBool(), true);

   655         QCOMPARE(qscriptvalue_cast<bool>(number3), true);

   656 

   657         QScriptValue number4 = QScriptValue(&eng, -456.0);

   658         QCOMPARE(number4.toBool(), true);

   659         QCOMPARE(qscriptvalue_cast<bool>(number4), true);

   660 

   661         QScriptValue str = QScriptValue(&eng, QString(""));

   662         QCOMPARE(str.toBool(), false);

   663         QCOMPARE(qscriptvalue_cast<bool>(str), false);

   664 

   665         QScriptValue str2 = QScriptValue(&eng, QString("123"));

   666         QCOMPARE(str2.toBool(), true);

   667         QCOMPARE(qscriptvalue_cast<bool>(str2), true);

   668     }

   669 

   670     QScriptValue object = eng.newObject();

   671     QCOMPARE(object.toBool(), true);

   672     QCOMPARE(qscriptvalue_cast<bool>(object), true);

   673 

   674     QScriptValue fun = eng.newFunction(myFunction);

   675     QCOMPARE(fun.toBool(), true);

   676     QCOMPARE(qscriptvalue_cast<bool>(fun), true);

   677 

   678     QScriptValue inv = QScriptValue();

   679     QCOMPARE(inv.toBool(), false);

   680     QCOMPARE(qscriptvalue_cast<bool>(inv), false);

   681 

   682     // V2 constructors

   683     {

   684         QScriptValue falskt = QScriptValue(false);

   685         QCOMPARE(falskt.toBool(), false);

   686         QCOMPARE(qscriptvalue_cast<bool>(falskt), false);

   687 

   688         QScriptValue sant = QScriptValue(true);

   689         QCOMPARE(sant.toBool(), true);

   690         QCOMPARE(qscriptvalue_cast<bool>(sant), true);

   691 

   692         QScriptValue number = QScriptValue(0.0);

   693         QCOMPARE(number.toBool(), false);

   694         QCOMPARE(qscriptvalue_cast<bool>(number), false);

   695 

   696         QScriptValue number2 = QScriptValue(qSNaN());

   697         QCOMPARE(number2.toBool(), false);

   698         QCOMPARE(qscriptvalue_cast<bool>(number2), false);

   699 

   700         QScriptValue number3 = QScriptValue(123.0);

   701         QCOMPARE(number3.toBool(), true);

   702         QCOMPARE(qscriptvalue_cast<bool>(number3), true);

   703 

   704         QScriptValue number4 = QScriptValue(-456.0);

   705         QCOMPARE(number4.toBool(), true);

   706         QCOMPARE(qscriptvalue_cast<bool>(number4), true);

   707 

   708         QScriptValue number5 = QScriptValue(0x43211234);

   709         QCOMPARE(number5.toBool(), true);

   710 

   711         QScriptValue str = QScriptValue(QString(""));

   712         QCOMPARE(str.toBool(), false);

   713         QCOMPARE(qscriptvalue_cast<bool>(str), false);

   714 

   715         QScriptValue str2 = QScriptValue(QString("123"));

   716         QCOMPARE(str2.toBool(), true);

   717         QCOMPARE(qscriptvalue_cast<bool>(str2), true);

   718     }

   719 }

   720 

   721 void tst_QScriptValue::toInteger_old()

   722 {

   723     QScriptEngine eng;

   724 

   725     {

   726         QScriptValue number = QScriptValue(&eng, 123.0);

   727         QCOMPARE(number.toInteger(), 123.0);

   728 

   729         QScriptValue number2 = QScriptValue(&eng, qSNaN());

   730         QCOMPARE(number2.toInteger(), 0.0);

   731 

   732         QScriptValue number3 = QScriptValue(&eng, qInf());

   733         QCOMPARE(qIsInf(number3.toInteger()), true);

   734 

   735         QScriptValue number4 = QScriptValue(&eng, 0.5);

   736         QCOMPARE(number4.toInteger(), 0.0);

   737 

   738         QScriptValue number5 = QScriptValue(&eng, 123.5);

   739         QCOMPARE(number5.toInteger(), 123.0);

   740 

   741         QScriptValue number6 = QScriptValue(&eng, -456.5);

   742         QCOMPARE(number6.toInteger(), -456.0);

   743 

   744         QScriptValue str = QScriptValue(&eng, "123.0");

   745         QCOMPARE(str.toInteger(), 123.0);

   746 

   747         QScriptValue str2 = QScriptValue(&eng, "NaN");

   748         QCOMPARE(str2.toInteger(), 0.0);

   749 

   750         QScriptValue str3 = QScriptValue(&eng, "Infinity");

   751         QCOMPARE(qIsInf(str3.toInteger()), true);

   752 

   753         QScriptValue str4 = QScriptValue(&eng, "0.5");

   754         QCOMPARE(str4.toInteger(), 0.0);

   755 

   756         QScriptValue str5 = QScriptValue(&eng, "123.5");

   757         QCOMPARE(str5.toInteger(), 123.0);

   758 

   759         QScriptValue str6 = QScriptValue(&eng, "-456.5");

   760         QCOMPARE(str6.toInteger(), -456.0);

   761     }

   762     // V2 constructors

   763     {

   764         QScriptValue number = QScriptValue(123.0);

   765         QCOMPARE(number.toInteger(), 123.0);

   766 

   767         QScriptValue number2 = QScriptValue(qSNaN());

   768         QCOMPARE(number2.toInteger(), 0.0);

   769 

   770         QScriptValue number3 = QScriptValue(qInf());

   771         QCOMPARE(qIsInf(number3.toInteger()), true);

   772 

   773         QScriptValue number4 = QScriptValue(0.5);

   774         QCOMPARE(number4.toInteger(), 0.0);

   775 

   776         QScriptValue number5 = QScriptValue(123.5);

   777         QCOMPARE(number5.toInteger(), 123.0);

   778 

   779         QScriptValue number6 = QScriptValue(-456.5);

   780         QCOMPARE(number6.toInteger(), -456.0);

   781 

   782         QScriptValue number7 = QScriptValue(0x43211234);

   783         QCOMPARE(number7.toInteger(), qsreal(0x43211234));

   784 

   785         QScriptValue str = QScriptValue("123.0");

   786         QCOMPARE(str.toInteger(), 123.0);

   787 

   788         QScriptValue str2 = QScriptValue("NaN");

   789         QCOMPARE(str2.toInteger(), 0.0);

   790 

   791         QScriptValue str3 = QScriptValue("Infinity");

   792         QCOMPARE(qIsInf(str3.toInteger()), true);

   793 

   794         QScriptValue str4 = QScriptValue("0.5");

   795         QCOMPARE(str4.toInteger(), 0.0);

   796 

   797         QScriptValue str5 = QScriptValue("123.5");

   798         QCOMPARE(str5.toInteger(), 123.0);

   799 

   800         QScriptValue str6 = QScriptValue("-456.5");

   801         QCOMPARE(str6.toInteger(), -456.0);

   802     }

   803 

   804     QScriptValue inv;

   805     QCOMPARE(inv.toInteger(), 0.0);

   806 }

   807 

   808 void tst_QScriptValue::toInt32_old()

   809 {

   810     QScriptEngine eng;

   811 

   812     {

   813         QScriptValue zer0 = QScriptValue(&eng, 0.0);

   814         QCOMPARE(zer0.toInt32(), 0);

   815         QCOMPARE(qscriptvalue_cast<qint32>(zer0), 0);

   816 

   817         QScriptValue number = QScriptValue(&eng, 123.0);

   818         QCOMPARE(number.toInt32(), 123);

   819         QCOMPARE(qscriptvalue_cast<qint32>(number), 123);

   820 

   821         QScriptValue number2 = QScriptValue(&eng, qSNaN());

   822         QCOMPARE(number2.toInt32(), 0);

   823         QCOMPARE(qscriptvalue_cast<qint32>(number2), 0);

   824 

   825         QScriptValue number3 = QScriptValue(&eng, +qInf());

   826         QCOMPARE(number3.toInt32(), 0);

   827         QCOMPARE(qscriptvalue_cast<qint32>(number3), 0);

   828 

   829         QScriptValue number3_2 = QScriptValue(&eng, -qInf());

   830         QCOMPARE(number3_2.toInt32(), 0);

   831         QCOMPARE(qscriptvalue_cast<qint32>(number3_2), 0);

   832 

   833         QScriptValue number4 = QScriptValue(&eng, 0.5);

   834         QCOMPARE(number4.toInt32(), 0);

   835         QCOMPARE(qscriptvalue_cast<qint32>(number4), 0);

   836 

   837         QScriptValue number5 = QScriptValue(&eng, 123.5);

   838         QCOMPARE(number5.toInt32(), 123);

   839         QCOMPARE(qscriptvalue_cast<qint32>(number5), 123);

   840 

   841         QScriptValue number6 = QScriptValue(&eng, -456.5);

   842         QCOMPARE(number6.toInt32(), -456);

   843         QCOMPARE(qscriptvalue_cast<qint32>(number6), -456);

   844 

   845         QScriptValue str = QScriptValue(&eng, "123.0");

   846         QCOMPARE(str.toInt32(), 123);

   847         QCOMPARE(qscriptvalue_cast<qint32>(str), 123);

   848 

   849         QScriptValue str2 = QScriptValue(&eng, "NaN");

   850         QCOMPARE(str2.toInt32(), 0);

   851         QCOMPARE(qscriptvalue_cast<qint32>(str2), 0);

   852 

   853         QScriptValue str3 = QScriptValue(&eng, "Infinity");

   854         QCOMPARE(str3.toInt32(), 0);

   855         QCOMPARE(qscriptvalue_cast<qint32>(str3), 0);

   856 

   857         QScriptValue str3_2 = QScriptValue(&eng, "-Infinity");

   858         QCOMPARE(str3_2.toInt32(), 0);

   859         QCOMPARE(qscriptvalue_cast<qint32>(str3_2), 0);

   860 

   861         QScriptValue str4 = QScriptValue(&eng, "0.5");

   862         QCOMPARE(str4.toInt32(), 0);

   863         QCOMPARE(qscriptvalue_cast<qint32>(str4), 0);

   864 

   865         QScriptValue str5 = QScriptValue(&eng, "123.5");

   866         QCOMPARE(str5.toInt32(), 123);

   867         QCOMPARE(qscriptvalue_cast<qint32>(str5), 123);

   868 

   869         QScriptValue str6 = QScriptValue(&eng, "-456.5");

   870         QCOMPARE(str6.toInt32(), -456);

   871         QCOMPARE(qscriptvalue_cast<qint32>(str6), -456);

   872     }

   873     // V2 constructors

   874     {

   875         QScriptValue zer0 = QScriptValue(0.0);

   876         QCOMPARE(zer0.toInt32(), 0);

   877         QCOMPARE(qscriptvalue_cast<qint32>(zer0), 0);

   878 

   879         QScriptValue number = QScriptValue(123.0);

   880         QCOMPARE(number.toInt32(), 123);

   881         QCOMPARE(qscriptvalue_cast<qint32>(number), 123);

   882 

   883         QScriptValue number2 = QScriptValue(qSNaN());

   884         QCOMPARE(number2.toInt32(), 0);

   885         QCOMPARE(qscriptvalue_cast<qint32>(number2), 0);

   886 

   887         QScriptValue number3 = QScriptValue(+qInf());

   888         QCOMPARE(number3.toInt32(), 0);

   889         QCOMPARE(qscriptvalue_cast<qint32>(number3), 0);

   890 

   891         QScriptValue number3_2 = QScriptValue(-qInf());

   892         QCOMPARE(number3_2.toInt32(), 0);

   893         QCOMPARE(qscriptvalue_cast<qint32>(number3_2), 0);

   894 

   895         QScriptValue number4 = QScriptValue(0.5);

   896         QCOMPARE(number4.toInt32(), 0);

   897         QCOMPARE(qscriptvalue_cast<qint32>(number4), 0);

   898 

   899         QScriptValue number5 = QScriptValue(123.5);

   900         QCOMPARE(number5.toInt32(), 123);

   901         QCOMPARE(qscriptvalue_cast<qint32>(number5), 123);

   902 

   903         QScriptValue number6 = QScriptValue(-456.5);

   904         QCOMPARE(number6.toInt32(), -456);

   905         QCOMPARE(qscriptvalue_cast<qint32>(number6), -456);

   906 

   907         QScriptValue number7 = QScriptValue(0x43211234);

   908         QCOMPARE(number7.toInt32(), 0x43211234);

   909 

   910         QScriptValue str = QScriptValue("123.0");

   911         QCOMPARE(str.toInt32(), 123);

   912         QCOMPARE(qscriptvalue_cast<qint32>(str), 123);

   913 

   914         QScriptValue str2 = QScriptValue("NaN");

   915         QCOMPARE(str2.toInt32(), 0);

   916         QCOMPARE(qscriptvalue_cast<qint32>(str2), 0);

   917 

   918         QScriptValue str3 = QScriptValue("Infinity");

   919         QCOMPARE(str3.toInt32(), 0);

   920         QCOMPARE(qscriptvalue_cast<qint32>(str3), 0);

   921 

   922         QScriptValue str3_2 = QScriptValue("-Infinity");

   923         QCOMPARE(str3_2.toInt32(), 0);

   924         QCOMPARE(qscriptvalue_cast<qint32>(str3_2), 0);

   925 

   926         QScriptValue str4 = QScriptValue("0.5");

   927         QCOMPARE(str4.toInt32(), 0);

   928         QCOMPARE(qscriptvalue_cast<qint32>(str4), 0);

   929 

   930         QScriptValue str5 = QScriptValue("123.5");

   931         QCOMPARE(str5.toInt32(), 123);

   932         QCOMPARE(qscriptvalue_cast<qint32>(str5), 123);

   933 

   934         QScriptValue str6 = QScriptValue("-456.5");

   935         QCOMPARE(str6.toInt32(), -456);

   936         QCOMPARE(qscriptvalue_cast<qint32>(str6), -456);

   937     }

   938 

   939     QScriptValue inv;

   940     QCOMPARE(inv.toInt32(), 0);

   941     QCOMPARE(qscriptvalue_cast<qint32>(inv), 0);

   942 }

   943 

   944 void tst_QScriptValue::toUInt32_old()

   945 {

   946     QScriptEngine eng;

   947 

   948     {

   949         QScriptValue zer0 = QScriptValue(&eng, 0.0);

   950         QCOMPARE(zer0.toUInt32(), quint32(0));

   951         QCOMPARE(qscriptvalue_cast<quint32>(zer0), quint32(0));

   952 

   953         QScriptValue number = QScriptValue(&eng, 123.0);

   954         QCOMPARE(number.toUInt32(), quint32(123));

   955         QCOMPARE(qscriptvalue_cast<quint32>(number), quint32(123));

   956 

   957         QScriptValue number2 = QScriptValue(&eng, qSNaN());

   958         QCOMPARE(number2.toUInt32(), quint32(0));

   959         QCOMPARE(qscriptvalue_cast<quint32>(number2), quint32(0));

   960 

   961         QScriptValue number3 = QScriptValue(&eng, +qInf());

   962         QCOMPARE(number3.toUInt32(), quint32(0));

   963         QCOMPARE(qscriptvalue_cast<quint32>(number3), quint32(0));

   964 

   965         QScriptValue number3_2 = QScriptValue(&eng, -qInf());

   966         QCOMPARE(number3_2.toUInt32(), quint32(0));

   967         QCOMPARE(qscriptvalue_cast<quint32>(number3_2), quint32(0));

   968 

   969         QScriptValue number4 = QScriptValue(&eng, 0.5);

   970         QCOMPARE(number4.toUInt32(), quint32(0));

   971 

   972         QScriptValue number5 = QScriptValue(&eng, 123.5);

   973         QCOMPARE(number5.toUInt32(), quint32(123));

   974 

   975         QScriptValue number6 = QScriptValue(&eng, -456.5);

   976         QCOMPARE(number6.toUInt32(), quint32(-456));

   977         QCOMPARE(qscriptvalue_cast<quint32>(number6), quint32(-456));

   978 

   979         QScriptValue str = QScriptValue(&eng, "123.0");

   980         QCOMPARE(str.toUInt32(), quint32(123));

   981         QCOMPARE(qscriptvalue_cast<quint32>(str), quint32(123));

   982 

   983         QScriptValue str2 = QScriptValue(&eng, "NaN");

   984         QCOMPARE(str2.toUInt32(), quint32(0));

   985         QCOMPARE(qscriptvalue_cast<quint32>(str2), quint32(0));

   986 

   987         QScriptValue str3 = QScriptValue(&eng, "Infinity");

   988         QCOMPARE(str3.toUInt32(), quint32(0));

   989         QCOMPARE(qscriptvalue_cast<quint32>(str3), quint32(0));

   990 

   991         QScriptValue str3_2 = QScriptValue(&eng, "-Infinity");

   992         QCOMPARE(str3_2.toUInt32(), quint32(0));

   993         QCOMPARE(qscriptvalue_cast<quint32>(str3_2), quint32(0));

   994 

   995         QScriptValue str4 = QScriptValue(&eng, "0.5");

   996         QCOMPARE(str4.toUInt32(), quint32(0));

   997         QCOMPARE(qscriptvalue_cast<quint32>(str4), quint32(0));

   998 

   999         QScriptValue str5 = QScriptValue(&eng, "123.5");

  1000         QCOMPARE(str5.toUInt32(), quint32(123));

  1001         QCOMPARE(qscriptvalue_cast<quint32>(str5), quint32(123));

  1002 

  1003         QScriptValue str6 = QScriptValue(&eng, "-456.5");

  1004         QCOMPARE(str6.toUInt32(), quint32(-456));

  1005         QCOMPARE(qscriptvalue_cast<quint32>(str6), quint32(-456));

  1006     }

  1007     // V2 constructors

  1008     {

  1009         QScriptValue zer0 = QScriptValue(0.0);

  1010         QCOMPARE(zer0.toUInt32(), quint32(0));

  1011         QCOMPARE(qscriptvalue_cast<quint32>(zer0), quint32(0));

  1012 

  1013         QScriptValue number = QScriptValue(123.0);

  1014         QCOMPARE(number.toUInt32(), quint32(123));

  1015         QCOMPARE(qscriptvalue_cast<quint32>(number), quint32(123));

  1016 

  1017         QScriptValue number2 = QScriptValue(qSNaN());

  1018         QCOMPARE(number2.toUInt32(), quint32(0));

  1019         QCOMPARE(qscriptvalue_cast<quint32>(number2), quint32(0));

  1020 

  1021         QScriptValue number3 = QScriptValue(+qInf());

  1022         QCOMPARE(number3.toUInt32(), quint32(0));

  1023         QCOMPARE(qscriptvalue_cast<quint32>(number3), quint32(0));

  1024 

  1025         QScriptValue number3_2 = QScriptValue(-qInf());

  1026         QCOMPARE(number3_2.toUInt32(), quint32(0));

  1027         QCOMPARE(qscriptvalue_cast<quint32>(number3_2), quint32(0));

  1028 

  1029         QScriptValue number4 = QScriptValue(0.5);

  1030         QCOMPARE(number4.toUInt32(), quint32(0));

  1031 

  1032         QScriptValue number5 = QScriptValue(123.5);

  1033         QCOMPARE(number5.toUInt32(), quint32(123));

  1034 

  1035         QScriptValue number6 = QScriptValue(-456.5);

  1036         QCOMPARE(number6.toUInt32(), quint32(-456));

  1037         QCOMPARE(qscriptvalue_cast<quint32>(number6), quint32(-456));

  1038 

  1039         QScriptValue number7 = QScriptValue(0x43211234);

  1040         QCOMPARE(number7.toUInt32(), quint32(0x43211234));

  1041 

  1042         QScriptValue str = QScriptValue("123.0");

  1043         QCOMPARE(str.toUInt32(), quint32(123));

  1044         QCOMPARE(qscriptvalue_cast<quint32>(str), quint32(123));

  1045 

  1046         QScriptValue str2 = QScriptValue("NaN");

  1047         QCOMPARE(str2.toUInt32(), quint32(0));

  1048         QCOMPARE(qscriptvalue_cast<quint32>(str2), quint32(0));

  1049 

  1050         QScriptValue str3 = QScriptValue("Infinity");

  1051         QCOMPARE(str3.toUInt32(), quint32(0));

  1052         QCOMPARE(qscriptvalue_cast<quint32>(str3), quint32(0));

  1053 

  1054         QScriptValue str3_2 = QScriptValue("-Infinity");

  1055         QCOMPARE(str3_2.toUInt32(), quint32(0));

  1056         QCOMPARE(qscriptvalue_cast<quint32>(str3_2), quint32(0));

  1057 

  1058         QScriptValue str4 = QScriptValue("0.5");

  1059         QCOMPARE(str4.toUInt32(), quint32(0));

  1060         QCOMPARE(qscriptvalue_cast<quint32>(str4), quint32(0));

  1061 

  1062         QScriptValue str5 = QScriptValue("123.5");

  1063         QCOMPARE(str5.toUInt32(), quint32(123));

  1064         QCOMPARE(qscriptvalue_cast<quint32>(str5), quint32(123));

  1065 

  1066         QScriptValue str6 = QScriptValue("-456.5");

  1067         QCOMPARE(str6.toUInt32(), quint32(-456));

  1068         QCOMPARE(qscriptvalue_cast<quint32>(str6), quint32(-456));

  1069     }

  1070 

  1071     QScriptValue inv;

  1072     QCOMPARE(inv.toUInt32(), quint32(0));

  1073     QCOMPARE(qscriptvalue_cast<quint32>(inv), quint32(0));

  1074 }

  1075 

  1076 void tst_QScriptValue::toUInt16_old()

  1077 {

  1078     QScriptEngine eng;

  1079 

  1080     {

  1081         QScriptValue zer0 = QScriptValue(&eng, 0.0);

  1082         QCOMPARE(zer0.toUInt16(), quint16(0));

  1083         QCOMPARE(qscriptvalue_cast<quint16>(zer0), quint16(0));

  1084 

  1085         QScriptValue number = QScriptValue(&eng, 123.0);

  1086         QCOMPARE(number.toUInt16(), quint16(123));

  1087         QCOMPARE(qscriptvalue_cast<quint16>(number), quint16(123));

  1088 

  1089         QScriptValue number2 = QScriptValue(&eng, qSNaN());

  1090         QCOMPARE(number2.toUInt16(), quint16(0));

  1091         QCOMPARE(qscriptvalue_cast<quint16>(number2), quint16(0));

  1092 

  1093         QScriptValue number3 = QScriptValue(&eng, +qInf());

  1094         QCOMPARE(number3.toUInt16(), quint16(0));

  1095         QCOMPARE(qscriptvalue_cast<quint16>(number3), quint16(0));

  1096 

  1097         QScriptValue number3_2 = QScriptValue(&eng, -qInf());

  1098         QCOMPARE(number3_2.toUInt16(), quint16(0));

  1099         QCOMPARE(qscriptvalue_cast<quint16>(number3_2), quint16(0));

  1100 

  1101         QScriptValue number4 = QScriptValue(&eng, 0.5);

  1102         QCOMPARE(number4.toUInt16(), quint16(0));

  1103 

  1104         QScriptValue number5 = QScriptValue(&eng, 123.5);

  1105         QCOMPARE(number5.toUInt16(), quint16(123));

  1106 

  1107         QScriptValue number6 = QScriptValue(&eng, -456.5);

  1108         QCOMPARE(number6.toUInt16(), quint16(-456));

  1109         QCOMPARE(qscriptvalue_cast<quint16>(number6), quint16(-456));

  1110 

  1111         QScriptValue number7 = QScriptValue(&eng, 0x10000);

  1112         QCOMPARE(number7.toUInt16(), quint16(0));

  1113         QCOMPARE(qscriptvalue_cast<quint16>(number7), quint16(0));

  1114 

  1115         QScriptValue number8 = QScriptValue(&eng, 0x10001);

  1116         QCOMPARE(number8.toUInt16(), quint16(1));

  1117         QCOMPARE(qscriptvalue_cast<quint16>(number8), quint16(1));

  1118 

  1119         QScriptValue str = QScriptValue(&eng, "123.0");

  1120         QCOMPARE(str.toUInt16(), quint16(123));

  1121         QCOMPARE(qscriptvalue_cast<quint16>(str), quint16(123));

  1122 

  1123         QScriptValue str2 = QScriptValue(&eng, "NaN");

  1124         QCOMPARE(str2.toUInt16(), quint16(0));

  1125         QCOMPARE(qscriptvalue_cast<quint16>(str2), quint16(0));

  1126 

  1127         QScriptValue str3 = QScriptValue(&eng, "Infinity");

  1128         QCOMPARE(str3.toUInt16(), quint16(0));

  1129         QCOMPARE(qscriptvalue_cast<quint16>(str3), quint16(0));

  1130 

  1131         QScriptValue str3_2 = QScriptValue(&eng, "-Infinity");

  1132         QCOMPARE(str3_2.toUInt16(), quint16(0));

  1133         QCOMPARE(qscriptvalue_cast<quint16>(str3_2), quint16(0));

  1134 

  1135         QScriptValue str4 = QScriptValue(&eng, "0.5");