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