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

**

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

#include <QByteArray>

#include <QCoreApplication>

#include <QDebug>

#include <QFile>

#include <QList>

#include <QRegExp>

#include <QTextStream>

#include <QtTest/QtTest>

#include <QtXml>

#include <QVariant>

#if defined(Q_OS_SYMBIAN)

# define SRCDIR ""

#endif

//TESTED_CLASS=

//TESTED_FILES=

QT_FORWARD_DECLARE_CLASS(QDomDocument)

QT_FORWARD_DECLARE_CLASS(QDomNode)

class tst_QDom : public QObject

{

    Q_OBJECT

private slots:

    void initTestCase();

    void namespacedAttributes() const;

    void setContent_data();

    void setContent();

    void toString_01_data();

    void toString_01();

    void toString_02_data();

    void toString_02();

    void hasAttributes_data();

    void hasAttributes();

    void save_data();

    void save();

    void saveWithSerialization() const;

    void saveWithSerialization_data() const;

    void cloneNode_data();

    void cloneNode();

    void ownerDocument_data();

    void ownerDocument();

    void ownerDocumentTask27424_data();

    void ownerDocumentTask27424();

    void parentNode_data();

    void parentNode();

    void documentCreationTask27424_data();

    void documentCreationTask27424();

    void browseElements();

    void ownerElementTask45192_data();

    void ownerElementTask45192();

    void domNodeMapAndList();

    void nullDocument();

    void invalidName_data();

    void invalidName();

    void invalidQualifiedName_data();

    void invalidQualifiedName();

    void invalidCharData_data();

    void invalidCharData();

    void roundTripAttributes() const;

    void normalizeEndOfLine() const;

    void normalizeAttributes() const;

    void serializeWeirdEOL() const;

    void reparentAttribute() const;

    void serializeNamespaces() const;

    void flagInvalidNamespaces() const;

    void flagUndeclaredNamespace() const;

    void indentComments() const;

    void checkLiveness() const;

    void reportDuplicateAttributes() const;

    void appendChildFromToDocument() const;

    void iterateCDATA() const;

    void appendDocumentNode() const;

    void germanUmlautToByteArray() const;

    void germanUmlautToFile() const;

    void setInvalidDataPolicy() const;

    void crashInSetContent() const;

    void doubleNamespaceDeclarations() const;

    void setContentQXmlReaderOverload() const;

    void toStringWithoutNewlines() const;

    void checkIntOverflow() const;

    void setContentWhitespace() const;

    void setContentWhitespace_data() const;

    void taskQTBUG4595_dontAssertWhenDocumentSpecifiesUnknownEncoding() const;

    void cleanupTestCase() const;

private:

    static QDomDocument generateRequest();

    static QDomDocument doc(const QString &title, const QByteArray &ba);

    static int hasAttributesHelper( const QDomNode& node );

    static bool compareDocuments( const QDomDocument &doc1, const QDomDocument &doc2 );

    static bool compareNodes( const QDomNode &node1, const QDomNode &node2, bool deep );

    static QDomNode findDomNode( const QDomDocument &doc, const QList<QVariant> &pathToNode );

    static QString onNullWarning(const char *const functionName);

    static bool isDeepEqual(const QDomNode &n1, const QDomNode &n2);

    static bool isFakeXMLDeclaration(const QDomNode &node);

    QList<QByteArray> m_excludedCodecs;

};

Q_DECLARE_METATYPE(QList<QVariant>)

void tst_QDom::setContent_data()

