summaryrefslogtreecommitdiffstats
path: root/tests/auto/qscriptvalue/testgen
diff options
context:
space:
mode:
Diffstat (limited to 'tests/auto/qscriptvalue/testgen')
-rw-r--r--tests/auto/qscriptvalue/testgen/data.txt116
-rwxr-xr-xtests/auto/qscriptvalue/testgen/gen.py203
-rw-r--r--tests/auto/qscriptvalue/testgen/main.cpp40
-rw-r--r--tests/auto/qscriptvalue/testgen/testgen.pro18
-rw-r--r--tests/auto/qscriptvalue/testgen/testgenerator.cpp644
-rw-r--r--tests/auto/qscriptvalue/testgen/testgenerator.h55
6 files changed, 1076 insertions, 0 deletions
diff --git a/tests/auto/qscriptvalue/testgen/data.txt b/tests/auto/qscriptvalue/testgen/data.txt
new file mode 100644
index 0000000..8e7026e
--- /dev/null
+++ b/tests/auto/qscriptvalue/testgen/data.txt
@@ -0,0 +1,116 @@
+# Data set for QScriptValue autotest.
+
+# Each line is a c++ code that should return a QScriptValue object.
+# Lines that are empty or start with '#' will be ignored
+
+QScriptValue()
+
+#Unbound values
+QScriptValue(QScriptValue::UndefinedValue)
+QScriptValue(QScriptValue::NullValue)
+QScriptValue(true)
+QScriptValue(false)
+QScriptValue(int(122))
+QScriptValue(uint(124))
+QScriptValue(0)
+QScriptValue(0.0)
+QScriptValue(123.0)
+QScriptValue(6.37e-8)
+QScriptValue(-6.37e-8)
+QScriptValue(0x43211234)
+QScriptValue(0x10000)
+QScriptValue(0x10001)
+QScriptValue(qSNaN())
+QScriptValue(qQNaN())
+QScriptValue(qInf())
+QScriptValue(-qInf())
+QScriptValue("NaN")
+QScriptValue("Infinity")
+QScriptValue("-Infinity")
+QScriptValue("ciao")
+QScriptValue(QString::fromLatin1("ciao"))
+QScriptValue(QString(""))
+QScriptValue(QString())
+QScriptValue(QString("0"))
+QScriptValue(QString("123"))
+QScriptValue(QString("12.4"))
+
+#Unbound values (bound to a null engine)
+QScriptValue(0, QScriptValue::UndefinedValue)
+QScriptValue(0, QScriptValue::NullValue)
+QScriptValue(0, true)
+QScriptValue(0, false)
+QScriptValue(0, int(122))
+QScriptValue(0, uint(124))
+QScriptValue(0, 0)
+QScriptValue(0, 0.0)
+QScriptValue(0, 123.0)
+QScriptValue(0, 6.37e-8)
+QScriptValue(0, -6.37e-8)
+QScriptValue(0, 0x43211234)
+QScriptValue(0, 0x10000)
+QScriptValue(0, 0x10001)
+QScriptValue(0, qSNaN())
+QScriptValue(0, qQNaN())
+QScriptValue(0, qInf())
+QScriptValue(0, -qInf())
+QScriptValue(0, "NaN")
+QScriptValue(0, "Infinity")
+QScriptValue(0, "-Infinity")
+QScriptValue(0, "ciao")
+QScriptValue(0, QString::fromLatin1("ciao"))
+QScriptValue(0, QString(""))
+QScriptValue(0, QString())
+QScriptValue(0, QString("0"))
+QScriptValue(0, QString("123"))
+QScriptValue(0, QString("12.3"))
+
+#Bound values
+QScriptValue(engine, QScriptValue::UndefinedValue)
+QScriptValue(engine, QScriptValue::NullValue)
+QScriptValue(engine, true)
+QScriptValue(engine, false)
+QScriptValue(engine, int(122))
+QScriptValue(engine, uint(124))
+QScriptValue(engine, 0)
+QScriptValue(engine, 0.0)
+QScriptValue(engine, 123.0)
+QScriptValue(engine, 6.37e-8)
+QScriptValue(engine, -6.37e-8)
+QScriptValue(engine, 0x43211234)
+QScriptValue(engine, 0x10000)
+QScriptValue(engine, 0x10001)
+QScriptValue(engine, qSNaN())
+QScriptValue(engine, qQNaN())
+QScriptValue(engine, qInf())
+QScriptValue(engine, -qInf())
+QScriptValue(engine, "NaN")
+QScriptValue(engine, "Infinity")
+QScriptValue(engine, "-Infinity")
+QScriptValue(engine, "ciao")
+QScriptValue(engine, QString::fromLatin1("ciao"))
+QScriptValue(engine, QString(""))
+QScriptValue(engine, QString())
+QScriptValue(engine, QString("0"))
+QScriptValue(engine, QString("123"))
+QScriptValue(engine, QString("1.23"))
+
+# evaluate
+engine->evaluate("[]")
+engine->evaluate("{}")
+engine->evaluate("Object.prototype")
+engine->evaluate("Date.prototype")
+engine->evaluate("Array.prototype")
+engine->evaluate("Function.prototype")
+engine->evaluate("Error.prototype")
+engine->evaluate("Object")
+engine->evaluate("Array")
+engine->evaluate("Number")
+engine->evaluate("Function")
+engine->evaluate("(function() { return 1; })")
+engine->evaluate("(function() { return 'ciao'; })")
+engine->evaluate("(function() { throw new Error('foo'); })")
+engine->evaluate("/foo/")
+engine->evaluate("new Object()")
+engine->evaluate("new Array()")
+engine->evaluate("new Error()")
diff --git a/tests/auto/qscriptvalue/testgen/gen.py b/tests/auto/qscriptvalue/testgen/gen.py
new file mode 100755
index 0000000..fddb853
--- /dev/null
+++ b/tests/auto/qscriptvalue/testgen/gen.py
@@ -0,0 +1,203 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+#Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+
+#This library is free software; you can redistribute it and/or
+#modify it under the terms of the GNU Library General Public
+#License as published by the Free Software Foundation; either
+#version 2 of the License, or (at your option) any later version.
+
+#This library is distributed in the hope that it will be useful,
+#but WITHOUT ANY WARRANTY; without even the implied warranty of
+#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+#Library General Public License for more details.
+
+#You should have received a copy of the GNU Library General Public License
+#along with this library; see the file COPYING.LIB. If not, write to
+#the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+#Boston, MA 02110-1301, USA.
+
+from __future__ import with_statement
+from string import Template
+
+class Options():
+ """Option manager. It parse and check all paramteres, set internal variables."""
+ def __init__(self, args):
+ import logging as log
+ log.basicConfig()
+ #comand line options parser
+ from optparse import OptionParser
+ #load some directory searching stuff
+ import os.path, sys
+
+ opt = OptionParser("%prog [options] path_to_input_file path_to_output_file.")
+
+ self._o, self._a = opt.parse_args(args)
+
+ try:
+ if not (os.path.exists(self._a[0])):
+ raise Exception("Path doesn't exist")
+ if len(self._a) != 2:
+ raise IndexError("Only two files!")
+ self._o.ipath = self._a[0]
+ self._o.opath = self._a[1]
+ except IndexError:
+ log.error("Bad usage. Please try -h or --help")
+ sys.exit(1)
+ except Exception:
+ log.error("Path '" + self._a[0] + " or " + self._a[1] + "' don't exist")
+ sys.exit(2)
+
+ def __getattr__(self, attr):
+ """map all options properties into this object (remove one level of indirection)"""
+ return getattr(self._o, attr)
+
+
+mainTempl = Template("""/*
+ Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+////////////////////////////////////////////////////////////////
+// THIS FILE IS AUTOGENERATED, ALL MODIFICATIONS WILL BE LAST //
+////////////////////////////////////////////////////////////////
+
+#include "testgenerator.h"
+
+#include <QtCore/qdatastream.h>
+#include <QtCore/qdatetime.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qfile.h>
+#include <QtCore/qnumeric.h>
+#include <QtCore/qvariant.h>
+#include <QtCore/qvector.h>
+#include <QtScript/qscriptvalue.h>
+#include <QtScript/qscriptengine.h>
+
+
+
+typedef bool (QScriptValue::*ComparisionType) (const QScriptValue&) const;
+static QVector<bool> compare(ComparisionType compare, QScriptValue value, const QScriptValueList& values) {
+ QVector<bool> result;
+ result.reserve(${count});
+
+ QScriptValueList::const_iterator i = values.constBegin();
+ for (; i != values.constEnd(); ++i) {
+ result << (value.*compare)(*i);
+ }
+ return result;
+}
+
+static void dump(QDataStream& out, QScriptValue& value, const QString& expression, const QScriptValueList& allValues)
+{
+ out << QString(expression);
+
+ out << value.isValid();
+ out << value.isBool();
+ out << value.isBoolean();
+ out << value.isNumber();
+ out << value.isFunction();
+ out << value.isNull();
+ out << value.isString();
+ out << value.isUndefined();
+ out << value.isVariant();
+ out << value.isQObject();
+ out << value.isQMetaObject();
+ out << value.isObject();
+ out << value.isDate();
+ out << value.isRegExp();
+ out << value.isArray();
+ out << value.isError();
+
+ out << value.toString();
+ out << value.toNumber();
+ out << value.toBool();
+ out << value.toBoolean();
+ out << value.toInteger();
+ out << value.toInt32();
+ out << value.toUInt32();
+ out << value.toUInt16();
+
+ out << compare(&QScriptValue::equals, value, allValues);
+ out << compare(&QScriptValue::strictlyEquals, value, allValues);
+ out << compare(&QScriptValue::lessThan, value, allValues);
+ out << compare(&QScriptValue::instanceOf, value, allValues);
+
+ out << qscriptvalue_cast<QString>(value);
+ out << qscriptvalue_cast<qsreal>(value);
+ out << qscriptvalue_cast<bool>(value);
+ out << qscriptvalue_cast<qint32>(value);
+ out << qscriptvalue_cast<quint32>(value);
+ out << qscriptvalue_cast<quint16>(value);
+}
+
+void TestGenerator::prepareData()
+{
+ QScriptEngine* engine = new QScriptEngine;
+
+ QScriptValueList allValues;
+ allValues << ${values};
+ QVector<QString> allDataTags;
+ allDataTags.reserve(${count});
+ allDataTags << ${dataTags};
+ QDataStream out(&m_tempFile);
+ out << allDataTags;
+
+ for(unsigned i = 0; i < ${count}; ++i)
+ dump(out, allValues[i], allDataTags[i], allValues);
+
+ delete engine;
+}
+""")
+qsvTempl = Template("""
+ {
+ QScriptValue value = ${expr};
+ dump(out, value, "${expr_esc}", allValues);
+ }""")
+
+
+
+if __name__ == '__main__':
+ import sys
+ o = Options(sys.argv[1:])
+ out = []
+ qsv = []
+ # load input file
+ with open(o.ipath) as f:
+ for row in f.readlines():
+ qsv.append(row)
+
+ #skip comments and empty lines
+ qsv = filter(lambda w: len(w.strip()) and not w.startswith('#'), qsv)
+
+ escape = lambda w: w.replace('\\','\\\\').replace('"','\\"')
+
+ for row in qsv:
+ row = row.replace('\n','')
+ row_esc = escape(row)
+ out.append(qsvTempl.substitute(expr = row, expr_esc = row_esc))
+
+ result = mainTempl.substitute(dump= "".join(out) \
+ , values = (11 * ' ' + '<< ').join(qsv) \
+ , count = len(qsv) \
+ , dataTags = (11 * ' ' + '<< ').join(map(lambda w: '"' + escape(w.replace('\n','')) + '"\n', qsv)))
+
+ with open(o.opath, 'w') as f:
+ f.write(result)
+
+
diff --git a/tests/auto/qscriptvalue/testgen/main.cpp b/tests/auto/qscriptvalue/testgen/main.cpp
new file mode 100644
index 0000000..389a725
--- /dev/null
+++ b/tests/auto/qscriptvalue/testgen/main.cpp
@@ -0,0 +1,40 @@
+/*
+ Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "testgenerator.h"
+#include <QtCore/qdebug.h>
+#include <QtCore/qfile.h>
+#include <QtCore/qstringlist.h>
+#include <QtCore/QCoreApplication>
+
+int main(int argc, char *argv[])
+{
+ QCoreApplication a(argc, argv);
+
+ if (argc != 2) {
+ qWarning() << "./prog outputfile";
+ exit(1);
+ }
+
+ //Procced
+ TestGenerator gen(a.arguments()[1]);
+ gen.run();
+
+ return 0;
+}
diff --git a/tests/auto/qscriptvalue/testgen/testgen.pro b/tests/auto/qscriptvalue/testgen/testgen.pro
new file mode 100644
index 0000000..47709a8
--- /dev/null
+++ b/tests/auto/qscriptvalue/testgen/testgen.pro
@@ -0,0 +1,18 @@
+QT += core script
+TARGET = testgen
+CONFIG += console
+CONFIG -= app_bundle
+TEMPLATE = app
+
+SOURCES += main.cpp \
+ testgenerator.cpp
+HEADERS += testgenerator.h
+
+
+INPUT_DATASET = data.txt
+dataset.name = Generating QScraiptValue autotest's dataset
+dataset.output = autogenerated.cpp
+dataset.commands = python gen.py data.txt autogenerated.cpp
+dataset.input = INPUT_DATASET
+dataset.variable_out = SOURCES
+QMAKE_EXTRA_COMPILERS += dataset
diff --git a/tests/auto/qscriptvalue/testgen/testgenerator.cpp b/tests/auto/qscriptvalue/testgen/testgenerator.cpp
new file mode 100644
index 0000000..199e84b
--- /dev/null
+++ b/tests/auto/qscriptvalue/testgen/testgenerator.cpp
@@ -0,0 +1,644 @@
+/*
+ Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "testgenerator.h"
+
+#include <QtCore/qdatastream.h>
+#include <QtCore/qdatetime.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qnumeric.h>
+#include <QtCore/qstringlist.h>
+#include <QtCore/qtextstream.h>
+#include <QtCore/qvariant.h>
+#include <QtScript/qscriptvalue.h>
+
+void TestGenerator::save(const QString& data)
+{
+ QTextStream out(&m_ofile);
+ out << data;
+}
+
+static QString escape(QString txt)
+{
+ return txt.replace("\\","\\\\").replace("\"","\\\"").replace("\n","\\n");
+}
+
+template<typename T>
+QString prepareToInsert(T value) {return QString::fromAscii("\"") + escape(value) + "\"";}
+template<>
+QString prepareToInsert<qsreal>(qsreal value)
+{
+ if (qIsNaN(value))
+ return "qQNaN()";
+ if (qIsInf(value))
+ return "qInf()";
+ return QString::number(value, 'g', 16);
+}
+template<>
+QString prepareToInsert<qint32>(qint32 value) {return QString::number(value);}
+template<>
+QString prepareToInsert<quint32>(quint32 value) {return QString::number(value);}
+template<>
+QString prepareToInsert<quint16>(quint16 value) {return QString::number(value);}
+template<>
+QString prepareToInsert<bool>(bool value) {return value ? "true" : "false";}
+template<>
+QString prepareToInsert<QString>(QString value) {return QString::fromAscii("\"") + escape(value) + "\"";}
+
+template<typename T>
+QString typeName() {return QString();}
+template<>
+QString typeName<qsreal>() {return "qsreal";}
+template<>
+QString typeName<qint32>() {return "qint32";}
+template<>
+QString typeName<quint32>() {return "quint32";}
+template<>
+QString typeName<quint16>() {return "quint16";}
+template<>
+QString typeName<bool>() {return "bool";}
+template<>
+QString typeName<QString>() {return "QString";}
+
+static QString generateIsXXXDef(const QString& name, const QList<QString>& list)
+{
+ static const QString templ("void tst_QScriptValue::%1_initData()\n"\
+ "{\n"\
+ " QTest::addColumn<bool>(\"expected\");\n"\
+ " initScriptValues();\n"\
+ "}\n"\
+ "\n"\
+ "void tst_QScriptValue::%1_makeData(const char* expr)\n"\
+ "{\n"\
+ " static QSet<QString> %1;\n"\
+ " if (%1.isEmpty()) {\n"\
+ " %1%2\n"\
+ " }\n"\
+ " newRow(expr) << %1.contains(expr);\n"\
+ "}\n"\
+ "\n"\
+ "void tst_QScriptValue::%1_test(const char*, const QScriptValue& value)\n"\
+ "{\n"\
+ " QFETCH(bool, expected);\n"\
+ " QCOMPARE(value.%1(), expected);\n"\
+ "}\n"\
+ "\n"\
+ "DEFINE_TEST_FUNCTION(%1)\n"\
+ "\n");
+
+ if (!list.size()) {
+ qWarning() << name << ": nothing to add!" ;
+ return QString();
+ }
+
+ QString result = templ;
+ QStringList set;
+ foreach(QString t, list) {
+ t = escape(t);
+ t.append('\"');
+ t.prepend('\"');
+ set.append(QString(" << "));
+ set.append(t);
+ set.append("\n ");
+ }
+ set.append(";");
+ return result.arg(name, set.join(QString()));
+}
+
+template<typename T>
+static QString generateToXXXDef(const QString& name, const QList<QPair<QString, T> >& list)
+{
+ static const QString templ = "\n"\
+ "void tst_QScriptValue::%1_initData()\n"\
+ "{\n"\
+ " QTest::addColumn<%2>(\"expected\");\n"\
+ " initScriptValues();\n"\
+ "}\n"\
+ "\n"\
+ "void tst_QScriptValue::%1_makeData(const char* expr)\n"\
+ "{\n"\
+ " static QHash<QString, %2> %1;\n"\
+ " if (%1.isEmpty()) {\n"\
+ "%3"\
+ " }\n"\
+ " newRow(expr) << %1.value(expr);\n"\
+ "}\n"\
+ "\n"\
+ "void tst_QScriptValue::%1_test(const char*, const QScriptValue& value)\n"\
+ "{\n"\
+ " QFETCH(%2, expected);\n"\
+ " QCOMPARE(value.%1(), expected);\n"\
+ "}\n"\
+ "\n"\
+ "DEFINE_TEST_FUNCTION(%1)\n";
+ QString result = templ;
+
+ typename QList<QPair<QString, T> >::const_iterator i = list.constBegin();
+ QStringList set;
+ for(; i != list.constEnd(); ++i) {
+ QPair<QString, T> t = *i;
+ t.first = escape(t.first);
+ set.append(QString(" "));
+ set.append(name);
+ set.append(".insert(\"");
+ set.append(t.first);
+ set.append(QString::fromAscii("\", "));
+ set.append(prepareToInsert<T>(t.second));
+ set.append(QString::fromAscii(");\n"));
+ }
+ return result.arg(name, typeName<T>(), set.join(QString()));
+}
+
+
+template<>
+QString generateToXXXDef<qsreal>(const QString& name, const QList<QPair<QString, qsreal> >& list)
+{
+ static const QString templ = "\n"\
+ "void tst_QScriptValue::%1_initData()\n"\
+ "{\n"\
+ " QTest::addColumn<%2>(\"expected\");\n"\
+ " initScriptValues();\n"\
+ "}\n"\
+ "\n"\
+ "void tst_QScriptValue::%1_makeData(const char* expr)\n"\
+ "{\n"\
+ " static QHash<QString, %2> %1;\n"\
+ " if (%1.isEmpty()) {\n"\
+ "%3"\
+ " }\n"\
+ " newRow(expr) << %1.value(expr);\n"\
+ "}\n"\
+ "\n"\
+ "void tst_QScriptValue::%1_test(const char*, const QScriptValue& value)\n"\
+ "{\n"\
+ " QFETCH(%2, expected);\n"\
+ "%666"
+ " if (qIsInf(expected)) {\n"\
+ " QVERIFY(qIsInf(value.%1()));\n"\
+ " return;\n"\
+ " }\n"\
+ " QCOMPARE(value.%1(), expected);\n"\
+ "}\n"\
+ "\n"\
+ "DEFINE_TEST_FUNCTION(%1)\n";
+ QString result = templ;
+
+ QList<QPair<QString, qsreal> >::const_iterator i = list.constBegin();
+ QStringList set;
+ for(; i != list.constEnd(); ++i) {
+ QPair<QString, qsreal> t = *i;
+ t.first = escape(t.first);
+ set.append(QString(" "));
+ set.append(name);
+ set.append(".insert(\"");
+ set.append(t.first);
+ set.append(QString::fromAscii("\", "));
+ set.append(prepareToInsert<qsreal>(t.second));
+ set.append(QString::fromAscii(");\n"));
+ }
+ // toInteger shouldn't return NaN, so it would be nice to catch the case.
+ QString hook;
+ if (name == "toNumber") {
+ hook =
+ " if (qIsNaN(expected)) {\n"\
+ " QVERIFY(qIsNaN(value.toNumber()));\n"\
+ " return;\n"\
+ " }\n";
+ }
+ return result.arg(name, typeName<qsreal>(), set.join(QString()), hook);
+}
+
+template<typename T>
+static QString generateCastDef(const QList<QPair<QString, T> >& list)
+{
+ static const QString templ = "\n"\
+ "void tst_QScriptValue::qscriptvalue_cast%2_initData()\n"\
+ "{\n"\
+ " QTest::addColumn<%2>(\"expected\");\n"\
+ " initScriptValues();\n"\
+ "}\n"\
+ "\n"\
+ "void tst_QScriptValue::qscriptvalue_cast%2_makeData(const char* expr)\n"\
+ "{\n"\
+ " static QHash<QString, %2> value;\n"\
+ " if (value.isEmpty()) {\n"\
+ "%3"\
+ " }\n"\
+ " newRow(expr) << value.value(expr);\n"\
+ "}\n"\
+ "\n"\
+ "void tst_QScriptValue::qscriptvalue_cast%2_test(const char*, const QScriptValue& value)\n"\
+ "{\n"\
+ " QFETCH(%2, expected);\n"\
+ " QCOMPARE(qscriptvalue_cast<%2>(value), expected);\n"\
+ "}\n"\
+ "\n"\
+ "DEFINE_TEST_FUNCTION(qscriptvalue_cast%2)\n";
+ QString result = templ;
+
+ typename QList<QPair<QString, T> >::const_iterator i = list.constBegin();
+ QStringList set;
+ for(; i != list.constEnd(); ++i) {
+ QPair<QString, T> t = *i;
+ t.first = escape(t.first);
+ set.append(QString(" "));
+ set.append("value.insert(\"");
+ set.append(t.first);
+ set.append(QString::fromAscii("\", "));
+ set.append(prepareToInsert<T>(t.second));
+ set.append(QString::fromAscii(");\n"));
+ }
+ return result.arg(typeName<T>(), set.join(QString()));
+}
+
+template<>
+QString generateCastDef<qsreal>(const QList<QPair<QString, qsreal> >& list)
+{
+ static const QString templ = "\n"\
+ "void tst_QScriptValue::qscriptvalue_cast%2_initData()\n"\
+ "{\n"\
+ " QTest::addColumn<%2>(\"expected\");\n"\
+ " initScriptValues();\n"\
+ "}\n"\
+ "\n"\
+ "void tst_QScriptValue::qscriptvalue_cast%2_makeData(const char* expr)\n"\
+ "{\n"\
+ " static QHash<QString, %2> value;\n"\
+ " if (value.isEmpty()) {\n"\
+ "%3"\
+ " }\n"\
+ " newRow(expr) << value.value(expr);\n"\
+ "}\n"\
+ "\n"\
+ "void tst_QScriptValue::qscriptvalue_cast%2_test(const char*, const QScriptValue& value)\n"\
+ "{\n"\
+ " QFETCH(%2, expected);\n"\
+ " if (qIsNaN(expected)) {\n"
+ " QVERIFY(qIsNaN(qscriptvalue_cast<%2>(value)));\n"
+ " return;\n"
+ " }\n"\
+ " if (qIsInf(expected)) {\n"
+ " QVERIFY(qIsInf(qscriptvalue_cast<%2>(value)));\n"
+ " return;\n"
+ " }\n"
+ " QCOMPARE(qscriptvalue_cast<%2>(value), expected);\n"\
+ "}\n"\
+ "\n"\
+ "DEFINE_TEST_FUNCTION(qscriptvalue_cast%2)\n";
+ QString result = templ;
+
+ QList<QPair<QString, qsreal> >::const_iterator i = list.constBegin();
+ QStringList set;
+ for(; i != list.constEnd(); ++i) {
+ QPair<QString, qsreal> t = *i;
+ t.first = escape(t.first);
+ set.append(QString(" "));
+ set.append("value.insert(\"");
+ set.append(t.first);
+ set.append(QString::fromAscii("\", "));
+ set.append(prepareToInsert<qsreal>(t.second));
+ set.append(QString::fromAscii(");\n"));
+ }
+ return result.arg(typeName<qsreal>(), set.join(QString()));
+}
+
+static QString generateCompareDef(const QString& comparisionType, const QList<QString> tags)
+{
+ static const QString templ = "\n"\
+ "void tst_QScriptValue::%1_initData()\n"\
+ "{\n"\
+ " QTest::addColumn<QScriptValue>(\"other\");\n"\
+ " QTest::addColumn<bool>(\"expected\");\n"\
+ " initScriptValues();\n"\
+ "}\n"\
+ "\n"\
+ "void tst_QScriptValue::%1_makeData(const char *expr)\n"\
+ "{\n"\
+ " static QSet<QString> equals;\n"\
+ " if (equals.isEmpty()) {\n"\
+ "%2\n"\
+ " }\n"\
+ " QHash<QString, QScriptValue>::const_iterator it;\n"\
+ " for (it = m_values.constBegin(); it != m_values.constEnd(); ++it) {\n"\
+ " QString tag = QString::fromLatin1(\"%20 <=> %21\").arg(expr).arg(it.key());\n"\
+ " newRow(tag.toLatin1()) << it.value() << equals.contains(tag);\n"\
+ " }\n"\
+ "}\n"\
+ "\n"\
+ "void tst_QScriptValue::%1_test(const char *, const QScriptValue& value)\n"\
+ "{\n"\
+ " QFETCH(QScriptValue, other);\n"\
+ " QFETCH(bool, expected);\n"\
+ " QCOMPARE(value.%1(other), expected);\n"\
+ "}\n"\
+ "\n"\
+ "DEFINE_TEST_FUNCTION(%1)\n";
+ Q_ASSERT(comparisionType == "strictlyEquals"
+ || comparisionType == "equals"
+ || comparisionType == "lessThan"
+ || comparisionType == "instanceOf");
+ QString result = templ;
+
+ QStringList set;
+ foreach(const QString& tmp, tags) {
+ set.append(" equals.insert(\"" + escape(tmp) + "\");");
+ }
+ return result.arg(comparisionType, set.join("\n"));
+}
+
+static QString generateInitDef(const QVector<QString>& allDataTags)
+{
+ static const QString templ = "/*\n"\
+ " Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)\n"\
+ "\n"\
+ " This library is free software; you can redistribute it and/or\n"\
+ " modify it under the terms of the GNU Library General Public\n"\
+ " License as published by the Free Software Foundation; either\n"\
+ " version 2 of the License, or (at your option) any later version.\n"\
+ "\n"\
+ " This library is distributed in the hope that it will be useful,\n"\
+ " but WITHOUT ANY WARRANTY; without even the implied warranty of\n"\
+ " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"\
+ " Library General Public License for more details.\n"\
+ "\n"\
+ " You should have received a copy of the GNU Library General Public License\n"\
+ " along with this library; see the file COPYING.LIB. If not, write to\n"\
+ " the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,\n"\
+ " Boston, MA 02110-1301, USA.\n"\
+ "*/\n"\
+ "\n"\
+ "#include \"tst_qscriptvalue.h\"\n\n"\
+ "#define DEFINE_TEST_VALUE(expr) m_values.insert(QString::fromLatin1(#expr), expr)\n"\
+ "\n"\
+ "void tst_QScriptValue::initScriptValues()\n"\
+ "{\n"\
+ " m_values.clear();\n"\
+ " if (engine) \n"\
+ " delete engine;\n"\
+ " engine = new QScriptEngine;\n"\
+ "%1\n}\n\n";
+ QString result = templ;
+ QStringList set;
+ foreach(const QString tag, allDataTags) {
+ set.append(" DEFINE_TEST_VALUE(" + tag + ");");
+ }
+
+ return result.arg(set.join("\n"));
+}
+
+static void squashTags(QString dataTag, const QVector<bool>& results, QList<QString>& tags, QVector<QString> dataTags)
+{
+ for(int i = 0; i < results.count(); ++i) {
+ if (results.at(i))
+ tags.append(dataTag + " <=> " + dataTags[i]);
+ }
+}
+
+
+QString TestGenerator::generateTest()
+{
+ // All data tags keept in one place.
+ QVector<QString> dataTags;
+
+ // Data tags for values that return true in isXXX call
+ QList<QString> isValidList;
+ QList<QString> isBoolList;
+ QList<QString> isBooleanList;
+ QList<QString> isNumberList;
+ QList<QString> isFunctionList;
+ QList<QString> isNullList;
+ QList<QString> isStringList;
+ QList<QString> isUndefinedList;
+ QList<QString> isVariantList;
+ QList<QString> isQObjectList;
+ QList<QString> isQMetaObjectList;
+ QList<QString> isObjectList;
+ QList<QString> isDateList;
+ QList<QString> isRegExpList;
+ QList<QString> isArrayList;
+ QList<QString> isErrorList;
+
+ // List of pairs data tag and value returned from toXXX call
+ QList<QPair<QString, QString> > toStringList;
+ QList<QPair<QString, qsreal> > toNumberList;
+ QList<QPair<QString, bool> > toBoolList;
+ QList<QPair<QString, bool> > toBooleanList;
+ QList<QPair<QString, qsreal> > toIntegerList;
+ QList<QPair<QString, qint32> > toInt32List;
+ QList<QPair<QString, quint32> > toUInt32List;
+ QList<QPair<QString, quint16> > toUInt16List;
+
+ // List of complex tags returning true
+ QList<QString> equalsList;
+ QList<QString> strictlyEqualsList;
+ QList<QString> lessThanList;
+ QList<QString> instanceOfList;
+
+ QList<QPair<QString, QString> > castStringList;
+ QList<QPair<QString, qsreal> > castSRealList;
+ QList<QPair<QString, bool> > castBoolList;
+ QList<QPair<QString, qint32> > castInt32List;
+ QList<QPair<QString, quint32> > castUInt32List;
+ QList<QPair<QString, quint16> > castUInt16List;
+
+ // Load.
+ m_tempFile.seek(0);
+ QDataStream in(&m_tempFile);
+ in >> dataTags;
+ Q_ASSERT(in.status() == in.Ok);
+
+ while(!in.atEnd())
+ {
+ bool isValidRes;
+ bool isBoolRes;
+ bool isBooleanRes;
+ bool isNumberRes;
+ bool isFunctionRes;
+ bool isNullRes;
+ bool isStringRes;
+ bool isUndefinedRes;
+ bool isVariantRes;
+ bool isQObjectRes;
+ bool isQMetaObjectRes;
+ bool isObjectRes;
+ bool isDateRes;
+ bool isRegExpRes;
+ bool isArrayRes;
+ bool isErrorRes;
+
+ QString toStringRes;
+ qsreal toNumberRes;
+ bool toBoolRes;
+ bool toBooleanRes;
+ qsreal toIntegerRes;
+ qint32 toInt32Res;
+ quint32 toUInt32Res;
+ quint16 toUInt16Res;
+ //toVariantRes;
+ //toDateTimeRes;
+
+ QVector<bool> equalsRes;
+ QVector<bool> strictlyEqualsRes;
+ QVector<bool> lessThanRes;
+ QVector<bool> instanceOfRes;
+
+ QString castStringRes;
+ qsreal castSRealRes;
+ bool castBoolRes;
+ qint32 castInt32Res;
+ quint32 castUInt32Res;
+ quint16 castUInt16Res;
+
+ QString dataTag;
+ in >> dataTag;
+ in >> isValidRes;
+ in >> isBoolRes;
+ in >> isBooleanRes;
+ in >> isNumberRes;
+ in >> isFunctionRes;
+ in >> isNullRes;
+ in >> isStringRes;
+ in >> isUndefinedRes;
+ in >> isVariantRes;
+ in >> isQObjectRes;
+ in >> isQMetaObjectRes;
+ in >> isObjectRes;
+ in >> isDateRes;
+ in >> isRegExpRes;
+ in >> isArrayRes;
+ in >> isErrorRes;
+
+ if (isValidRes) isValidList.append(dataTag);
+ if (isBoolRes) isBoolList.append(dataTag);
+ if (isBooleanRes) isBooleanList.append(dataTag);
+ if (isNumberRes) isNumberList.append(dataTag);
+ if (isFunctionRes) isFunctionList.append(dataTag);
+ if (isNullRes) isNullList.append(dataTag);
+ if (isStringRes) isStringList.append(dataTag);
+ if (isUndefinedRes) isUndefinedList.append(dataTag);
+ if (isVariantRes) isVariantList.append(dataTag);
+ if (isQObjectRes) isQObjectList.append(dataTag);
+ if (isQMetaObjectRes) isQMetaObjectList.append(dataTag);
+ if (isObjectRes) isObjectList.append(dataTag);
+ if (isDateRes) isDateList.append(dataTag);
+ if (isRegExpRes) isRegExpList.append(dataTag);
+ if (isArrayRes) isArrayList.append(dataTag);
+ if (isErrorRes) isErrorList.append(dataTag);
+
+ in >> toStringRes;
+ in >> toNumberRes;
+ in >> toBoolRes;
+ in >> toBooleanRes;
+ in >> toIntegerRes;
+ in >> toInt32Res;
+ in >> toUInt32Res;
+ in >> toUInt16Res;
+ //in >> toVariantRes;
+ //in >> toDateTimeRes;
+
+ toStringList.append(QPair<QString, QString>(dataTag, toStringRes));
+ toNumberList.append(QPair<QString, qsreal>(dataTag, toNumberRes));
+ toBoolList.append(QPair<QString, bool>(dataTag, toBoolRes));
+ toBooleanList.append(QPair<QString, bool>(dataTag, toBooleanRes));
+ toIntegerList.append(QPair<QString, qsreal>(dataTag, toIntegerRes));
+ toInt32List.append(QPair<QString, qint32>(dataTag, toInt32Res));
+ toUInt32List.append(QPair<QString, quint32>(dataTag, toUInt32Res));
+ toUInt16List.append(QPair<QString, quint16>(dataTag, toUInt16Res));
+
+ in >> equalsRes;
+ in >> strictlyEqualsRes;
+ in >> lessThanRes;
+ in >> instanceOfRes;
+
+ squashTags(dataTag, equalsRes, equalsList, dataTags);
+ squashTags(dataTag, strictlyEqualsRes, strictlyEqualsList, dataTags);
+ squashTags(dataTag, lessThanRes, lessThanList, dataTags);
+ squashTags(dataTag, instanceOfRes, instanceOfList, dataTags);
+
+ in >> castStringRes;
+ in >> castSRealRes;
+ in >> castBoolRes;
+ in >> castInt32Res;
+ in >> castUInt32Res;
+ in >> castUInt16Res;
+
+ castStringList.append(QPair<QString, QString>(dataTag, castStringRes));
+ castSRealList.append(QPair<QString, qsreal>(dataTag, castSRealRes));
+ castBoolList.append(QPair<QString, bool>(dataTag, castBoolRes));
+ castInt32List.append(QPair<QString, qint32>(dataTag, castInt32Res));
+ castUInt32List.append(QPair<QString, quint32>(dataTag, castUInt32Res));
+ castUInt16List.append(QPair<QString, quint16>(dataTag, castUInt16Res));
+
+ Q_ASSERT(in.status() == in.Ok);
+ }
+
+ Q_ASSERT(in.atEnd());
+
+ // Generate.
+ QStringList result;
+ result.append(generateInitDef(dataTags));
+ result.append(generateIsXXXDef("isValid", isValidList));
+ result.append(generateIsXXXDef("isBool", isBoolList));
+ result.append(generateIsXXXDef("isBoolean", isBooleanList));
+ result.append(generateIsXXXDef("isNumber", isNumberList));
+ result.append(generateIsXXXDef("isFunction", isFunctionList));
+ result.append(generateIsXXXDef("isNull", isNullList));
+ result.append(generateIsXXXDef("isString", isStringList));
+ result.append(generateIsXXXDef("isUndefined", isUndefinedList));
+ result.append(generateIsXXXDef("isVariant", isVariantList));
+ result.append(generateIsXXXDef("isQObject", isQObjectList));
+ result.append(generateIsXXXDef("isQMetaObject", isQMetaObjectList));
+ result.append(generateIsXXXDef("isObject", isObjectList));
+ result.append(generateIsXXXDef("isDate", isDateList));
+ result.append(generateIsXXXDef("isRegExp", isRegExpList));
+ result.append(generateIsXXXDef("isArray", isArrayList));
+ result.append(generateIsXXXDef("isError", isErrorList));
+
+ result.append(generateToXXXDef<QString>("toString", toStringList));
+ result.append(generateToXXXDef<qsreal>("toNumber", toNumberList));
+ result.append(generateToXXXDef<bool>("toBool", toBoolList));
+ result.append(generateToXXXDef<bool>("toBoolean", toBooleanList));
+ result.append(generateToXXXDef<qsreal>("toInteger", toIntegerList));
+ result.append(generateToXXXDef<qint32>("toInt32", toInt32List));
+ result.append(generateToXXXDef<quint32>("toUInt32", toUInt32List));
+ result.append(generateToXXXDef<quint16>("toUInt16", toUInt16List));
+
+ result.append(generateCompareDef("equals", equalsList));
+ result.append(generateCompareDef("strictlyEquals", strictlyEqualsList));
+ result.append(generateCompareDef("lessThan", lessThanList));
+ result.append(generateCompareDef("instanceOf", instanceOfList));
+
+ result.append(generateCastDef(castStringList));
+ result.append(generateCastDef(castSRealList));
+ result.append(generateCastDef(castBoolList));
+ result.append(generateCastDef(castInt32List));
+ result.append(generateCastDef(castUInt32List));
+ result.append(generateCastDef(castUInt16List));
+
+ return result.join("\n");
+}
+
+
+
+
+
+
+
+
+
diff --git a/tests/auto/qscriptvalue/testgen/testgenerator.h b/tests/auto/qscriptvalue/testgen/testgenerator.h
new file mode 100644
index 0000000..d3a2196
--- /dev/null
+++ b/tests/auto/qscriptvalue/testgen/testgenerator.h
@@ -0,0 +1,55 @@
+/*
+ Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#ifndef TESTGENERATOR_H
+#define TESTGENERATOR_H
+
+#include <QtCore/qdebug.h>
+#include <QtCore/qfile.h>
+#include <QtCore/qtemporaryfile.h>
+
+class TestGenerator {
+public:
+ TestGenerator(QString& outputpath)
+ : m_ofile(outputpath)
+ {
+ // Open output file
+ if (!m_ofile.open(QIODevice::WriteOnly | QIODevice::Text)) {
+ qWarning() << "Can't open output file: " << outputpath;
+ exit(2);
+ }
+ m_tempFile.open();
+ }
+
+ void run()
+ {
+ prepareData();
+ Q_ASSERT(m_tempFile.size());
+ save(generateTest());
+ }
+
+ void prepareData();
+ QString generateTest();
+ void save(const QString& data);
+private:
+ QFile m_ofile;
+ QTemporaryFile m_tempFile;
+};
+
+#endif // TESTGENERATOR_H
generated by cgit v0.12 at 2025-01-05 02:31:28 (GMT)