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

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

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

    41 

    42 

    43 #include <QtTest/QtTest>

    44 #include <QtGui/QPushButton>

    45 #include <QtCore/qnumeric.h>

    46 

    47 #include <QtScript/qscriptclass.h>

    48 #include <QtScript/qscriptvalue.h>

    49 #include <QtScript/qscriptengine.h>

    50 

    51 //TESTED_CLASS=

    52 //TESTED_FILES=

    53 

    54 QT_BEGIN_NAMESPACE

    55 extern bool qt_script_isJITEnabled();

    56 QT_END_NAMESPACE

    57 

    58 class tst_QScriptValue : public QObject

    59 {

    60     Q_OBJECT

    61 

    62 public:

    63     tst_QScriptValue();

    64     virtual ~tst_QScriptValue();

    65 

    66 private slots:

    67     void ctor();

    68     void engine();

    69     void toString();

    70     void toNumber();

    71     void toBoolean();

    72     void toBool();

    73     void toInteger();

    74     void toInt32();

    75     void toUInt32();

    76     void toUInt16();

    77     void toVariant();

    78     void toQObject();

    79     void toObject();

    80     void toDateTime();

    81     void toRegExp();

    82     void instanceOf();

    83     void isArray();

    84     void isDate();

    85     void isError();

    86     void isRegExp();

    87     void getSetPrototype();

    88     void getSetScope();

    89     void getSetProperty();

    90     void arrayElementGetterSetter();

    91     void getSetData();

    92     void getSetScriptClass();

    93     void call();

    94     void construct();

    95     void lessThan();

    96     void equals();

    97     void strictlyEquals();

    98     void castToPointer();

    99     void prettyPrinter_data();

   100     void prettyPrinter();

   101     void engineDeleted();

   102     void valueOfWithClosure();

   103     void objectId();

   104 };

   105 

   106 tst_QScriptValue::tst_QScriptValue()

   107 {

   108 }

   109 

   110 tst_QScriptValue::~tst_QScriptValue()

   111 {

   112 }

   113 

   114 void tst_QScriptValue::ctor()

   115 {

   116     QScriptEngine eng;

   117     {

   118         QScriptValue v;

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

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

   121     }

   122     {

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

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

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

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

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

   128     }

   129     {

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

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

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

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

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

   135     }

   136     {

   137         QScriptValue v(&eng, false);

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

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

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

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

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

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

   144     }

   145     {

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

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

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

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

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

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

   152     }

   153     {

   154         QScriptValue v(int(0x43211234));

   155         QVERIFY(v.isNumber());

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

   157     }

   158     {

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

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

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

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

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

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

   165     }

   166     {

   167         QScriptValue v(uint(0x43211234));

   168         QVERIFY(v.isNumber());

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

   170     }

   171     {

   172         QScriptValue v(&eng, 1.0);

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

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

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

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

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

   178     }

   179     {

   180         QScriptValue v(12345678910.5);

   181         QVERIFY(v.isNumber());

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

   183     }

   184     {

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

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

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

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

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

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

   191     }

   192     {

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

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

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

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

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

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

   199     }

   200     // copy constructor, operator=

   201     {

   202         QScriptValue v(&eng, 1.0);

   203         QScriptValue v2(v);

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

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

   206 

   207         QScriptValue v3(v);

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

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

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

   211 

   212         QScriptValue v4(&eng, 2.0);

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

   214         v3 = v4;

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

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

   217 

   218         v2 = QScriptValue();

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

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

   221 

   222         QScriptValue v5(v);

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

   224         v = QScriptValue();

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

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

   227     }

   228 

   229     // constructors that take no engine argument

   230     {

   231         QScriptValue v(QScriptValue::UndefinedValue);

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

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

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

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

   236     }

   237     {

   238         QScriptValue v(QScriptValue::NullValue);

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

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

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

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

   243     }

   244     {

   245         QScriptValue v(false);

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

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

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

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

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

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

   252     }

   253     {

   254         QScriptValue v(int(1));

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

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

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

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

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

   260     }

   261     {

   262         QScriptValue v(uint(1));

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

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

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

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

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

   268     }

   269     {

   270         QScriptValue v(1.0);

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

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

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

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

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

   276     }

   277     {

   278         QScriptValue v("ciao");

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

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

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

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

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

   284     }

   285     {

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

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

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

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

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

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

   292     }

   293     // copy constructor, operator=

   294     {

   295         QScriptValue v(1.0);

   296         QScriptValue v2(v);

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

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

   299 

   300         QScriptValue v3(v);

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

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

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

   304 

   305         QScriptValue v4(2.0);

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

   307         v3 = v4;

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

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

   310 

   311         v2 = QScriptValue();

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

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

   314 

   315         QScriptValue v5(v);

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

   317         v = QScriptValue();

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

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

   320     }

   321 

   322     // 0 engine

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

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

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

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

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

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

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

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

   331 }

   332 

   333 void tst_QScriptValue::engine()

   334 {

   335     QScriptEngine eng;

   336     QScriptValue object = eng.newObject();

   337     QCOMPARE(object.engine(), &eng);

   338 }

   339 

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

   341 {

   342     return eng->undefinedValue();

   343 }

   344 

   345 void tst_QScriptValue::toString()

   346 {

   347     QScriptEngine eng;

   348 

   349     QScriptValue undefined = eng.undefinedValue();

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

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

   352 

   353     QScriptValue null = eng.nullValue();

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

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

   356 

   357     {

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

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

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

   361 

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

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

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

   365     }

   366     {

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

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

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

   370     }

   371     {

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

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

   374     }

   375     {

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

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

   378 

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

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

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

   382     }

   383 

   384     QScriptValue object = eng.newObject();

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

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

   387 

   388     QScriptValue fun = eng.newFunction(myFunction);

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

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

   391 

   392     // toString() that throws exception

   393     {

   394         QScriptValue objectObject = eng.evaluate(

   395             "(function(){"

   396             "  o = { };"

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

   398             "  return o;"

   399             "})()");

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

   401         QVERIFY(eng.hasUncaughtException());

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

   403     }

   404     {

   405         eng.clearExceptions();

   406         QScriptValue objectObject = eng.evaluate(

   407             "(function(){"

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

   409             "  f.prototype = Date;"

   410             "  return new f;"

   411             "})()");

   412         QVERIFY(!eng.hasUncaughtException());

   413         QVERIFY(objectObject.isObject());

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

   415         QVERIFY(eng.hasUncaughtException());

   416         eng.clearExceptions();

   417     }

   418 

   419     QScriptValue inv = QScriptValue();

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

   421 

   422     // V2 constructors

   423     {

   424         QScriptValue falskt = QScriptValue(false);

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

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

   427 

   428         QScriptValue sant = QScriptValue(true);

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

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

   431 

   432         QScriptValue number = QScriptValue(123);

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

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

   435 

   436         QScriptValue number2(int(0x43211234));

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

   438 

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

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

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

   442     }

   443 

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

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

   446     QScriptValue variant = eng.newVariant(123);

   447     QVERIFY(variant.isVariant());

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

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

   450     QVERIFY(variant.isVariant());

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

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

   453     QVERIFY(variant.isVariant());

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

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

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

   457 }

   458 

   459 void tst_QScriptValue::toNumber()

   460 {

   461     QScriptEngine eng;

   462 

   463     QScriptValue undefined = eng.undefinedValue();

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

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

   466 

   467     QScriptValue null = eng.nullValue();

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

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

   470 

   471     {

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

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

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

   475 

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

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

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

   479 

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

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

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

   483 

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

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

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

   487 

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

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

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

   491     }

   492 

   493     QScriptValue object = eng.newObject();

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

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

   496 

   497     QScriptValue fun = eng.newFunction(myFunction);

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

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

   500 

   501     QScriptValue inv = QScriptValue();

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

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

   504 

   505     // V2 constructors

   506     {

   507         QScriptValue falskt = QScriptValue(false);

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

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

   510 

   511         QScriptValue sant = QScriptValue(true);

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

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

   514 

   515         QScriptValue number = QScriptValue(123.0);

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

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

   518 

   519         QScriptValue number2(int(0x43211234));

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

   521 

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

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

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

   525 

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

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

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

   529     }

   530 }

   531 

   532 void tst_QScriptValue::toBoolean() // deprecated

   533 {

   534     QScriptEngine eng;

   535 

   536     QScriptValue undefined = eng.undefinedValue();

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

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

   539 

   540     QScriptValue null = eng.nullValue();

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

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

   543 

   544     {

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

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

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

   548 

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

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

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

   552 

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

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

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

   556 

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

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

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

   560 

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

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

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

   564 

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

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

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

   568 

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

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

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

   572 

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

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

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

   576     }

   577 

   578     QScriptValue object = eng.newObject();

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

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

   581 

   582     QScriptValue fun = eng.newFunction(myFunction);

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

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

   585 

   586     QScriptValue inv = QScriptValue();

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

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

   589 

   590     // V2 constructors

   591     {

   592         QScriptValue falskt = QScriptValue(false);

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

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

   595 

   596         QScriptValue sant = QScriptValue(true);

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

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

   599 

   600         QScriptValue number = QScriptValue(0.0);

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

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

   603 

   604         QScriptValue number2 = QScriptValue(qSNaN());

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

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

   607 

   608         QScriptValue number3 = QScriptValue(123.0);

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

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

   611 

   612         QScriptValue number4 = QScriptValue(-456.0);

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

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

   615 

   616         QScriptValue number5 = QScriptValue(0x43211234);

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

   618 

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

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

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

   622 

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

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

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

   626     }

   627 }

   628 

   629 void tst_QScriptValue::toBool()

   630 {

   631     QScriptEngine eng;

   632 

   633     QScriptValue undefined = eng.undefinedValue();

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

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

   636 

   637     QScriptValue null = eng.nullValue();

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

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

   640 

   641     {

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

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

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

   645 

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

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

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

   649 

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

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

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

   653 

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

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

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

   657 

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

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

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

   661 

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

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

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

   665 

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

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

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

   669 

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

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

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

   673     }

   674 

   675     QScriptValue object = eng.newObject();

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

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

   678 

   679     QScriptValue fun = eng.newFunction(myFunction);

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

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

   682 

   683     QScriptValue inv = QScriptValue();

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

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

   686 

   687     // V2 constructors

   688     {

   689         QScriptValue falskt = QScriptValue(false);

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

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

   692 

   693         QScriptValue sant = QScriptValue(true);

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

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

   696 

   697         QScriptValue number = QScriptValue(0.0);

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

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

   700 

   701         QScriptValue number2 = QScriptValue(qSNaN());

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

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

   704 

   705         QScriptValue number3 = QScriptValue(123.0);

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

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

   708 

   709         QScriptValue number4 = QScriptValue(-456.0);

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

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

   712 

   713         QScriptValue number5 = QScriptValue(0x43211234);

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

   715 

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

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

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

   719 

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

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

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

   723     }

   724 }

   725 

   726 void tst_QScriptValue::toInteger()

   727 {

   728     QScriptEngine eng;

   729 

   730     {

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

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

   733 

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

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

   736 

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

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

   739 

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

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

   742 

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

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

   745 

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

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

   748 

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

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

   751 

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

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

   754 

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

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

   757 

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

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

   760 

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

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

   763 

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

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

   766     }

   767     // V2 constructors

   768     {

   769         QScriptValue number = QScriptValue(123.0);

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

   771 

   772         QScriptValue number2 = QScriptValue(qSNaN());

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

   774 

   775         QScriptValue number3 = QScriptValue(qInf());

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

   777 

   778         QScriptValue number4 = QScriptValue(0.5);

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

   780 

   781         QScriptValue number5 = QScriptValue(123.5);

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

   783 

   784         QScriptValue number6 = QScriptValue(-456.5);

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

   786 

   787         QScriptValue number7 = QScriptValue(0x43211234);

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

   789 

   790         QScriptValue str = QScriptValue("123.0");

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

   792 

   793         QScriptValue str2 = QScriptValue("NaN");

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

   795 

   796         QScriptValue str3 = QScriptValue("Infinity");

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

   798 

   799         QScriptValue str4 = QScriptValue("0.5");

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

   801 

   802         QScriptValue str5 = QScriptValue("123.5");

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

   804 

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

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

   807     }

   808 

   809     QScriptValue inv;

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

   811 }

   812 

   813 void tst_QScriptValue::toInt32()

   814 {

   815     QScriptEngine eng;

   816 

   817     {

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

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

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

   821 

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

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

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

   825 

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

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

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

   829 

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

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

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

   833 

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

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

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

   837 

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

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

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

   841 

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

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

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

   845 

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

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

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

   849 

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

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

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

   853 

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

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

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

   857 

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

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

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

   861 

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

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

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

   865 

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

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

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

   869 

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

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

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

   873 

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

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

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

   877     }

   878     // V2 constructors

   879     {

   880         QScriptValue zer0 = QScriptValue(0.0);

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

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

   883 

   884         QScriptValue number = QScriptValue(123.0);

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

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

   887 

   888         QScriptValue number2 = QScriptValue(qSNaN());

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

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

   891 

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

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

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

   895 

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

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

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

   899 

   900         QScriptValue number4 = QScriptValue(0.5);

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

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

   903 

   904         QScriptValue number5 = QScriptValue(123.5);

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

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

   907 

   908         QScriptValue number6 = QScriptValue(-456.5);

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

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

   911 

   912         QScriptValue number7 = QScriptValue(0x43211234);

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

   914 

   915         QScriptValue str = QScriptValue("123.0");

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

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

   918 

   919         QScriptValue str2 = QScriptValue("NaN");

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

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

   922 

   923         QScriptValue str3 = QScriptValue("Infinity");

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

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

   926 

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

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

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

   930 

   931         QScriptValue str4 = QScriptValue("0.5");

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

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

   934 

   935         QScriptValue str5 = QScriptValue("123.5");

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

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

   938 

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

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

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

   942     }

   943 

   944     QScriptValue inv;

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

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

   947 }

   948 

   949 void tst_QScriptValue::toUInt32()

   950 {

   951     QScriptEngine eng;

   952 

   953     {

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

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

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

   957 

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

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

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

   961 

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

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

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

   965 

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

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

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

   969 

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

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

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

   973 

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

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

   976 

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

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

   979 

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

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

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

   983 

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

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

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

   987 

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

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

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

   991 

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

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

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

   995 

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

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

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

   999 

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

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

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

  1003 

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

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

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

  1007 

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

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

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

  1011     }

  1012     // V2 constructors

  1013     {

  1014         QScriptValue zer0 = QScriptValue(0.0);

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

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

  1017 

  1018         QScriptValue number = QScriptValue(123.0);

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

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

  1021 

  1022         QScriptValue number2 = QScriptValue(qSNaN());

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

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

  1025 

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

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

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

  1029 

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

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

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

  1033 

  1034         QScriptValue number4 = QScriptValue(0.5);

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

  1036 

  1037         QScriptValue number5 = QScriptValue(123.5);

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

  1039 

  1040         QScriptValue number6 = QScriptValue(-456.5);

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

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

  1043 

  1044         QScriptValue number7 = QScriptValue(0x43211234);

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

  1046 

  1047         QScriptValue str = QScriptValue("123.0");

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

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

  1050 

  1051         QScriptValue str2 = QScriptValue("NaN");

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

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

  1054 

  1055         QScriptValue str3 = QScriptValue("Infinity");

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

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

  1058 

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

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

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

  1062 

  1063         QScriptValue str4 = QScriptValue("0.5");

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

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

  1066 

  1067         QScriptValue str5 = QScriptValue("123.5");

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

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

  1070 

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

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

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

  1074     }

  1075 

  1076     QScriptValue inv;

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

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

  1079 }

  1080 

  1081 void tst_QScriptValue::toUInt16()

  1082 {

  1083     QScriptEngine eng;

  1084 

  1085     {

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

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

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

  1089 

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

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

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

  1093 

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

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

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

  1097 

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

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

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

  1101 

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

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

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

  1105 

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

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

  1108 

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

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

  1111 

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

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

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

  1115 

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

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

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

  1119 

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

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

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

  1123 

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

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

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

  1127 

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

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

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

  1131 

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

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