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

**

** 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 <QDirIterator>

#include <QEventLoop>

#include <QNetworkAccessManager>

#include <QNetworkReply>

#include <QNetworkRequest>

#include <QtTest/QtTest>

#include <QUrl>

#include <QXmlDefaultHandler>

#include <QXmlStreamReader>

#include "qc14n.h"

//TESTED_CLASS=QXmlStreamReader QXmlStreamWriter

//TESTED_FILES=corelib/xml/stream/qxmlutils.cpp corelib/xml/stream/qxmlstream.cpp corelib/xml/stream/qxmlstream_p.h

Q_DECLARE_METATYPE(QXmlStreamReader::ReadElementTextBehaviour)

static const int expectedRunCount = 1646;

static const int expectedSkipCount = 532;

static inline int best(int a, int b)

{

    if (a < 0)

        return b;

    if (b < 0)

        return a;

    return qMin(a, b);

}

static inline int best(int a, int b, int c)

{

    if (a < 0)

        return best(b, c);

    if (b < 0)

        return best(a, c);

    if (c < 0)

        return best(a, b);

    return qMin(qMin(a, b), c);

}

/**

 *  Opens @p filename and returns content produced as per

 *  xmlconf/xmltest/canonxml.html.

 *

 *  @p docType is the DOCTYPE name that the returned output should

 *  have, if it doesn't already have one.

 */

static QByteArray makeCanonical(const QString &filename,

                                const QString &docType,

                                bool &hasError,

                                bool testIncremental = false)

{

    QFile file(filename);

    file.open(QIODevice::ReadOnly);

    QXmlStreamReader reader;

    QByteArray buffer;

    int bufferPos = 0;

    if (testIncremental)

        buffer = file.readAll();

    else

        reader.setDevice(&file);

    QByteArray outarray;

    QXmlStreamWriter writer(&outarray);

    forever {

        while (!reader.atEnd()) {

            reader.readNext();

            if (reader.isDTD()) {

                if (!reader.notationDeclarations().isEmpty()) {

                    QString dtd;

                    QTextStream writeDtd(&dtd);

                    writeDtd << "<!DOCTYPE ";

                    writeDtd << docType;

                    writeDtd << " [";

                    writeDtd << endl;

                    QMap<QString, QXmlStreamNotationDeclaration> sortedNotationDeclarations;

                    foreach (QXmlStreamNotationDeclaration notation, reader.notationDeclarations())

                        sortedNotationDeclarations.insert(notation.name().toString(), notation);

                    foreach (QXmlStreamNotationDeclaration notation, sortedNotationDeclarations.values()) {

                        writeDtd << "<!NOTATION ";

                        writeDtd << notation.name().toString();

                        if (notation.publicId().isEmpty()) {

                            writeDtd << " SYSTEM \'";

                            writeDtd << notation.systemId().toString();

                            writeDtd << "\'";

                        } else {

                            writeDtd << " PUBLIC \'";

                            writeDtd << notation.publicId().toString();

                            writeDtd << "\'";

                            if (!notation.systemId().isEmpty() ) {

                                writeDtd << " \'";

                                writeDtd << notation.systemId().toString();

                                writeDtd << "\'";

                            }

                        }

                        writeDtd << ">";

                        writeDtd << endl;

                    }

                    writeDtd << "]>";

                    writeDtd << endl;

                    writer.writeDTD(dtd);

                }

            } else if (reader.isStartElement()) {

                writer.writeStartElement(reader.namespaceUri().toString(), reader.name().toString());

                QMap<QString, QXmlStreamAttribute> sortedAttributes;

                foreach(QXmlStreamAttribute attribute, reader.attributes())

                    sortedAttributes.insert(attribute.name().toString(), attribute);

                foreach(QXmlStreamAttribute attribute, sortedAttributes.values())

                    writer.writeAttribute(attribute);

                writer.writeCharacters(QString()); // write empty string to avoid having empty xml tags

            } else if (reader.isCharacters()) {

                // make canonical

                QString text = reader.text().toString();

                int i = 0;

                int p = 0;

                while ((i = best(text.indexOf(QLatin1Char(10), p),

                                 text.indexOf(QLatin1Char(13), p),

                                 text.indexOf(QLatin1Char(9), p))) >= 0) {

                    writer.writeCharacters(text.mid(p, i - p));

                    writer.writeEntityReference(QString("#%1").arg(text.at(i).unicode()));

                    p = i + 1;

                }

                writer.writeCharacters(text.mid(p));

            } else if (reader.isStartDocument() || reader.isEndDocument() || reader.isComment()){

                // canonical does not want any of those

            } else if (reader.isProcessingInstruction() && reader.processingInstructionData().isEmpty()) {

                // for some reason canonical wants a space

                writer.writeProcessingInstruction(reader.processingInstructionTarget().toString(), QLatin1String(""));

            } else if (!reader.hasError()){

                writer.writeCurrentToken(reader);

            }

        }

        if (testIncremental && bufferPos < buffer.size()) {

            reader.addData(QByteArray(buffer.data() + (bufferPos++), 1));

        } else {

            break;

        }

    }

    if (reader.hasError()) {

        hasError = true;

        outarray += "ERROR:";

        outarray += reader.errorString().toLatin1();

    }

    else

        hasError = false;

    return outarray;

}

