code.vuplus.com Git - vuplus_webkit/blob - Source/JavaScriptCore/qt/tests/qscriptvalue/tst_qscriptvalue_generated_istype.cpp

   1 /*
   2     Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
   3
   4     This library is free software; you can redistribute it and/or
   5     modify it under the terms of the GNU Library General Public
   6     License as published by the Free Software Foundation; either
   7     version 2 of the License, or (at your option) any later version.
   8
   9     This library is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12     Library General Public License for more details.
  13
  14     You should have received a copy of the GNU Library General Public License
  15     along with this library; see the file COPYING.LIB.  If not, write to
  16     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17     Boston, MA 02110-1301, USA.
  18 */
  19
  20
  21 /****************************************************************************
  22 *************** This file has been generated. DO NOT MODIFY! ****************
  23 ****************************************************************************/
  24
  25 #include "tst_qscriptvalue.h"
  26
  27
  28 static const QString isValid_array[] = {
  29     "QScriptValue(QScriptValue::UndefinedValue)",
  30     "QScriptValue(QScriptValue::NullValue)",
  31     "QScriptValue(true)",
  32     "QScriptValue(false)",
  33     "QScriptValue(int(122))",
  34     "QScriptValue(uint(124))",
  35     "QScriptValue(0)",
  36     "QScriptValue(0.0)",
  37     "QScriptValue(123.0)",
  38     "QScriptValue(6.37e-8)",
  39     "QScriptValue(-6.37e-8)",
  40     "QScriptValue(0x43211234)",
  41     "QScriptValue(0x10000)",
  42     "QScriptValue(0x10001)",
  43     "QScriptValue(qSNaN())",
  44     "QScriptValue(qQNaN())",
  45     "QScriptValue(qInf())",
  46     "QScriptValue(-qInf())",
  47     "QScriptValue(\"NaN\")",
  48     "QScriptValue(\"Infinity\")",
  49     "QScriptValue(\"-Infinity\")",
  50     "QScriptValue(\"ciao\")",
  51     "QScriptValue(QString::fromLatin1(\"ciao\"))",
  52     "QScriptValue(QString(\"\"))",
  53     "QScriptValue(QString())",
  54     "QScriptValue(QString(\"0\"))",
  55     "QScriptValue(QString(\"123\"))",
  56     "QScriptValue(QString(\"12.4\"))",
  57     "QScriptValue(0, QScriptValue::UndefinedValue)",
  58     "QScriptValue(0, QScriptValue::NullValue)",
  59     "QScriptValue(0, true)",
  60     "QScriptValue(0, false)",
  61     "QScriptValue(0, int(122))",
  62     "QScriptValue(0, uint(124))",
  63     "QScriptValue(0, 0)",
  64     "QScriptValue(0, 0.0)",
  65     "QScriptValue(0, 123.0)",
  66     "QScriptValue(0, 6.37e-8)",
  67     "QScriptValue(0, -6.37e-8)",
  68     "QScriptValue(0, 0x43211234)",
  69     "QScriptValue(0, 0x10000)",
  70     "QScriptValue(0, 0x10001)",
  71     "QScriptValue(0, qSNaN())",
  72     "QScriptValue(0, qQNaN())",
  73     "QScriptValue(0, qInf())",
  74     "QScriptValue(0, -qInf())",
  75     "QScriptValue(0, \"NaN\")",
  76     "QScriptValue(0, \"Infinity\")",
  77     "QScriptValue(0, \"-Infinity\")",
  78     "QScriptValue(0, \"ciao\")",
  79     "QScriptValue(0, QString::fromLatin1(\"ciao\"))",
  80     "QScriptValue(0, QString(\"\"))",
  81     "QScriptValue(0, QString())",
  82     "QScriptValue(0, QString(\"0\"))",
  83     "QScriptValue(0, QString(\"123\"))",
  84     "QScriptValue(0, QString(\"12.3\"))",
  85     "QScriptValue(engine, QScriptValue::UndefinedValue)",
  86     "QScriptValue(engine, QScriptValue::NullValue)",
  87     "QScriptValue(engine, true)",
  88     "QScriptValue(engine, false)",
  89     "QScriptValue(engine, int(122))",
  90     "QScriptValue(engine, uint(124))",
  91     "QScriptValue(engine, 0)",
  92     "QScriptValue(engine, 0.0)",
  93     "QScriptValue(engine, 123.0)",
  94     "QScriptValue(engine, 6.37e-8)",
  95     "QScriptValue(engine, -6.37e-8)",
  96     "QScriptValue(engine, 0x43211234)",
  97     "QScriptValue(engine, 0x10000)",
  98     "QScriptValue(engine, 0x10001)",
  99     "QScriptValue(engine, qSNaN())",
 100     "QScriptValue(engine, qQNaN())",
 101     "QScriptValue(engine, qInf())",
 102     "QScriptValue(engine, -qInf())",
 103     "QScriptValue(engine, \"NaN\")",
 104     "QScriptValue(engine, \"Infinity\")",
 105     "QScriptValue(engine, \"-Infinity\")",
 106     "QScriptValue(engine, \"ciao\")",
 107     "QScriptValue(engine, QString::fromLatin1(\"ciao\"))",
 108     "QScriptValue(engine, QString(\"\"))",
 109     "QScriptValue(engine, QString())",
 110     "QScriptValue(engine, QString(\"0\"))",
 111     "QScriptValue(engine, QString(\"123\"))",
 112     "QScriptValue(engine, QString(\"1.23\"))",
 113     "engine->evaluate(\"[]\")",
 114     "engine->evaluate(\"{}\")",
 115     "engine->evaluate(\"Object.prototype\")",
 116     "engine->evaluate(\"Date.prototype\")",
 117     "engine->evaluate(\"Array.prototype\")",
 118     "engine->evaluate(\"Function.prototype\")",
 119     "engine->evaluate(\"Error.prototype\")",
 120     "engine->evaluate(\"Object\")",
 121     "engine->evaluate(\"Array\")",
 122     "engine->evaluate(\"Number\")",
 123     "engine->evaluate(\"Function\")",
 124     "engine->evaluate(\"(function() { return 1; })\")",
 125     "engine->evaluate(\"(function() { return 'ciao'; })\")",
 126     "engine->evaluate(\"(function() { throw new Error('foo'); })\")",
 127     "engine->evaluate(\"/foo/\")",
 128     "engine->evaluate(\"new Object()\")",
 129     "engine->evaluate(\"new Array()\")",
 130     "engine->evaluate(\"new Error()\")",
 131     "engine->evaluate(\"a = new Object(); a.foo = 22; a.foo\")",
 132     "engine->evaluate(\"Undefined\")",
 133     "engine->evaluate(\"Null\")",
 134     "engine->evaluate(\"True\")",
 135     "engine->evaluate(\"False\")",
 136     "engine->evaluate(\"undefined\")",
 137     "engine->evaluate(\"null\")",
 138     "engine->evaluate(\"true\")",
 139     "engine->evaluate(\"false\")",
 140     "engine->evaluate(\"122\")",
 141     "engine->evaluate(\"124\")",
 142     "engine->evaluate(\"0\")",
 143     "engine->evaluate(\"0.0\")",
 144     "engine->evaluate(\"123.0\")",
 145     "engine->evaluate(\"6.37e-8\")",
 146     "engine->evaluate(\"-6.37e-8\")",
 147     "engine->evaluate(\"0x43211234\")",
 148     "engine->evaluate(\"0x10000\")",
 149     "engine->evaluate(\"0x10001\")",
 150     "engine->evaluate(\"NaN\")",
 151     "engine->evaluate(\"Infinity\")",
 152     "engine->evaluate(\"-Infinity\")",
 153     "engine->evaluate(\"'ciao'\")",
 154     "engine->evaluate(\"''\")",
 155     "engine->evaluate(\"'0'\")",
 156     "engine->evaluate(\"'123'\")",
 157     "engine->evaluate(\"'12.4'\")",
 158     "engine->nullValue()",
 159     "engine->undefinedValue()",
 160     "engine->newObject()",
 161     "engine->newArray()",
 162     "engine->newArray(10)"};
 163
 164 void tst_QScriptValue::isValid_data()
 165 {
 166     QTest::addColumn<QScriptValue>("value");
 167     QTest::addColumn<bool>("expected");
 168     if (m_engine)
 169         delete m_engine;
 170     m_engine = new QScriptEngine();
 171     QSet<QString> expectedValue;
 172     expectedValue.reserve(134);
 173     for (uint i = 0; i < 134; ++i)
 174         expectedValue.insert(isValid_array[i]);
 175     for (uint i = 0; i < 135; ++i) {
 176         QPair<QString, QScriptValue> testcase = initScriptValues(i);
 177         QTest::newRow(testcase.first.toAscii().constData()) << testcase.second << expectedValue.contains(testcase.first);
 178     }
 179 }
 180
 181 void tst_QScriptValue::isValid()
 182 {
 183     QFETCH(QScriptValue, value);
 184     QFETCH(bool, expected);
 185     QCOMPARE(value.isValid(), expected);
 186     QCOMPARE(value.isValid(), expected);
 187 }
 188
 189 static const QString isBool_array[] = {
 190     "QScriptValue(true)",
 191     "QScriptValue(false)",
 192     "QScriptValue(0, true)",
 193     "QScriptValue(0, false)",
 194     "QScriptValue(engine, true)",
 195     "QScriptValue(engine, false)",
 196     "engine->evaluate(\"true\")",
 197     "engine->evaluate(\"false\")"};
 198
 199 void tst_QScriptValue::isBool_data()
 200 {
 201     QTest::addColumn<QScriptValue>("value");
 202     QTest::addColumn<bool>("expected");
 203     if (m_engine)
 204         delete m_engine;
 205     m_engine = new QScriptEngine();
 206     QSet<QString> expectedValue;
 207     expectedValue.reserve(8);
 208     for (uint i = 0; i < 8; ++i)
 209         expectedValue.insert(isBool_array[i]);
 210     for (uint i = 0; i < 135; ++i) {
 211         QPair<QString, QScriptValue> testcase = initScriptValues(i);
 212         QTest::newRow(testcase.first.toAscii().constData()) << testcase.second << expectedValue.contains(testcase.first);
 213     }
 214 }
 215
 216 void tst_QScriptValue::isBool()
 217 {
 218     QFETCH(QScriptValue, value);
 219     QFETCH(bool, expected);
 220     QCOMPARE(value.isBool(), expected);
 221     QCOMPARE(value.isBool(), expected);
 222 }
 223
 224 static const QString isBoolean_array[] = {
 225     "QScriptValue(true)",
 226     "QScriptValue(false)",
 227     "QScriptValue(0, true)",
 228     "QScriptValue(0, false)",
 229     "QScriptValue(engine, true)",
 230     "QScriptValue(engine, false)",
 231     "engine->evaluate(\"true\")",
 232     "engine->evaluate(\"false\")"};
 233
 234 void tst_QScriptValue::isBoolean_data()
 235 {
 236     QTest::addColumn<QScriptValue>("value");
 237     QTest::addColumn<bool>("expected");
 238     if (m_engine)
 239         delete m_engine;
 240     m_engine = new QScriptEngine();
 241     QSet<QString> expectedValue;
 242     expectedValue.reserve(8);
 243     for (uint i = 0; i < 8; ++i)
 244         expectedValue.insert(isBoolean_array[i]);
 245     for (uint i = 0; i < 135; ++i) {
 246         QPair<QString, QScriptValue> testcase = initScriptValues(i);
 247         QTest::newRow(testcase.first.toAscii().constData()) << testcase.second << expectedValue.contains(testcase.first);
 248     }
 249 }
 250
 251 void tst_QScriptValue::isBoolean()
 252 {
 253     QFETCH(QScriptValue, value);
 254     QFETCH(bool, expected);
 255     QCOMPARE(value.isBoolean(), expected);
 256     QCOMPARE(value.isBoolean(), expected);
 257 }
 258
 259 static const QString isNumber_array[] = {
 260     "QScriptValue(int(122))",
 261     "QScriptValue(uint(124))",
 262     "QScriptValue(0)",
 263     "QScriptValue(0.0)",
 264     "QScriptValue(123.0)",
 265     "QScriptValue(6.37e-8)",
 266     "QScriptValue(-6.37e-8)",
 267     "QScriptValue(0x43211234)",
 268     "QScriptValue(0x10000)",
 269     "QScriptValue(0x10001)",
 270     "QScriptValue(qSNaN())",
 271     "QScriptValue(qQNaN())",
 272     "QScriptValue(qInf())",
 273     "QScriptValue(-qInf())",
 274     "QScriptValue(0, int(122))",
 275     "QScriptValue(0, uint(124))",
 276     "QScriptValue(0, 0)",
 277     "QScriptValue(0, 0.0)",
 278     "QScriptValue(0, 123.0)",
 279     "QScriptValue(0, 6.37e-8)",
 280     "QScriptValue(0, -6.37e-8)",
 281     "QScriptValue(0, 0x43211234)",
 282     "QScriptValue(0, 0x10000)",
 283     "QScriptValue(0, 0x10001)",
 284     "QScriptValue(0, qSNaN())",
 285     "QScriptValue(0, qQNaN())",
 286     "QScriptValue(0, qInf())",
 287     "QScriptValue(0, -qInf())",
 288     "QScriptValue(engine, int(122))",
 289     "QScriptValue(engine, uint(124))",
 290     "QScriptValue(engine, 0)",
 291     "QScriptValue(engine, 0.0)",
 292     "QScriptValue(engine, 123.0)",
 293     "QScriptValue(engine, 6.37e-8)",
 294     "QScriptValue(engine, -6.37e-8)",
 295     "QScriptValue(engine, 0x43211234)",
 296     "QScriptValue(engine, 0x10000)",
 297     "QScriptValue(engine, 0x10001)",
 298     "QScriptValue(engine, qSNaN())",
 299     "QScriptValue(engine, qQNaN())",
 300     "QScriptValue(engine, qInf())",
 301     "QScriptValue(engine, -qInf())",
 302     "engine->evaluate(\"a = new Object(); a.foo = 22; a.foo\")",
 303     "engine->evaluate(\"122\")",
 304     "engine->evaluate(\"124\")",
 305     "engine->evaluate(\"0\")",
 306     "engine->evaluate(\"0.0\")",
 307     "engine->evaluate(\"123.0\")",
 308     "engine->evaluate(\"6.37e-8\")",
 309     "engine->evaluate(\"-6.37e-8\")",
 310     "engine->evaluate(\"0x43211234\")",
 311     "engine->evaluate(\"0x10000\")",
 312     "engine->evaluate(\"0x10001\")",
 313     "engine->evaluate(\"NaN\")",
 314     "engine->evaluate(\"Infinity\")",
 315     "engine->evaluate(\"-Infinity\")"};
 316
 317 void tst_QScriptValue::isNumber_data()
 318 {
 319     QTest::addColumn<QScriptValue>("value");
 320     QTest::addColumn<bool>("expected");
 321     if (m_engine)
 322         delete m_engine;
 323     m_engine = new QScriptEngine();
 324     QSet<QString> expectedValue;
 325     expectedValue.reserve(56);
 326     for (uint i = 0; i < 56; ++i)
 327         expectedValue.insert(isNumber_array[i]);
 328     for (uint i = 0; i < 135; ++i) {
 329         QPair<QString, QScriptValue> testcase = initScriptValues(i);
 330         QTest::newRow(testcase.first.toAscii().constData()) << testcase.second << expectedValue.contains(testcase.first);
 331     }
 332 }
 333
 334 void tst_QScriptValue::isNumber()
 335 {
 336     QFETCH(QScriptValue, value);
 337     QFETCH(bool, expected);
 338     QCOMPARE(value.isNumber(), expected);
 339     QCOMPARE(value.isNumber(), expected);
 340 }
 341
 342 static const QString isFunction_array[] = {
 343     "engine->evaluate(\"Function.prototype\")",
 344     "engine->evaluate(\"Object\")",
 345     "engine->evaluate(\"Array\")",
 346     "engine->evaluate(\"Number\")",
 347     "engine->evaluate(\"Function\")",
 348     "engine->evaluate(\"(function() { return 1; })\")",
 349     "engine->evaluate(\"(function() { return 'ciao'; })\")",
 350     "engine->evaluate(\"(function() { throw new Error('foo'); })\")",
 351     "engine->evaluate(\"/foo/\")"};
 352
 353 void tst_QScriptValue::isFunction_data()
 354 {
 355     QTest::addColumn<QScriptValue>("value");
 356     QTest::addColumn<bool>("expected");
 357     if (m_engine)
 358         delete m_engine;
 359     m_engine = new QScriptEngine();
 360     QSet<QString> expectedValue;
 361     expectedValue.reserve(9);
 362     for (uint i = 0; i < 9; ++i)
 363         expectedValue.insert(isFunction_array[i]);
 364     for (uint i = 0; i < 135; ++i) {
 365         QPair<QString, QScriptValue> testcase = initScriptValues(i);
 366         QTest::newRow(testcase.first.toAscii().constData()) << testcase.second << expectedValue.contains(testcase.first);
 367     }
 368 }
 369
 370 void tst_QScriptValue::isFunction()
 371 {
 372     QFETCH(QScriptValue, value);
 373     QFETCH(bool, expected);
 374     QCOMPARE(value.isFunction(), expected);
 375     QCOMPARE(value.isFunction(), expected);
 376 }
 377
 378 static const QString isNull_array[] = {
 379     "QScriptValue(QScriptValue::NullValue)",
 380     "QScriptValue(0, QScriptValue::NullValue)",
 381     "QScriptValue(engine, QScriptValue::NullValue)",
 382     "engine->evaluate(\"null\")",
 383     "engine->nullValue()"};
 384
 385 void tst_QScriptValue::isNull_data()
 386 {
 387     QTest::addColumn<QScriptValue>("value");
 388     QTest::addColumn<bool>("expected");
 389     if (m_engine)
 390         delete m_engine;
 391     m_engine = new QScriptEngine();
 392     QSet<QString> expectedValue;
 393     expectedValue.reserve(5);
 394     for (uint i = 0; i < 5; ++i)
 395         expectedValue.insert(isNull_array[i]);
 396     for (uint i = 0; i < 135; ++i) {
 397         QPair<QString, QScriptValue> testcase = initScriptValues(i);
 398         QTest::newRow(testcase.first.toAscii().constData()) << testcase.second << expectedValue.contains(testcase.first);
 399     }
 400 }
 401
 402 void tst_QScriptValue::isNull()
 403 {
 404     QFETCH(QScriptValue, value);
 405     QFETCH(bool, expected);
 406     QCOMPARE(value.isNull(), expected);
 407     QCOMPARE(value.isNull(), expected);
 408 }
 409
 410 static const QString isString_array[] = {
 411     "QScriptValue(\"NaN\")",
 412     "QScriptValue(\"Infinity\")",
 413     "QScriptValue(\"-Infinity\")",
 414     "QScriptValue(\"ciao\")",
 415     "QScriptValue(QString::fromLatin1(\"ciao\"))",
 416     "QScriptValue(QString(\"\"))",
 417     "QScriptValue(QString())",
 418     "QScriptValue(QString(\"0\"))",
 419     "QScriptValue(QString(\"123\"))",
 420     "QScriptValue(QString(\"12.4\"))",
 421     "QScriptValue(0, \"NaN\")",
 422     "QScriptValue(0, \"Infinity\")",
 423     "QScriptValue(0, \"-Infinity\")",
 424     "QScriptValue(0, \"ciao\")",
 425     "QScriptValue(0, QString::fromLatin1(\"ciao\"))",
 426     "QScriptValue(0, QString(\"\"))",
 427     "QScriptValue(0, QString())",
 428     "QScriptValue(0, QString(\"0\"))",
 429     "QScriptValue(0, QString(\"123\"))",
 430     "QScriptValue(0, QString(\"12.3\"))",
 431     "QScriptValue(engine, \"NaN\")",
 432     "QScriptValue(engine, \"Infinity\")",
 433     "QScriptValue(engine, \"-Infinity\")",
 434     "QScriptValue(engine, \"ciao\")",
 435     "QScriptValue(engine, QString::fromLatin1(\"ciao\"))",
 436     "QScriptValue(engine, QString(\"\"))",
 437     "QScriptValue(engine, QString())",
 438     "QScriptValue(engine, QString(\"0\"))",
 439     "QScriptValue(engine, QString(\"123\"))",
 440     "QScriptValue(engine, QString(\"1.23\"))",
 441     "engine->evaluate(\"'ciao'\")",
 442     "engine->evaluate(\"''\")",
 443     "engine->evaluate(\"'0'\")",
 444     "engine->evaluate(\"'123'\")",
 445     "engine->evaluate(\"'12.4'\")"};
 446
 447 void tst_QScriptValue::isString_data()
 448 {
 449     QTest::addColumn<QScriptValue>("value");
 450     QTest::addColumn<bool>("expected");
 451     if (m_engine)
 452         delete m_engine;
 453     m_engine = new QScriptEngine();
 454     QSet<QString> expectedValue;
 455     expectedValue.reserve(35);
 456     for (uint i = 0; i < 35; ++i)
 457         expectedValue.insert(isString_array[i]);
 458     for (uint i = 0; i < 135; ++i) {
 459         QPair<QString, QScriptValue> testcase = initScriptValues(i);
 460         QTest::newRow(testcase.first.toAscii().constData()) << testcase.second << expectedValue.contains(testcase.first);
 461     }
 462 }
 463
 464 void tst_QScriptValue::isString()
 465 {
 466     QFETCH(QScriptValue, value);
 467     QFETCH(bool, expected);
 468     QCOMPARE(value.isString(), expected);
 469     QCOMPARE(value.isString(), expected);
 470 }
 471
 472 static const QString isUndefined_array[] = {
 473     "QScriptValue(QScriptValue::UndefinedValue)",
 474     "QScriptValue(0, QScriptValue::UndefinedValue)",
 475     "QScriptValue(engine, QScriptValue::UndefinedValue)",
 476     "engine->evaluate(\"{}\")",
 477     "engine->evaluate(\"undefined\")",
 478     "engine->undefinedValue()"};
 479
 480 void tst_QScriptValue::isUndefined_data()
 481 {
 482     QTest::addColumn<QScriptValue>("value");
 483     QTest::addColumn<bool>("expected");
 484     if (m_engine)
 485         delete m_engine;
 486     m_engine = new QScriptEngine();
 487     QSet<QString> expectedValue;
 488     expectedValue.reserve(6);
 489     for (uint i = 0; i < 6; ++i)
 490         expectedValue.insert(isUndefined_array[i]);
 491     for (uint i = 0; i < 135; ++i) {
 492         QPair<QString, QScriptValue> testcase = initScriptValues(i);
 493         QTest::newRow(testcase.first.toAscii().constData()) << testcase.second << expectedValue.contains(testcase.first);
 494     }
 495 }
 496
 497 void tst_QScriptValue::isUndefined()
 498 {
 499     QFETCH(QScriptValue, value);
 500     QFETCH(bool, expected);
 501     QCOMPARE(value.isUndefined(), expected);
 502     QCOMPARE(value.isUndefined(), expected);
 503 }
 504
 505
 506
 507
 508 static const QString isObject_array[] = {
 509     "engine->evaluate(\"[]\")",
 510     "engine->evaluate(\"Object.prototype\")",
 511     "engine->evaluate(\"Date.prototype\")",
 512     "engine->evaluate(\"Array.prototype\")",
 513     "engine->evaluate(\"Function.prototype\")",
 514     "engine->evaluate(\"Error.prototype\")",
 515     "engine->evaluate(\"Object\")",
 516     "engine->evaluate(\"Array\")",
 517     "engine->evaluate(\"Number\")",
 518     "engine->evaluate(\"Function\")",
 519     "engine->evaluate(\"(function() { return 1; })\")",
 520     "engine->evaluate(\"(function() { return 'ciao'; })\")",
 521     "engine->evaluate(\"(function() { throw new Error('foo'); })\")",
 522     "engine->evaluate(\"/foo/\")",
 523     "engine->evaluate(\"new Object()\")",
 524     "engine->evaluate(\"new Array()\")",
 525     "engine->evaluate(\"new Error()\")",
 526     "engine->evaluate(\"Undefined\")",
 527     "engine->evaluate(\"Null\")",
 528     "engine->evaluate(\"True\")",
 529     "engine->evaluate(\"False\")",
 530     "engine->newObject()",
 531     "engine->newArray()",
 532     "engine->newArray(10)"};
 533
 534 void tst_QScriptValue::isObject_data()
 535 {
 536     QTest::addColumn<QScriptValue>("value");
 537     QTest::addColumn<bool>("expected");
 538     if (m_engine)
 539         delete m_engine;
 540     m_engine = new QScriptEngine();
 541     QSet<QString> expectedValue;
 542     expectedValue.reserve(24);
 543     for (uint i = 0; i < 24; ++i)
 544         expectedValue.insert(isObject_array[i]);
 545     for (uint i = 0; i < 135; ++i) {
 546         QPair<QString, QScriptValue> testcase = initScriptValues(i);
 547         QTest::newRow(testcase.first.toAscii().constData()) << testcase.second << expectedValue.contains(testcase.first);
 548     }
 549 }
 550
 551 void tst_QScriptValue::isObject()
 552 {
 553     QFETCH(QScriptValue, value);
 554     QFETCH(bool, expected);
 555     QCOMPARE(value.isObject(), expected);
 556     QCOMPARE(value.isObject(), expected);
 557 }
 558
 559 static const QString isArray_array[] = {
 560     "engine->evaluate(\"[]\")",
 561     "engine->evaluate(\"Array.prototype\")",
 562     "engine->evaluate(\"new Array()\")",
 563     "engine->newArray()",
 564     "engine->newArray(10)"};
 565
 566 void tst_QScriptValue::isArray_data()
 567 {
 568     QTest::addColumn<QScriptValue>("value");
 569     QTest::addColumn<bool>("expected");
 570     if (m_engine)
 571         delete m_engine;
 572     m_engine = new QScriptEngine();
 573     QSet<QString> expectedValue;
 574     expectedValue.reserve(5);
 575     for (uint i = 0; i < 5; ++i)
 576         expectedValue.insert(isArray_array[i]);
 577     for (uint i = 0; i < 135; ++i) {
 578         QPair<QString, QScriptValue> testcase = initScriptValues(i);
 579         QTest::newRow(testcase.first.toAscii().constData()) << testcase.second << expectedValue.contains(testcase.first);
 580     }
 581 }
 582
 583 void tst_QScriptValue::isArray()
 584 {
 585     QFETCH(QScriptValue, value);
 586     QFETCH(bool, expected);
 587     QCOMPARE(value.isArray(), expected);
 588     QCOMPARE(value.isArray(), expected);
 589 }
 590
 591 static const QString isError_array[] = {
 592     "engine->evaluate(\"Error.prototype\")",
 593     "engine->evaluate(\"new Error()\")",
 594     "engine->evaluate(\"Undefined\")",
 595     "engine->evaluate(\"Null\")",
 596     "engine->evaluate(\"True\")",
 597     "engine->evaluate(\"False\")"};
 598
 599 void tst_QScriptValue::isError_data()
 600 {
 601     QTest::addColumn<QScriptValue>("value");
 602     QTest::addColumn<bool>("expected");
 603     if (m_engine)
 604         delete m_engine;
 605     m_engine = new QScriptEngine();
 606     QSet<QString> expectedValue;
 607     expectedValue.reserve(6);
 608     for (uint i = 0; i < 6; ++i)
 609         expectedValue.insert(isError_array[i]);
 610     for (uint i = 0; i < 135; ++i) {
 611         QPair<QString, QScriptValue> testcase = initScriptValues(i);
 612         QTest::newRow(testcase.first.toAscii().constData()) << testcase.second << expectedValue.contains(testcase.first);
 613     }
 614 }
 615
 616 void tst_QScriptValue::isError()
 617 {
 618     QFETCH(QScriptValue, value);
 619     QFETCH(bool, expected);
 620     QCOMPARE(value.isError(), expected);
 621     QCOMPARE(value.isError(), expected);
 622 }