/****************************************************************************

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#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 QHash<QString, QString>& data)

{

    foreach(const QString& name, data.keys()) {

        QFile ofile(m_opath + "tst_qscriptvalue_generated_" + name + ".cpp");

        if (!ofile.open(QIODevice::WriteOnly | QIODevice::Text)) {

            qWarning() << "Can't open output file: " << ofile.fileName();

            exit(2);

        }

        QTextStream out(&ofile);

        out << data[name];

    }

}

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 generateLicence()

{

    return  "/****************************************************************************\n"

            "**\n"

            "** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).\n"

            "** All rights reserved.\n"

            "** Contact: Nokia Corporation (qt-info@nokia.com)\n"

            "**\n"

            "** This file is part of the test suite of the Qt Toolkit.\n"

            "**\n"

            "** $QT_BEGIN_LICENSE:LGPL$\n"

            "** No Commercial Usage\n"

            "** This file contains pre-release code and may not be distributed.\n"

            "** You may use this file in accordance with the terms and conditions\n"

            "** contained in the Technology Preview License Agreement accompanying\n"

            "** this package.\n"

            "**\n"

            "** GNU Lesser General Public License Usage\n"

            "** Alternatively, this file may be used under the terms of the GNU Lesser\n"

            "** General Public License version 2.1 as published by the Free Software\n"

            "** Foundation and appearing in the file LICENSE.LGPL included in the\n"

            "** packaging of this file.  Please review the following information to\n"

            "** ensure the GNU Lesser General Public License version 2.1 requirements\n"

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

            "**\n"

            "** In addition, as a special exception, Nokia gives you certain additional\n"

            "** rights.  These rights are described in the Nokia Qt LGPL Exception\n"

            "** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.\n"

            "**\n"

            "** If you have questions regarding the use of this file, please contact\n"

            "** Nokia at qt-info@nokia.com.\n"

            "**\n"

            "**\n"

            "**\n"

            "**\n"

            "**\n"

            "**\n"

            "**\n"

            "**\n"

            "** $QT_END_LICENSE$\n"

            "**\n"

            "****************************************************************************/\n"

            "\n"\

            "/****************************************************************************\n"\

            "*************** This file has been generated. DO NOT MODIFY! ****************\n"

            "****************************************************************************/\n\n"\

            "#include \"tst_qscriptvalue.h\"\n\n";

}

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"\

                               "static QString %1_array [] = {%2};\n\n"\

                               "void tst_QScriptValue::%1_makeData(const char* expr)\n"\

                               "{\n"\

                               "    static QSet<QString> %1;\n"\

                               "    if (%1.isEmpty()) {\n"\

                               "        %1.reserve(%3);\n"\

                               "        for (unsigned i = 0; i < %3; ++i)\n"\

                               "            %1.insert(%1_array[i]);\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"\

                               "    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;

    set.reserve(3 * list.count());

    foreach(const QString& t, list) {

        set.append("\n    \"");

        set.append(escape(t));

        set.append("\",");

    }

    return result.arg(name, set.join(QString()), QString::number(list.count()));

}

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"\

                                 "static QString %1_tagArray [] = {%4};\n\n"\

                                 "static %2 %1_valueArray [] = {%5};\n\n"\

                                 "void tst_QScriptValue::%1_makeData(const char* expr)\n"\

                                 "{\n"\

                                 "    static QHash<QString, %2> %1;\n"\

                                 "    if (%1.isEmpty()) {\n"\

                                 "        %1.reserve(%3);\n"\

                                 "        for (unsigned i = 0; i < %3; ++i)\n"\

                                 "            %1.insert(%1_tagArray[i], %1_valueArray[i]);\n"\

                                 "    }\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"\

                                 "    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 tagSet, valueSet;

    tagSet.reserve(list.count());

    valueSet.reserve(list.count());

    int tmp = -1;

    for(; i != list.constEnd(); ++i) {

        QPair<QString, T> t = *i;

        t.first = escape(t.first);

        tagSet.append(QString("\n    \""));

        tagSet.append(t.first);

        tagSet.append(QString::fromAscii("\","));

        if (!((++tmp)%2))

            valueSet.append(QString("\n    "));

        valueSet.append(prepareToInsert<T>(t.second));

        valueSet.append(QString::fromAscii(", "));

    }

    return result.arg(name,

                      typeName<T>(),

                      QString::number(list.count()),

                      tagSet.join(QString()),

                      valueSet.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"\

                                 "static QString %1_tagArray [] = {%3};\n"\

                                 "static %2 %1_valueArray [] = {%4};\n"\

                                 "void tst_QScriptValue::%1_makeData(const char* expr)\n"\

                                 "{\n"\

                                 "    static QHash<QString, %2> %1;\n"\

                                 "    if (%1.isEmpty()) {\n"\

                                 "        %1.reserve(%5);\n"\

                                 "        for (unsigned i = 0; i < %5; ++i)\n"\

                                 "            %1.insert(%1_tagArray[i], %1_valueArray[i]);\n"\

                                 "    }\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"\

                                 "        QVERIFY(qIsInf(value.%1()));\n"\

                                 "        return;\n"\

                                 "    }\n"\

                                 "    QCOMPARE(value.%1(), expected);\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 tagSet, valueSet;

    tagSet.reserve(list.count());

    valueSet.reserve(list.count());

    int tmp = -1;

    for(; i != list.constEnd(); ++i) {

        QPair<QString, qsreal> t = *i;

        t.first = escape(t.first);

        tagSet.append(QString("\n    \""));

        tagSet.append(t.first);

        tagSet.append(QString::fromAscii("\","));

        if (!((++tmp)%10))

            valueSet.append(QString("\n    "));

        valueSet.append(prepareToInsert<qsreal>(t.second));

        valueSet.append(QString::fromAscii(", "));

    }

    // 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>(),

          tagSet.join(QString()),

          valueSet.join(QString()),

          QString::number(list.count()),

          hook);

}