/**

 * @short Returns the lexical QName of the document element in

 * @p document.

 *

 * It is assumed that @p document is a well-formed XML document.

 */

static QString documentElement(const QByteArray &document)

{

    QXmlStreamReader reader(document);

    while(!reader.atEnd())

    {

        if(reader.isStartElement())

            return reader.qualifiedName().toString();

        reader.readNext();

    }

    Q_ASSERT_X(false, Q_FUNC_INFO,

               qPrintable(QString::fromLatin1("The input %1 didn't contain an element.").arg(QString::fromUtf8(document.constData()))));

    return QString();

}

/**

 * @short Loads W3C's XML conformance test suite and runs it on QXmlStreamReader.

 *

 * Since this suite is fairly large, it runs the tests sequentially in order to not

 * have them all loaded into memory at once. In this way, the maximum memory usage stays

 * low, which means one can run valgrind on this test. However, the drawback is that

 * QTestLib's usual error reporting and testing mechanisms are slightly bypassed.

 *

 * Part of this code is a manual, ad-hoc implementation of xml:base.

 *

 * @see <a href="http://www.w3.org/XML/Test/">Extensible

 * Markup Language (XML) Conformance Test Suites</a>

 */

class TestSuiteHandler : public QXmlDefaultHandler

{

public:

    /**

     * The first string is the test ID, the second is

     * a description of what went wrong.

     */

    typedef QPair<QString, QString> GeneralFailure;

    /**

     * The string is the test ID.

     */

    QStringList successes;

    /**

     * The first value is the baseline, while the se

     */

    class MissedBaseline

    {

    public:

        MissedBaseline(const QString &aId,

                       const QByteArray &aExpected,

                       const QByteArray &aOutput) : id(aId),

                                                    expected(aExpected),

                                                    output(aOutput)

        {

            Q_ASSERT(!aId.isEmpty());

        }

        QString     id;

        QByteArray  expected;

        QByteArray  output;

    };

    QList<GeneralFailure> failures;

    QList<MissedBaseline> missedBaselines;

    /**

     * The count of how many tests that were run.

     */

    int runCount;

    int skipCount;

    /**

     * @p baseURI is the the URI of where the catalog file resides.

     */

    TestSuiteHandler(const QUrl &baseURI) : runCount(0),

                                            skipCount(0)

    {

        Q_ASSERT(baseURI.isValid());

        m_baseURI.push(baseURI);

    }

    virtual bool characters(const QString &chars)

    {

        m_ch = chars;

        return true;

    }

    virtual bool startElement(const QString &,

                              const QString &,

                              const QString &,

                              const QXmlAttributes &atts)

    {

        m_atts.push(atts);

        const int i = atts.index(QLatin1String("xml:base"));

        if(i != -1)

            m_baseURI.push(m_baseURI.top().resolved(atts.value(i)));

        return true;

    }

    virtual bool endElement(const QString &,

                            const QString &localName,

                            const QString &)

