1 /****************************************************************************
2 **
3 ** Copyright (C) 2015 The Qt Company Ltd.
4 ** Contact: http://www.qt.io/licensing/
5 **
6 ** This file is part of the test suite of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and The Qt Company. For licensing terms
14 ** and conditions see http://www.qt.io/terms-conditions. For further
15 ** information use the contact form at http://www.qt.io/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 or version 3 as published by the Free
20 ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
21 ** LICENSE.LGPLv3 included in the packaging of this file. Please review the
22 ** following information to ensure the GNU Lesser General Public License
23 ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
24 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
25 **
26 ** As a special exception, The Qt Company gives you certain additional
27 ** rights. These rights are described in The Qt Company LGPL Exception
28 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
29 **
30 ** GNU General Public License Usage
31 ** Alternatively, this file may be used under the terms of the GNU
32 ** General Public License version 3.0 as published by the Free Software
33 ** Foundation and appearing in the file LICENSE.GPL included in the
34 ** packaging of this file.  Please review the following information to
35 ** ensure the GNU General Public License version 3.0 requirements will be
36 ** met: http://www.gnu.org/copyleft/gpl.html.
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41 
42 /****************************************************************************
43 *************** This file has been generated. DO NOT MODIFY! ****************
44 ****************************************************************************/
45 
46 #include "tst_qscriptvalue.h"
47 
48 
isValid_initData()49 void tst_QScriptValueGenerated::isValid_initData()
50 {
51     QTest::addColumn<bool>("expected");
52     initScriptValues();
53 }
54 
55 static QString isValid_array[] = {
56     "QScriptValue(QScriptValue::UndefinedValue)",
57     "QScriptValue(QScriptValue::NullValue)",
58     "QScriptValue(true)",
59     "QScriptValue(false)",
60     "QScriptValue(int(122))",
61     "QScriptValue(uint(124))",
62     "QScriptValue(0)",
63     "QScriptValue(0.0)",
64     "QScriptValue(123.0)",
65     "QScriptValue(6.37e-8)",
66     "QScriptValue(-6.37e-8)",
67     "QScriptValue(0x43211234)",
68     "QScriptValue(0x10000)",
69     "QScriptValue(0x10001)",
70     "QScriptValue(qSNaN())",
71     "QScriptValue(qQNaN())",
72     "QScriptValue(qInf())",
73     "QScriptValue(-qInf())",
74     "QScriptValue(\"NaN\")",
75     "QScriptValue(\"Infinity\")",
76     "QScriptValue(\"-Infinity\")",
77     "QScriptValue(\"ciao\")",
78     "QScriptValue(QString::fromLatin1(\"ciao\"))",
79     "QScriptValue(QString(\"\"))",
80     "QScriptValue(QString())",
81     "QScriptValue(QString(\"0\"))",
82     "QScriptValue(QString(\"123\"))",
83     "QScriptValue(QString(\"12.4\"))",
84     "QScriptValue(0, QScriptValue::UndefinedValue)",
85     "QScriptValue(0, QScriptValue::NullValue)",
86     "QScriptValue(0, true)",
87     "QScriptValue(0, false)",
88     "QScriptValue(0, int(122))",
89     "QScriptValue(0, uint(124))",
90     "QScriptValue(0, 0)",
91     "QScriptValue(0, 0.0)",
92     "QScriptValue(0, 123.0)",
93     "QScriptValue(0, 6.37e-8)",
94     "QScriptValue(0, -6.37e-8)",
95     "QScriptValue(0, 0x43211234)",
96     "QScriptValue(0, 0x10000)",
97     "QScriptValue(0, 0x10001)",
98     "QScriptValue(0, qSNaN())",
99     "QScriptValue(0, qQNaN())",
100     "QScriptValue(0, qInf())",
101     "QScriptValue(0, -qInf())",
102     "QScriptValue(0, \"NaN\")",
103     "QScriptValue(0, \"Infinity\")",
104     "QScriptValue(0, \"-Infinity\")",
105     "QScriptValue(0, \"ciao\")",
106     "QScriptValue(0, QString::fromLatin1(\"ciao\"))",
107     "QScriptValue(0, QString(\"\"))",
108     "QScriptValue(0, QString())",
109     "QScriptValue(0, QString(\"0\"))",
110     "QScriptValue(0, QString(\"123\"))",
111     "QScriptValue(0, QString(\"12.3\"))",
112     "QScriptValue(engine, QScriptValue::UndefinedValue)",
113     "QScriptValue(engine, QScriptValue::NullValue)",
114     "QScriptValue(engine, true)",
115     "QScriptValue(engine, false)",
116     "QScriptValue(engine, int(122))",
117     "QScriptValue(engine, uint(124))",
118     "QScriptValue(engine, 0)",
119     "QScriptValue(engine, 0.0)",
120     "QScriptValue(engine, 123.0)",
121     "QScriptValue(engine, 6.37e-8)",
122     "QScriptValue(engine, -6.37e-8)",
123     "QScriptValue(engine, 0x43211234)",
124     "QScriptValue(engine, 0x10000)",
125     "QScriptValue(engine, 0x10001)",
126     "QScriptValue(engine, qSNaN())",
127     "QScriptValue(engine, qQNaN())",
128     "QScriptValue(engine, qInf())",
129     "QScriptValue(engine, -qInf())",
130     "QScriptValue(engine, \"NaN\")",
131     "QScriptValue(engine, \"Infinity\")",
132     "QScriptValue(engine, \"-Infinity\")",
133     "QScriptValue(engine, \"ciao\")",
134     "QScriptValue(engine, QString::fromLatin1(\"ciao\"))",
135     "QScriptValue(engine, QString(\"\"))",
136     "QScriptValue(engine, QString())",
137     "QScriptValue(engine, QString(\"0\"))",
138     "QScriptValue(engine, QString(\"123\"))",
139     "QScriptValue(engine, QString(\"1.23\"))",
140     "engine->evaluate(\"[]\")",
141     "engine->evaluate(\"{}\")",
142     "engine->evaluate(\"Object.prototype\")",
143     "engine->evaluate(\"Date.prototype\")",
144     "engine->evaluate(\"Array.prototype\")",
145     "engine->evaluate(\"Function.prototype\")",
146     "engine->evaluate(\"Error.prototype\")",
147     "engine->evaluate(\"Object\")",
148     "engine->evaluate(\"Array\")",
149     "engine->evaluate(\"Number\")",
150     "engine->evaluate(\"Function\")",
151     "engine->evaluate(\"(function() { return 1; })\")",
152     "engine->evaluate(\"(function() { return 'ciao'; })\")",
153     "engine->evaluate(\"(function() { throw new Error('foo'); })\")",
154     "engine->evaluate(\"/foo/\")",
155     "engine->evaluate(\"new Object()\")",
156     "engine->evaluate(\"new Array()\")",
157     "engine->evaluate(\"new Error()\")",
158     "engine->evaluate(\"new Boolean(true)\")",
159     "engine->evaluate(\"new Boolean(false)\")",
160     "engine->evaluate(\"new Number(123)\")",
161     "engine->evaluate(\"new RegExp('foo', 'gim')\")",
162     "engine->evaluate(\"new String('ciao')\")",
163     "engine->evaluate(\"a = new Object(); a.foo = 22; a.foo\")",
164     "engine->evaluate(\"Undefined\")",
165     "engine->evaluate(\"Null\")",
166     "engine->evaluate(\"True\")",
167     "engine->evaluate(\"False\")",
168     "engine->evaluate(\"undefined\")",
169     "engine->evaluate(\"null\")",
170     "engine->evaluate(\"true\")",
171     "engine->evaluate(\"false\")",
172     "engine->evaluate(\"122\")",
173     "engine->evaluate(\"124\")",
174     "engine->evaluate(\"0\")",
175     "engine->evaluate(\"0.0\")",
176     "engine->evaluate(\"123.0\")",
177     "engine->evaluate(\"6.37e-8\")",
178     "engine->evaluate(\"-6.37e-8\")",
179     "engine->evaluate(\"0x43211234\")",
180     "engine->evaluate(\"0x10000\")",
181     "engine->evaluate(\"0x10001\")",
182     "engine->evaluate(\"NaN\")",
183     "engine->evaluate(\"Infinity\")",
184     "engine->evaluate(\"-Infinity\")",
185     "engine->evaluate(\"'ciao'\")",
186     "engine->evaluate(\"''\")",
187     "engine->evaluate(\"'0'\")",
188     "engine->evaluate(\"'123'\")",
189     "engine->evaluate(\"'12.4'\")",
190     "engine->nullValue()",
191     "engine->undefinedValue()",
192     "engine->newObject()",
193     "engine->newArray()",
194     "engine->newArray(10)",
195     "engine->newDate(QDateTime())",
196     "engine->newQMetaObject(&QObject::staticMetaObject)",
197     "engine->newRegExp(\"foo\", \"gim\")",
198     "engine->newVariant(QVariant())",
199     "engine->newVariant(QVariant(123))",
200     "engine->newVariant(QVariant(false))",
201     "engine->newQObject(0)",
202     "engine->newQObject(engine)"
203 };
204 
isValid_makeData(const char * expr)205 void tst_QScriptValueGenerated::isValid_makeData(const char* expr)
206 {
207     static QSet<QString> isValid;
208     if (isValid.isEmpty()) {
209         isValid.reserve(147);
210         for (unsigned i = 0; i < 147; ++i)
211             isValid.insert(isValid_array[i]);
212     }
213     newRow(expr) << isValid.contains(expr);
214 }
215 
isValid_test(const char *,const QScriptValue & value)216 void tst_QScriptValueGenerated::isValid_test(const char*, const QScriptValue& value)
217 {
218     QFETCH(bool, expected);
219     QCOMPARE(value.isValid(), expected);
220     QCOMPARE(value.isValid(), expected);
221 }
222 
DEFINE_TEST_FUNCTION(isValid)223 DEFINE_TEST_FUNCTION(isValid)
224 
225 
226 void tst_QScriptValueGenerated::isBool_initData()
227 {
228     QTest::addColumn<bool>("expected");
229     initScriptValues();
230 }
231 
232 static QString isBool_array[] = {
233     "QScriptValue(true)",
234     "QScriptValue(false)",
235     "QScriptValue(0, true)",
236     "QScriptValue(0, false)",
237     "QScriptValue(engine, true)",
238     "QScriptValue(engine, false)",
239     "engine->evaluate(\"true\")",
240     "engine->evaluate(\"false\")"
241 };
242 
isBool_makeData(const char * expr)243 void tst_QScriptValueGenerated::isBool_makeData(const char* expr)
244 {
245     static QSet<QString> isBool;
246     if (isBool.isEmpty()) {
247         isBool.reserve(8);
248         for (unsigned i = 0; i < 8; ++i)
249             isBool.insert(isBool_array[i]);
250     }
251     newRow(expr) << isBool.contains(expr);
252 }
253 
isBool_test(const char *,const QScriptValue & value)254 void tst_QScriptValueGenerated::isBool_test(const char*, const QScriptValue& value)
255 {
256     QFETCH(bool, expected);
257     QCOMPARE(value.isBool(), expected);
258     QCOMPARE(value.isBool(), expected);
259 }
260 
DEFINE_TEST_FUNCTION(isBool)261 DEFINE_TEST_FUNCTION(isBool)
262 
263 
264 void tst_QScriptValueGenerated::isBoolean_initData()
265 {
266     QTest::addColumn<bool>("expected");
267     initScriptValues();
268 }
269 
270 static QString isBoolean_array[] = {
271     "QScriptValue(true)",
272     "QScriptValue(false)",
273     "QScriptValue(0, true)",
274     "QScriptValue(0, false)",
275     "QScriptValue(engine, true)",
276     "QScriptValue(engine, false)",
277     "engine->evaluate(\"true\")",
278     "engine->evaluate(\"false\")"
279 };
280 
isBoolean_makeData(const char * expr)281 void tst_QScriptValueGenerated::isBoolean_makeData(const char* expr)
282 {
283     static QSet<QString> isBoolean;
284     if (isBoolean.isEmpty()) {
285         isBoolean.reserve(8);
286         for (unsigned i = 0; i < 8; ++i)
287             isBoolean.insert(isBoolean_array[i]);
288     }
289     newRow(expr) << isBoolean.contains(expr);
290 }
291 
isBoolean_test(const char *,const QScriptValue & value)292 void tst_QScriptValueGenerated::isBoolean_test(const char*, const QScriptValue& value)
293 {
294     QFETCH(bool, expected);
295     QCOMPARE(value.isBoolean(), expected);
296     QCOMPARE(value.isBoolean(), expected);
297 }
298 
DEFINE_TEST_FUNCTION(isBoolean)299 DEFINE_TEST_FUNCTION(isBoolean)
300 
301 
302 void tst_QScriptValueGenerated::isNumber_initData()
303 {
304     QTest::addColumn<bool>("expected");
305     initScriptValues();
306 }
307 
308 static QString isNumber_array[] = {
309     "QScriptValue(int(122))",
310     "QScriptValue(uint(124))",
311     "QScriptValue(0)",
312     "QScriptValue(0.0)",
313     "QScriptValue(123.0)",
314     "QScriptValue(6.37e-8)",
315     "QScriptValue(-6.37e-8)",
316     "QScriptValue(0x43211234)",
317     "QScriptValue(0x10000)",
318     "QScriptValue(0x10001)",
319     "QScriptValue(qSNaN())",
320     "QScriptValue(qQNaN())",
321     "QScriptValue(qInf())",
322     "QScriptValue(-qInf())",
323     "QScriptValue(0, int(122))",
324     "QScriptValue(0, uint(124))",
325     "QScriptValue(0, 0)",
326     "QScriptValue(0, 0.0)",
327     "QScriptValue(0, 123.0)",
328     "QScriptValue(0, 6.37e-8)",
329     "QScriptValue(0, -6.37e-8)",
330     "QScriptValue(0, 0x43211234)",
331     "QScriptValue(0, 0x10000)",
332     "QScriptValue(0, 0x10001)",
333     "QScriptValue(0, qSNaN())",
334     "QScriptValue(0, qQNaN())",
335     "QScriptValue(0, qInf())",
336     "QScriptValue(0, -qInf())",
337     "QScriptValue(engine, int(122))",
338     "QScriptValue(engine, uint(124))",
339     "QScriptValue(engine, 0)",
340     "QScriptValue(engine, 0.0)",
341     "QScriptValue(engine, 123.0)",
342     "QScriptValue(engine, 6.37e-8)",
343     "QScriptValue(engine, -6.37e-8)",
344     "QScriptValue(engine, 0x43211234)",
345     "QScriptValue(engine, 0x10000)",
346     "QScriptValue(engine, 0x10001)",
347     "QScriptValue(engine, qSNaN())",
348     "QScriptValue(engine, qQNaN())",
349     "QScriptValue(engine, qInf())",
350     "QScriptValue(engine, -qInf())",
351     "engine->evaluate(\"a = new Object(); a.foo = 22; a.foo\")",
352     "engine->evaluate(\"122\")",
353     "engine->evaluate(\"124\")",
354     "engine->evaluate(\"0\")",
355     "engine->evaluate(\"0.0\")",
356     "engine->evaluate(\"123.0\")",
357     "engine->evaluate(\"6.37e-8\")",
358     "engine->evaluate(\"-6.37e-8\")",
359     "engine->evaluate(\"0x43211234\")",
360     "engine->evaluate(\"0x10000\")",
361     "engine->evaluate(\"0x10001\")",
362     "engine->evaluate(\"NaN\")",
363     "engine->evaluate(\"Infinity\")",
364     "engine->evaluate(\"-Infinity\")"
365 };
366 
isNumber_makeData(const char * expr)367 void tst_QScriptValueGenerated::isNumber_makeData(const char* expr)
368 {
369     static QSet<QString> isNumber;
370     if (isNumber.isEmpty()) {
371         isNumber.reserve(56);
372         for (unsigned i = 0; i < 56; ++i)
373             isNumber.insert(isNumber_array[i]);
374     }
375     newRow(expr) << isNumber.contains(expr);
376 }
377 
isNumber_test(const char *,const QScriptValue & value)378 void tst_QScriptValueGenerated::isNumber_test(const char*, const QScriptValue& value)
379 {
380     QFETCH(bool, expected);
381     QCOMPARE(value.isNumber(), expected);
382     QCOMPARE(value.isNumber(), expected);
383 }
384 
DEFINE_TEST_FUNCTION(isNumber)385 DEFINE_TEST_FUNCTION(isNumber)
386 
387 
388 void tst_QScriptValueGenerated::isFunction_initData()
389 {
390     QTest::addColumn<bool>("expected");
391     initScriptValues();
392 }
393 
394 static QString isFunction_array[] = {
395     "engine->evaluate(\"Function.prototype\")",
396     "engine->evaluate(\"Object\")",
397     "engine->evaluate(\"Array\")",
398     "engine->evaluate(\"Number\")",
399     "engine->evaluate(\"Function\")",
400     "engine->evaluate(\"(function() { return 1; })\")",
401     "engine->evaluate(\"(function() { return 'ciao'; })\")",
402     "engine->evaluate(\"(function() { throw new Error('foo'); })\")",
403     "engine->evaluate(\"/foo/\")",
404     "engine->evaluate(\"new RegExp('foo', 'gim')\")",
405     "engine->newQMetaObject(&QObject::staticMetaObject)",
406     "engine->newRegExp(\"foo\", \"gim\")"
407 };
408 
isFunction_makeData(const char * expr)409 void tst_QScriptValueGenerated::isFunction_makeData(const char* expr)
410 {
411     static QSet<QString> isFunction;
412     if (isFunction.isEmpty()) {
413         isFunction.reserve(12);
414         for (unsigned i = 0; i < 12; ++i)
415             isFunction.insert(isFunction_array[i]);
416     }
417     newRow(expr) << isFunction.contains(expr);
418 }
419 
isFunction_test(const char *,const QScriptValue & value)420 void tst_QScriptValueGenerated::isFunction_test(const char*, const QScriptValue& value)
421 {
422     QFETCH(bool, expected);
423     QCOMPARE(value.isFunction(), expected);
424     QCOMPARE(value.isFunction(), expected);
425 }
426 
DEFINE_TEST_FUNCTION(isFunction)427 DEFINE_TEST_FUNCTION(isFunction)
428 
429 
430 void tst_QScriptValueGenerated::isNull_initData()
431 {
432     QTest::addColumn<bool>("expected");
433     initScriptValues();
434 }
435 
436 static QString isNull_array[] = {
437     "QScriptValue(QScriptValue::NullValue)",
438     "QScriptValue(0, QScriptValue::NullValue)",
439     "QScriptValue(engine, QScriptValue::NullValue)",
440     "engine->evaluate(\"null\")",
441     "engine->nullValue()",
442     "engine->newQObject(0)"
443 };
444 
isNull_makeData(const char * expr)445 void tst_QScriptValueGenerated::isNull_makeData(const char* expr)
446 {
447     static QSet<QString> isNull;
448     if (isNull.isEmpty()) {
449         isNull.reserve(6);
450         for (unsigned i = 0; i < 6; ++i)
451             isNull.insert(isNull_array[i]);
452     }
453     newRow(expr) << isNull.contains(expr);
454 }
455 
isNull_test(const char *,const QScriptValue & value)456 void tst_QScriptValueGenerated::isNull_test(const char*, const QScriptValue& value)
457 {
458     QFETCH(bool, expected);
459     QCOMPARE(value.isNull(), expected);
460     QCOMPARE(value.isNull(), expected);
461 }
462 
DEFINE_TEST_FUNCTION(isNull)463 DEFINE_TEST_FUNCTION(isNull)
464 
465 
466 void tst_QScriptValueGenerated::isString_initData()
467 {
468     QTest::addColumn<bool>("expected");
469     initScriptValues();
470 }
471 
472 static QString isString_array[] = {
473     "QScriptValue(\"NaN\")",
474     "QScriptValue(\"Infinity\")",
475     "QScriptValue(\"-Infinity\")",
476     "QScriptValue(\"ciao\")",
477     "QScriptValue(QString::fromLatin1(\"ciao\"))",
478     "QScriptValue(QString(\"\"))",
479     "QScriptValue(QString())",
480     "QScriptValue(QString(\"0\"))",
481     "QScriptValue(QString(\"123\"))",
482     "QScriptValue(QString(\"12.4\"))",
483     "QScriptValue(0, \"NaN\")",
484     "QScriptValue(0, \"Infinity\")",
485     "QScriptValue(0, \"-Infinity\")",
486     "QScriptValue(0, \"ciao\")",
487     "QScriptValue(0, QString::fromLatin1(\"ciao\"))",
488     "QScriptValue(0, QString(\"\"))",
489     "QScriptValue(0, QString())",
490     "QScriptValue(0, QString(\"0\"))",
491     "QScriptValue(0, QString(\"123\"))",
492     "QScriptValue(0, QString(\"12.3\"))",
493     "QScriptValue(engine, \"NaN\")",
494     "QScriptValue(engine, \"Infinity\")",
495     "QScriptValue(engine, \"-Infinity\")",
496     "QScriptValue(engine, \"ciao\")",
497     "QScriptValue(engine, QString::fromLatin1(\"ciao\"))",
498     "QScriptValue(engine, QString(\"\"))",
499     "QScriptValue(engine, QString())",
500     "QScriptValue(engine, QString(\"0\"))",
501     "QScriptValue(engine, QString(\"123\"))",
502     "QScriptValue(engine, QString(\"1.23\"))",
503     "engine->evaluate(\"'ciao'\")",
504     "engine->evaluate(\"''\")",
505     "engine->evaluate(\"'0'\")",
506     "engine->evaluate(\"'123'\")",
507     "engine->evaluate(\"'12.4'\")"
508 };
509 
isString_makeData(const char * expr)510 void tst_QScriptValueGenerated::isString_makeData(const char* expr)
511 {
512     static QSet<QString> isString;
513     if (isString.isEmpty()) {
514         isString.reserve(35);
515         for (unsigned i = 0; i < 35; ++i)
516             isString.insert(isString_array[i]);
517     }
518     newRow(expr) << isString.contains(expr);
519 }
520 
isString_test(const char *,const QScriptValue & value)521 void tst_QScriptValueGenerated::isString_test(const char*, const QScriptValue& value)
522 {
523     QFETCH(bool, expected);
524     QCOMPARE(value.isString(), expected);
525     QCOMPARE(value.isString(), expected);
526 }
527 
DEFINE_TEST_FUNCTION(isString)528 DEFINE_TEST_FUNCTION(isString)
529 
530 
531 void tst_QScriptValueGenerated::isUndefined_initData()
532 {
533     QTest::addColumn<bool>("expected");
534     initScriptValues();
535 }
536 
537 static QString isUndefined_array[] = {
538     "QScriptValue(QScriptValue::UndefinedValue)",
539     "QScriptValue(0, QScriptValue::UndefinedValue)",
540     "QScriptValue(engine, QScriptValue::UndefinedValue)",
541     "engine->evaluate(\"{}\")",
542     "engine->evaluate(\"undefined\")",
543     "engine->undefinedValue()"
544 };
545 
isUndefined_makeData(const char * expr)546 void tst_QScriptValueGenerated::isUndefined_makeData(const char* expr)
547 {
548     static QSet<QString> isUndefined;
549     if (isUndefined.isEmpty()) {
550         isUndefined.reserve(6);
551         for (unsigned i = 0; i < 6; ++i)
552             isUndefined.insert(isUndefined_array[i]);
553     }
554     newRow(expr) << isUndefined.contains(expr);
555 }
556 
isUndefined_test(const char *,const QScriptValue & value)557 void tst_QScriptValueGenerated::isUndefined_test(const char*, const QScriptValue& value)
558 {
559     QFETCH(bool, expected);
560     QCOMPARE(value.isUndefined(), expected);
561     QCOMPARE(value.isUndefined(), expected);
562 }
563 
DEFINE_TEST_FUNCTION(isUndefined)564 DEFINE_TEST_FUNCTION(isUndefined)
565 
566 
567 void tst_QScriptValueGenerated::isVariant_initData()
568 {
569     QTest::addColumn<bool>("expected");
570     initScriptValues();
571 }
572 
573 static QString isVariant_array[] = {
574     "engine->newVariant(QVariant())",
575     "engine->newVariant(QVariant(123))",
576     "engine->newVariant(QVariant(false))"
577 };
578 
isVariant_makeData(const char * expr)579 void tst_QScriptValueGenerated::isVariant_makeData(const char* expr)
580 {
581     static QSet<QString> isVariant;
582     if (isVariant.isEmpty()) {
583         isVariant.reserve(3);
584         for (unsigned i = 0; i < 3; ++i)
585             isVariant.insert(isVariant_array[i]);
586     }
587     newRow(expr) << isVariant.contains(expr);
588 }
589 
isVariant_test(const char *,const QScriptValue & value)590 void tst_QScriptValueGenerated::isVariant_test(const char*, const QScriptValue& value)
591 {
592     QFETCH(bool, expected);
593     QCOMPARE(value.isVariant(), expected);
594     QCOMPARE(value.isVariant(), expected);
595 }
596 
DEFINE_TEST_FUNCTION(isVariant)597 DEFINE_TEST_FUNCTION(isVariant)
598 
599 
600 void tst_QScriptValueGenerated::isQObject_initData()
601 {
602     QTest::addColumn<bool>("expected");
603     initScriptValues();
604 }
605 
606 static QString isQObject_array[] = {
607     "engine->newQObject(engine)"
608 };
609 
isQObject_makeData(const char * expr)610 void tst_QScriptValueGenerated::isQObject_makeData(const char* expr)
611 {
612     static QSet<QString> isQObject;
613     if (isQObject.isEmpty()) {
614         isQObject.reserve(1);
615         for (unsigned i = 0; i < 1; ++i)
616             isQObject.insert(isQObject_array[i]);
617     }
618     newRow(expr) << isQObject.contains(expr);
619 }
620 
isQObject_test(const char *,const QScriptValue & value)621 void tst_QScriptValueGenerated::isQObject_test(const char*, const QScriptValue& value)
622 {
623     QFETCH(bool, expected);
624     QCOMPARE(value.isQObject(), expected);
625     QCOMPARE(value.isQObject(), expected);
626 }
627 
DEFINE_TEST_FUNCTION(isQObject)628 DEFINE_TEST_FUNCTION(isQObject)
629 
630 
631 void tst_QScriptValueGenerated::isQMetaObject_initData()
632 {
633     QTest::addColumn<bool>("expected");
634     initScriptValues();
635 }
636 
637 static QString isQMetaObject_array[] = {
638     "engine->newQMetaObject(&QObject::staticMetaObject)"
639 };
640 
isQMetaObject_makeData(const char * expr)641 void tst_QScriptValueGenerated::isQMetaObject_makeData(const char* expr)
642 {
643     static QSet<QString> isQMetaObject;
644     if (isQMetaObject.isEmpty()) {
645         isQMetaObject.reserve(1);
646         for (unsigned i = 0; i < 1; ++i)
647             isQMetaObject.insert(isQMetaObject_array[i]);
648     }
649     newRow(expr) << isQMetaObject.contains(expr);
650 }
651 
isQMetaObject_test(const char *,const QScriptValue & value)652 void tst_QScriptValueGenerated::isQMetaObject_test(const char*, const QScriptValue& value)
653 {
654     QFETCH(bool, expected);
655     QCOMPARE(value.isQMetaObject(), expected);
656     QCOMPARE(value.isQMetaObject(), expected);
657 }
658 
DEFINE_TEST_FUNCTION(isQMetaObject)659 DEFINE_TEST_FUNCTION(isQMetaObject)
660 
661 
662 void tst_QScriptValueGenerated::isObject_initData()
663 {
664     QTest::addColumn<bool>("expected");
665     initScriptValues();
666 }
667 
668 static QString isObject_array[] = {
669     "engine->evaluate(\"[]\")",
670     "engine->evaluate(\"Object.prototype\")",
671     "engine->evaluate(\"Date.prototype\")",
672     "engine->evaluate(\"Array.prototype\")",
673     "engine->evaluate(\"Function.prototype\")",
674     "engine->evaluate(\"Error.prototype\")",
675     "engine->evaluate(\"Object\")",
676     "engine->evaluate(\"Array\")",
677     "engine->evaluate(\"Number\")",
678     "engine->evaluate(\"Function\")",
679     "engine->evaluate(\"(function() { return 1; })\")",
680     "engine->evaluate(\"(function() { return 'ciao'; })\")",
681     "engine->evaluate(\"(function() { throw new Error('foo'); })\")",
682     "engine->evaluate(\"/foo/\")",
683     "engine->evaluate(\"new Object()\")",
684     "engine->evaluate(\"new Array()\")",
685     "engine->evaluate(\"new Error()\")",
686     "engine->evaluate(\"new Boolean(true)\")",
687     "engine->evaluate(\"new Boolean(false)\")",
688     "engine->evaluate(\"new Number(123)\")",
689     "engine->evaluate(\"new RegExp('foo', 'gim')\")",
690     "engine->evaluate(\"new String('ciao')\")",
691     "engine->evaluate(\"Undefined\")",
692     "engine->evaluate(\"Null\")",
693     "engine->evaluate(\"True\")",
694     "engine->evaluate(\"False\")",
695     "engine->newObject()",
696     "engine->newArray()",
697     "engine->newArray(10)",
698     "engine->newDate(QDateTime())",
699     "engine->newQMetaObject(&QObject::staticMetaObject)",
700     "engine->newRegExp(\"foo\", \"gim\")",
701     "engine->newVariant(QVariant())",
702     "engine->newVariant(QVariant(123))",
703     "engine->newVariant(QVariant(false))",
704     "engine->newQObject(engine)"
705 };
706 
isObject_makeData(const char * expr)707 void tst_QScriptValueGenerated::isObject_makeData(const char* expr)
708 {
709     static QSet<QString> isObject;
710     if (isObject.isEmpty()) {
711         isObject.reserve(36);
712         for (unsigned i = 0; i < 36; ++i)
713             isObject.insert(isObject_array[i]);
714     }
715     newRow(expr) << isObject.contains(expr);
716 }
717 
isObject_test(const char *,const QScriptValue & value)718 void tst_QScriptValueGenerated::isObject_test(const char*, const QScriptValue& value)
719 {
720     QFETCH(bool, expected);
721     QCOMPARE(value.isObject(), expected);
722     QCOMPARE(value.isObject(), expected);
723 }
724 
DEFINE_TEST_FUNCTION(isObject)725 DEFINE_TEST_FUNCTION(isObject)
726 
727 
728 void tst_QScriptValueGenerated::isDate_initData()
729 {
730     QTest::addColumn<bool>("expected");
731     initScriptValues();
732 }
733 
734 static QString isDate_array[] = {
735     "engine->evaluate(\"Date.prototype\")",
736     "engine->newDate(QDateTime())"
737 };
738 
isDate_makeData(const char * expr)739 void tst_QScriptValueGenerated::isDate_makeData(const char* expr)
740 {
741     static QSet<QString> isDate;
742     if (isDate.isEmpty()) {
743         isDate.reserve(2);
744         for (unsigned i = 0; i < 2; ++i)
745             isDate.insert(isDate_array[i]);
746     }
747     newRow(expr) << isDate.contains(expr);
748 }
749 
isDate_test(const char *,const QScriptValue & value)750 void tst_QScriptValueGenerated::isDate_test(const char*, const QScriptValue& value)
751 {
752     QFETCH(bool, expected);
753     QCOMPARE(value.isDate(), expected);
754     QCOMPARE(value.isDate(), expected);
755 }
756 
DEFINE_TEST_FUNCTION(isDate)757 DEFINE_TEST_FUNCTION(isDate)
758 
759 
760 void tst_QScriptValueGenerated::isRegExp_initData()
761 {
762     QTest::addColumn<bool>("expected");
763     initScriptValues();
764 }
765 
766 static QString isRegExp_array[] = {
767     "engine->evaluate(\"/foo/\")",
768     "engine->evaluate(\"new RegExp('foo', 'gim')\")",
769     "engine->newRegExp(\"foo\", \"gim\")"
770 };
771 
isRegExp_makeData(const char * expr)772 void tst_QScriptValueGenerated::isRegExp_makeData(const char* expr)
773 {
774     static QSet<QString> isRegExp;
775     if (isRegExp.isEmpty()) {
776         isRegExp.reserve(3);
777         for (unsigned i = 0; i < 3; ++i)
778             isRegExp.insert(isRegExp_array[i]);
779     }
780     newRow(expr) << isRegExp.contains(expr);
781 }
782 
isRegExp_test(const char *,const QScriptValue & value)783 void tst_QScriptValueGenerated::isRegExp_test(const char*, const QScriptValue& value)
784 {
785     QFETCH(bool, expected);
786     QCOMPARE(value.isRegExp(), expected);
787     QCOMPARE(value.isRegExp(), expected);
788 }
789 
DEFINE_TEST_FUNCTION(isRegExp)790 DEFINE_TEST_FUNCTION(isRegExp)
791 
792 
793 void tst_QScriptValueGenerated::isArray_initData()
794 {
795     QTest::addColumn<bool>("expected");
796     initScriptValues();
797 }
798 
799 static QString isArray_array[] = {
800     "engine->evaluate(\"[]\")",
801     "engine->evaluate(\"Array.prototype\")",
802     "engine->evaluate(\"new Array()\")",
803     "engine->newArray()",
804     "engine->newArray(10)"
805 };
806 
isArray_makeData(const char * expr)807 void tst_QScriptValueGenerated::isArray_makeData(const char* expr)
808 {
809     static QSet<QString> isArray;
810     if (isArray.isEmpty()) {
811         isArray.reserve(5);
812         for (unsigned i = 0; i < 5; ++i)
813             isArray.insert(isArray_array[i]);
814     }
815     newRow(expr) << isArray.contains(expr);
816 }
817 
isArray_test(const char *,const QScriptValue & value)818 void tst_QScriptValueGenerated::isArray_test(const char*, const QScriptValue& value)
819 {
820     QFETCH(bool, expected);
821     QCOMPARE(value.isArray(), expected);
822     QCOMPARE(value.isArray(), expected);
823 }
824 
DEFINE_TEST_FUNCTION(isArray)825 DEFINE_TEST_FUNCTION(isArray)
826 
827 
828 void tst_QScriptValueGenerated::isError_initData()
829 {
830     QTest::addColumn<bool>("expected");
831     initScriptValues();
832 }
833 
834 static QString isError_array[] = {
835     "engine->evaluate(\"Error.prototype\")",
836     "engine->evaluate(\"new Error()\")",
837     "engine->evaluate(\"Undefined\")",
838     "engine->evaluate(\"Null\")",
839     "engine->evaluate(\"True\")",
840     "engine->evaluate(\"False\")"
841 };
842 
isError_makeData(const char * expr)843 void tst_QScriptValueGenerated::isError_makeData(const char* expr)
844 {
845     static QSet<QString> isError;
846     if (isError.isEmpty()) {
847         isError.reserve(6);
848         for (unsigned i = 0; i < 6; ++i)
849             isError.insert(isError_array[i]);
850     }
851     newRow(expr) << isError.contains(expr);
852 }
853 
isError_test(const char *,const QScriptValue & value)854 void tst_QScriptValueGenerated::isError_test(const char*, const QScriptValue& value)
855 {
856     QFETCH(bool, expected);
857     QCOMPARE(value.isError(), expected);
858     QCOMPARE(value.isError(), expected);
859 }
860 
861 DEFINE_TEST_FUNCTION(isError)
862 
863