{

    const QString doc01(

        "<!DOCTYPE a1 [ <!ENTITY blubber 'and'> ]>\n"

        "<a1>\n"

        " <b1>\n"

        "  <c1>foo</c1>\n"

        "  <c2>bar</c2>\n"

        "  <c3>foo &amp; bar</c3>\n"

        "  <c4>foo &blubber; bar</c4>\n"

        " </b1>\n"

        " <b2> </b2>\n"

        " <b3>\n"

        "  <c1/>\n"

        " </b3>\n"

        "</a1>\n"

        );

    QTest::addColumn<QString>("doc");

    QTest::addColumn<QStringList>("featuresTrue");

    QTest::addColumn<QStringList>("featuresFalse");

    QTest::addColumn<QString>("res");

/*    QTest::newRow( "01" ) << doc01

                       << QStringList()

                       << QString("http://trolltech.com/xml/features/report-whitespace-only-CharData").split(' ')

                       << QString("<!DOCTYPE a1>\n"

                                   "<a1>\n"

                                   "    <b1>\n"

                                   "        <c1>foo</c1>\n"

                                   "        <c2>bar</c2>\n"

                                   "        <c3>foo &amp; bar</c3>\n"

                                   "        <c4>foo and bar</c4>\n"

                                   "    </b1>\n"

                                   "    <b2/>\n"

                                   "    <b3>\n"

                                   "        <c1/>\n"

                                   "    </b3>\n"

                                   "</a1>\n");

    QTest::newRow( "02" ) << doc01

                       << QString("http://trolltech.com/xml/features/report-whitespace-only-CharData").split(' ')

                       << QStringList()

                       << QString("<!DOCTYPE a1>\n"

                                   "<a1>\n"

                                   " <b1>\n"

                                   "  <c1>foo</c1>\n"

                                   "  <c2>bar</c2>\n"

                                   "  <c3>foo &amp; bar</c3>\n"

                                   "  <c4>foo and bar</c4>\n"

                                   " </b1>\n"

                                   " <b2> </b2>\n"

                                   " <b3>\n"

                                   "  <c1/>\n"

                                   " </b3>\n"

                                   "</a1>\n");

    QTest::newRow( "03" ) << doc01

                       << QString("http://trolltech.com/xml/features/report-start-end-entity").split(' ')

                       << QString("http://trolltech.com/xml/features/report-whitespace-only-CharData").split(' ')

                       << QString("<!DOCTYPE a1 [\n"

                                   "<!ENTITY blubber \"and\">\n"

                                   "]>\n"

                                   "<a1>\n"

                                   "    <b1>\n"

                                   "        <c1>foo</c1>\n"

                                   "        <c2>bar</c2>\n"

                                   "        <c3>foo &amp; bar</c3>\n"

                                   "        <c4>foo &blubber; bar</c4>\n"

                                   "    </b1>\n"

                                   "    <b2/>\n"

                                   "    <b3>\n"

                                   "        <c1/>\n"

                                   "    </b3>\n"

                                   "</a1>\n");

    QTest::newRow( "04" ) << doc01

                       << QString("http://trolltech.com/xml/features/report-whitespace-only-CharData http://trolltech.com/xml/features/report-start-end-entity").split(' ')

                       << QStringList()

                       << QString("<!DOCTYPE a1 [\n"

                                   "<!ENTITY blubber \"and\">\n"

                                   "]>\n"

                                   "<a1>\n"

                                   " <b1>\n"

                                   "  <c1>foo</c1>\n"

                                   "  <c2>bar</c2>\n"

                                   "  <c3>foo &amp; bar</c3>\n"

                                   "  <c4>foo &blubber; bar</c4>\n"

                                   " </b1>\n"

                                   " <b2> </b2>\n"

                                   " <b3>\n"

                                   "  <c1/>\n"

                                   " </b3>\n"

                                   "</a1>\n");

  */   QTest::newRow("05") << QString("<message>\n"

                                "    <body>&lt;b&gt;foo&lt;/b&gt;>]]&gt;</body>\n"

                                "</message>\n")

                     << QStringList() << QStringList()

                     << QString("<message>\n"

                                "    <body>&lt;b>foo&lt;/b>>]]&gt;</body>\n"

                                "</message>\n");

}

void tst_QDom::setContent()

{

    QFETCH( QString, doc );

    QXmlInputSource source;

    source.setData( doc );

    QFETCH( QStringList, featuresTrue );

    QFETCH( QStringList, featuresFalse );

    QXmlSimpleReader reader;

    QStringList::Iterator it;

    for ( it = featuresTrue.begin(); it != featuresTrue.end(); ++it ) {

        QVERIFY( reader.hasFeature( *it ) );

        reader.setFeature( *it, TRUE );

    }

    for ( it = featuresFalse.begin(); it != featuresFalse.end(); ++it ) {

        QVERIFY( reader.hasFeature( *it ) );

        reader.setFeature( *it, FALSE );

    }

    QDomDocument domDoc;

    QVERIFY( domDoc.setContent( &source, &reader ) );

    QString eRes;

    QTextStream ts( &eRes, QIODevice::WriteOnly );

    domDoc.save( ts, 4 );

    QTEST( eRes, "res" );

    // make sure that if we parse our output again, we get the same document

    QDomDocument domDoc1;

    QDomDocument domDoc2;

    QVERIFY( domDoc1.setContent( doc ) );

    QVERIFY( domDoc2.setContent( eRes ) );

    QVERIFY( compareDocuments( domDoc1, domDoc2 ) );

}