template<typename T>

static QString generateCastDef(const QList<QPair<QString, T> >& list)

{

    static const QString templ = "\n"\

                                 "void tst_QScriptValue::qscriptvalue_cast%1_initData()\n"\

                                 "{\n"\

                                 "    QTest::addColumn<%1>(\"expected\");\n"\

                                 "    initScriptValues();\n"\

                                 "}\n"\

                                 "\n"\

                                 "static QString qscriptvalue_cast%1_tagArray [] = {%2};\n"\

                                 "static %1 qscriptvalue_cast%1_valueArray [] = {%3};\n"\

                                 "void tst_QScriptValue::qscriptvalue_cast%1_makeData(const char* expr)\n"\

                                 "{\n"\

                                 "    static QHash<QString, %1> value;\n"\

                                 "    if (value.isEmpty()) {\n"\

                                 "        value.reserve(%4);\n"\

                                 "        for (unsigned i = 0; i < %4; ++i)\n"\

                                 "            value.insert(qscriptvalue_cast%1_tagArray[i], qscriptvalue_cast%1_valueArray[i]);\n"\

                                 "    }\n"\

                                 "    newRow(expr) << value.value(expr);\n"\

                                 "}\n"\

                                 "\n"\

                                 "void tst_QScriptValue::qscriptvalue_cast%1_test(const char*, const QScriptValue& value)\n"\

                                 "{\n"\

                                 "    QFETCH(%1, expected);\n"\

                                 "    QCOMPARE(qscriptvalue_cast<%1>(value), expected);\n"\

                                 "    QCOMPARE(qscriptvalue_cast<%1>(value), expected);\n"\

                                 "}\n"\

                                 "\n"\

                                 "DEFINE_TEST_FUNCTION(qscriptvalue_cast%1)\n";

    QString result = templ;

    typename QList<QPair<QString, T> >::const_iterator i = list.constBegin();

    QStringList tagSet, valueSet;

    tagSet.reserve(list.count());

    valueSet.reserve(list.count());

    int tmp = -1;

    for(; i != list.constEnd(); ++i) {

        QPair<QString, T> t = *i;

        t.first = escape(t.first);

        tagSet.append(QString("\n    \""));

        tagSet.append(t.first);

        tagSet.append(QString::fromAscii("\","));

        if (!((++tmp)%2))

            valueSet.append(QString("\n    "));

        valueSet.append(prepareToInsert<T>(t.second));

        valueSet.append(QString::fromAscii(", "));

    }

    return result.arg(typeName<T>(), tagSet.join(QString()), valueSet.join(QString()), QString::number(list.count()));

}