    {

        if(localName == QLatin1String("TEST"))

        {

            /* We don't want tests for XML 1.1.0, in fact). */

            if(m_atts.top().value(QString(), QLatin1String("VERSION")) == QLatin1String("1.1"))

            {

                ++skipCount;

                m_atts.pop();

                return true;

            }

            /* We don't want tests that conflict with the namespaces spec. Our parser is a

             * namespace-aware parser. */

            else if(m_atts.top().value(QString(), QLatin1String("NAMESPACE")) == QLatin1String("no"))

            {

                ++skipCount;

                m_atts.pop();

                return true;

            }

            const QString inputFilePath(m_baseURI.top().resolved(m_atts.top().value(QString(), QLatin1String("URI")))

                                                                .toLocalFile());

            const QString id(m_atts.top().value(QString(), QLatin1String("ID")));

            const QString type(m_atts.top().value(QString(), QLatin1String("TYPE")));

            QString expectedFilePath;

            const int index = m_atts.top().index(QString(), QLatin1String("OUTPUT"));

            //qDebug() << "Running test case:" << id;

            if(index != -1)

            {

                expectedFilePath = m_baseURI.top().resolved(m_atts.top().value(QString(),

                                                            QLatin1String("OUTPUT"))).toLocalFile();

            }

            /* testcases.dtd: 'No parser should accept a "not-wf" testcase

             * unless it's a nonvalidating parser and the test contains

             * external entities that the parser doesn't read.'

             *

             * We also let this apply to "valid", "invalid" and "error" tests, although

             * I'm not fully sure this is correct. */

            const QString ents(m_atts.top().value(QString(), QLatin1String("ENTITIES")));

            m_atts.pop();

            if(ents == QLatin1String("both") ||

               ents == QLatin1String("general") ||

               ents == QLatin1String("parameter"))

            {

                ++skipCount;

                return true;

            }

            ++runCount;

            QFile inputFile(inputFilePath);

            if(!inputFile.open(QIODevice::ReadOnly))

            {

                failures.append(qMakePair(id, QString::fromLatin1("Failed to open input file %1").arg(inputFilePath)));

                return true;

            }

            if(type == QLatin1String("not-wf"))

            {

                if(isWellformed(&inputFile, ParseSinglePass))

                {

                     failures.append(qMakePair(id, QString::fromLatin1("Failed to flag %1 as not well-formed.")

                                                   .arg(inputFilePath)));

                     /* Exit, the incremental test will fail as well, no need to flood the output. */

                     return true;

                }

                else

                    successes.append(id);

                if(isWellformed(&inputFile, ParseIncrementally))

                {

                     failures.append(qMakePair(id, QString::fromLatin1("Failed to flag %1 as not well-formed with incremental parsing.")

                                                   .arg(inputFilePath)));

                }

                else

                    successes.append(id);

                return true;

            }

            QXmlStreamReader reader(&inputFile);

            /* See testcases.dtd which reads: 'Nonvalidating parsers

             * must also accept "invalid" testcases, but validating ones must reject them.' */

            if(type == QLatin1String("invalid") || type == QLatin1String("valid"))

            {

                QByteArray expected;

                QString docType;

                /* We only want to compare against a baseline when we have

                 * one. Some "invalid"-tests, for instance, doesn't have baselines. */

                if(!expectedFilePath.isEmpty())

                {

                    QFile expectedFile(expectedFilePath);

                    if(!expectedFile.open(QIODevice::ReadOnly))

                    {

                        failures.append(qMakePair(id, QString::fromLatin1("Failed to open baseline %1").arg(expectedFilePath)));

                        return true;

                    }

                    expected = expectedFile.readAll();

                    docType = documentElement(expected);

                }

                else

                    docType = QLatin1String("dummy");

                bool hasError = true;

                bool incremental = false;

                QByteArray input(makeCanonical(inputFilePath, docType, hasError, incremental));

                if (!hasError && !expectedFilePath.isEmpty() && input == expected)

                    input = makeCanonical(inputFilePath, docType, hasError, (incremental = true));

                if(hasError)

                    failures.append(qMakePair(id, QString::fromLatin1("Failed to parse %1%2")

                                              .arg(incremental?"(incremental run only) ":"")

                                              .arg(inputFilePath)));

                if(!expectedFilePath.isEmpty() && input != expected)

                {

                    missedBaselines.append(MissedBaseline(id, expected, input));

                    return true;

                }

                else

                {

                    successes.append(id);

                    return true;

                }

            }

            else if(type == QLatin1String("error"))

            {

                /* Not yet sure about this one. */

                // TODO

                return true;

            }

            else

            {

                Q_ASSERT_X(false, Q_FUNC_INFO, "The input catalog is invalid.");

                return false;

            }

        }

        else if(localName == QLatin1String("TESTCASES") && m_atts.top().index(QLatin1String("xml:base")) != -1)

            m_baseURI.pop();

        m_atts.pop();

        return true;

    }

    enum ParseMode

    {

        ParseIncrementally,

        ParseSinglePass

    };

    static bool isWellformed(QIODevice *const inputFile, const ParseMode mode)

    {

        Q_ASSERT(inputFile);

        Q_ASSERT_X(inputFile->isOpen(), Q_FUNC_INFO, "The caller is responsible for opening the device.");

        Q_ASSERT(mode == ParseIncrementally || mode == ParseSinglePass);

        if(mode == ParseIncrementally)

        {

            QXmlStreamReader reader;

            QByteArray buffer;

            int bufferPos = 0;

            buffer = inputFile->readAll();

            while(true)

            {

                while(!reader.atEnd())

                    reader.readNext();

                if(bufferPos < buffer.size())

                {

                    ++bufferPos;

                    reader.addData(QByteArray(buffer.data() + bufferPos, 1));

                }

                else

                    break;

            }

            return !reader.hasError();

        }

        else

        {

            QXmlStreamReader reader;

            reader.setDevice(inputFile);

            while(!reader.atEnd())

                reader.readNext();

            return !reader.hasError();

        }

    }

private:

    QStack<QXmlAttributes>  m_atts;

    QString                 m_ch;

    QStack<QUrl>            m_baseURI;

};

class tst_QXmlStream: public QObject

{

    Q_OBJECT