void tst_QDom::toString_01_data()

{

    QTest::addColumn<QString>("fileName");

    QTest::newRow( "01" ) << QString(SRCDIR "testdata/toString_01/doc01.xml");

    QTest::newRow( "02" ) << QString(SRCDIR "testdata/toString_01/doc02.xml");

    QTest::newRow( "03" ) << QString(SRCDIR "testdata/toString_01/doc03.xml");

    QTest::newRow( "04" ) << QString(SRCDIR "testdata/toString_01/doc04.xml");

    QTest::newRow( "05" ) << QString(SRCDIR "testdata/toString_01/doc05.xml");

    QTest::newRow( "euc-jp" ) << QString(SRCDIR "testdata/toString_01/doc_euc-jp.xml");

    QTest::newRow( "iso-2022-jp" ) << QString(SRCDIR "testdata/toString_01/doc_iso-2022-jp.xml");

    QTest::newRow( "little-endian" ) << QString(SRCDIR "testdata/toString_01/doc_little-endian.xml");

    QTest::newRow( "utf-16" ) << QString(SRCDIR "testdata/toString_01/doc_utf-16.xml");

    QTest::newRow( "utf-8" ) << QString(SRCDIR "testdata/toString_01/doc_utf-8.xml");

}

/*! \internal

  This function tests that the QDomDocument::toString() function results in the

  same XML document. The meaning of "same" in this context means that the

  "information" in the resulting XML file is the same as in the original, i.e.

  we are not intrested in different formatting, etc.

  To achieve this, the XML document of the toString() function is parsed again

  and the two QDomDocuments are compared.

*/

void tst_QDom::toString_01()

{

    QFETCH(QString, fileName);

    QFile f(fileName);

    QVERIFY2(f.open(QIODevice::ReadOnly), qPrintable(QString::fromLatin1("Failed to open file %1, file error: %2").arg(fileName).arg(f.error())));

    QDomDocument doc;

    QString errorMsg;

    int errorLine;

    int errorCol;

    QVERIFY(doc.setContent( &f, &errorMsg, &errorLine, &errorCol )); /*,

        QString("QDomDocument::setContent() failed: %1 in line %2, column %3")

                        .arg( errorMsg ).arg( errorLine ).arg( errorCol )); */

    // test toString()'s invariant with different indenting depths

    for ( int i=0; i<5; i++ ) {

        QString toStr = doc.toString( i );

        QDomDocument res;

        QVERIFY( res.setContent( toStr ) );

        QVERIFY( compareDocuments( doc, res ) );

    }

}

void tst_QDom::toString_02_data()

{

    save_data();

}

/*

  Tests the new QDomDocument::toString(int) overload (basically the same test

  as save()).

*/

void tst_QDom::toString_02()

{

    QFETCH( QString, doc );

    QFETCH( int, indent );

    QDomDocument domDoc;

    QVERIFY( domDoc.setContent( doc ) );

    QTEST( domDoc.toString(indent), "res" );

}

void tst_QDom::hasAttributes_data()

{

    QTest::addColumn<int>("visitedNodes");

    QTest::addColumn<QByteArray>("xmlDoc");

    QByteArray doc1("<top>Make a <blubb>stupid</blubb>, useless test sentence.</top>");

    QByteArray doc2("<top a=\"a\">Make a <blubb a=\"a\">stupid</blubb>, useless test sentence.</top>");

    QByteArray doc3("<!-- just a useless comment -->\n"

                    "<?pi foo bar?>\n"

                    "<foo>\n"

                    "<bar fnord=\"snafu\" hmpf=\"grmpf\">\n"

                    "<foobar/>\n"

                    "</bar>\n"

                    "<bar>blubber</bar>\n"

                    "more text, pretty unintresting, though\n"

                    "<hmpfl blubber=\"something\" />\n"

                    "<![CDATA[ foo bar @!<>] ]]>\n"

                    "</foo>\n"

                    "<!-- just a useless comment -->\n"

                    "<?pi foo bar?>\n");

    QTest::newRow( "01" ) << 6 << doc1;

    QTest::newRow( "02" ) << 6 << doc2;

    QTest::newRow( "03" ) << 13 << doc3;

}