template<>

QString generateCastDef<qsreal>(const QList<QPair<QString, qsreal> >& list)

{

    static const QString templ = "\n"\

                                 "void tst_QScriptValue::qscriptvalue_cast%1_initData()\n"\

                                 "{\n"\

                                 "    QTest::addColumn<%1>(\"expected\");\n"\

                                 "    initScriptValues();\n"\

                                 "}\n"\

                                 "\n"\

                                 "static QString qscriptvalue_cast%1_tagArray [] = {%2};\n"\

                                 "static %1 qscriptvalue_cast%1_valueArray [] = {%3};\n"\

                                 "void tst_QScriptValue::qscriptvalue_cast%1_makeData(const char* expr)\n"\

                                 "{\n"\

                                 "    static QHash<QString, %1> value;\n"\

                                 "    if (value.isEmpty()) {\n"\

                                 "        value.reserve(%4);\n"\

                                 "        for (unsigned i = 0; i < %4; ++i)\n"\

                                 "            value.insert(qscriptvalue_cast%1_tagArray[i], qscriptvalue_cast%1_valueArray[i]);\n"\

                                 "    }\n"\

                                 "    newRow(expr) << value.value(expr);\n"\

                                 "}\n"\

                                 "\n"\

                                 "void tst_QScriptValue::qscriptvalue_cast%1_test(const char*, const QScriptValue& value)\n"\

                                 "{\n"\

                                 "    QFETCH(%1, expected);\n"\

                                 "    if (qIsNaN(expected)) {\n"

                                 "        QVERIFY(qIsNaN(qscriptvalue_cast<%1>(value)));\n"

                                 "        QVERIFY(qIsNaN(qscriptvalue_cast<%1>(value)));\n"

                                 "        return;\n"

                                 "    }\n"\

                                 "    if (qIsInf(expected)) {\n"

                                 "        QVERIFY(qIsInf(qscriptvalue_cast<%1>(value)));\n"

                                 "        QVERIFY(qIsInf(qscriptvalue_cast<%1>(value)));\n"

                                 "        return;\n"

                                 "    }\n"

                                 "    QCOMPARE(qscriptvalue_cast<%1>(value), expected);\n"\

                                 "    QCOMPARE(qscriptvalue_cast<%1>(value), expected);\n"\

                                 "}\n"\

                                 "\n"\

                                 "DEFINE_TEST_FUNCTION(qscriptvalue_cast%1)\n";

    QString result = templ;

    QList<QPair<QString, qsreal> >::const_iterator i = list.constBegin();

    QStringList tagSet, valueSet;

    tagSet.reserve(list.count());

    valueSet.reserve(list.count());

    int tmp = -1;

    for(; i != list.constEnd(); ++i) {

        QPair<QString, qsreal> t = *i;

        t.first = escape(t.first);

        tagSet.append(QString("\n    \""));

        tagSet.append(t.first);

        tagSet.append(QString::fromAscii("\","));

        if (!((++tmp)%10))

            valueSet.append(QString("\n    "));

        valueSet.append(prepareToInsert<qsreal>(t.second));

        valueSet.append(QString::fromAscii(", "));

    }

    return result.arg(typeName<qsreal>(),

                      tagSet.join(QString()),

                      valueSet.join(QString()),

                      QString::number(list.count()));

}

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"\

                                 "static QString %1_array [] = {%2};\n\n"\

                                 "void tst_QScriptValue::%1_makeData(const char *expr)\n"\

                                 "{\n"\

                                 "    static QSet<QString> equals;\n"\

                                 "    if (equals.isEmpty()) {\n"\

                                 "        equals.reserve(%3);\n"\

                                 "        for (unsigned i = 0; i < %3; ++i)\n"\

                                 "            equals.insert(%1_array[i]);\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;

    set.reserve(tags.count());

    foreach(const QString& tmp, tags) {

        set.append("\n    \"" + escape(tmp) + "\",");

    }

    return result.arg(comparisionType, set.join(""), QString::number(tags.count()));

}

static QString generateInitDef(const QVector<QString>& allDataTags)

{

    static const QString templ = "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) {