/*

  This function tests that QDomNode::hasAttributes() returns TRUE if and only

  if the node has attributes (i.e. QDomNode::attributes() returns a list with

  attributes in it).

*/

void tst_QDom::hasAttributes()

{

    QFETCH( QByteArray, xmlDoc );

    QDomDocument doc;

    QVERIFY( doc.setContent( xmlDoc ) );

    int visitedNodes = hasAttributesHelper( doc );

    QTEST( visitedNodes, "visitedNodes" );

}

int tst_QDom::hasAttributesHelper( const QDomNode& node )

{

    int visitedNodes = 1;

    if ( node.hasAttributes() ) {

            if (node.attributes().count() == 0)

            return -1;

//        QVERIFY( node.attributes().count() > 0 );

    } else {

            if (node.attributes().count() != 0)

            return -1;

//        QVERIFY( node.attributes().count() == 0 );

    }

    QDomNodeList children = node.childNodes();

    for ( int i=0; i<children.count(); i++ ) {

            int j = hasAttributesHelper( children.item(i) );

        if (j < 0)

            return -1;

        visitedNodes += j;

    }

    return visitedNodes;

}

void tst_QDom::save_data()

{

    const QString doc01(

            "<a1>\n"

            " <b1>\n"

            "  <c1>\n"

            "   <d1/>\n"

            "  </c1>\n"

            "  <c2/>\n"

            " </b1>\n"

            " <b2/>\n"

            " <b3>\n"

            "  <c1/>\n"

            " </b3>\n"

            "</a1>\n"

            );

    QTest::addColumn<QString>("doc");

    QTest::addColumn<int>("indent");

    QTest::addColumn<QString>("res");

    QTest::newRow( "01" ) << doc01 << 0 << QString(doc01).replace( QRegExp(" "), "" );

    QTest::newRow( "02" ) << doc01 << 1 << doc01;

    QTest::newRow( "03" ) << doc01 << 2 << QString(doc01).replace( QRegExp(" "), "  " );

    QTest::newRow( "04" ) << doc01 << 10 << QString(doc01).replace( QRegExp(" "), "          " );

}

void tst_QDom::save()

{

    QFETCH( QString, doc );

    QFETCH( int, indent );

    QDomDocument domDoc;

    QVERIFY( domDoc.setContent( doc ) );

    QString eRes;

    QTextStream ts( &eRes, QIODevice::WriteOnly );

    domDoc.save( ts, indent );

    QTEST( eRes, "res" );

}

void tst_QDom::initTestCase()

{

#ifdef Q_CC_MINGW

    QSKIP("Our current test machine, arsia, is too slow for this auto test.", SkipAll);

#endif

    QFile file(SRCDIR "testdata/excludedCodecs.txt");

    QVERIFY(file.open(QIODevice::ReadOnly|QIODevice::Text));

    QByteArray codecName;

    m_excludedCodecs = file.readAll().split('\n');

}

void tst_QDom::saveWithSerialization() const

{

    QFETCH(QString, fileName);

    QFile f(fileName);

    QVERIFY(f.open(QIODevice::ReadOnly));

    QDomDocument doc;

    // Read the document

    QVERIFY(doc.setContent(&f));

    const QList<QByteArray> codecs(QTextCodec::availableCodecs());

    QByteArray codecName;

    foreach(codecName, codecs) {

        /* Avoid codecs that can't handle the files we have. */

        if(m_excludedCodecs.contains(codecName.toLower()))

            continue;

        /* Write out doc in the specified codec. */

        QByteArray storage;

        QBuffer writeDevice(&storage);

        QVERIFY(writeDevice.open(QIODevice::WriteOnly));

        QTextStream s(&writeDevice);

        QTextCodec *codec = QTextCodec::codecForName(codecName);

        QVERIFY2(codec, qPrintable(QString::fromLatin1("Failed to load codec %1, even though it was in QTextCodec::availableCodecs()")

                                   .arg(QString::fromLatin1(codecName.constData()))));

        s.setCodec(codec);

        doc.save(s, 0, QDomNode::EncodingFromTextStream);

        s.flush();

        writeDevice.close();

        QBuffer readDevice(&storage);