1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QBuffer>

    44 #include <QByteArray>

    45 #include <QCoreApplication>

    46 #include <QDebug>

    47 #include <QFile>

    48 #include <QList>

    49 #include <QRegExp>

    50 #include <QTextStream>

    51 #include <QtTest/QtTest>

    52 #include <QtXml>

    53 #include <QVariant>

    54 

    55 #if defined(Q_OS_SYMBIAN)

    56 # define SRCDIR ""

    57 #endif

    58 

    59 //TESTED_CLASS=

    60 //TESTED_FILES=

    61 

    62 QT_FORWARD_DECLARE_CLASS(QDomDocument)

    63 QT_FORWARD_DECLARE_CLASS(QDomNode)

    64 

    65 class tst_QDom : public QObject

    66 {

    67     Q_OBJECT

    68 

    69 private slots:

    70     void initTestCase();

    71     void namespacedAttributes() const;

    72     void setContent_data();

    73     void setContent();

    74     void toString_01_data();

    75     void toString_01();

    76     void toString_02_data();

    77     void toString_02();

    78     void hasAttributes_data();

    79     void hasAttributes();

    80     void save_data();

    81     void save();

    82     void saveWithSerialization() const;

    83     void saveWithSerialization_data() const;

    84     void cloneNode_data();

    85     void cloneNode();

    86     void ownerDocument_data();

    87     void ownerDocument();

    88     void ownerDocumentTask27424_data();

    89     void ownerDocumentTask27424();

    90     void parentNode_data();

    91     void parentNode();

    92     void documentCreationTask27424_data();

    93     void documentCreationTask27424();

    94     void browseElements();

    95     void ownerElementTask45192_data();

    96     void ownerElementTask45192();

    97     void domNodeMapAndList();

    98 

    99     void nullDocument();

   100     void invalidName_data();

   101     void invalidName();

   102     void invalidQualifiedName_data();

   103     void invalidQualifiedName();

   104     void invalidCharData_data();

   105     void invalidCharData();

   106 

   107     void roundTripAttributes() const;

   108     void normalizeEndOfLine() const;

   109     void normalizeAttributes() const;

   110     void serializeWeirdEOL() const;

   111     void reparentAttribute() const;

   112     void serializeNamespaces() const;

   113     void flagInvalidNamespaces() const;

   114     void flagUndeclaredNamespace() const;

   115 

   116     void indentComments() const;

   117     void checkLiveness() const;

   118     void reportDuplicateAttributes() const;

   119     void appendChildFromToDocument() const;

   120     void iterateCDATA() const;

   121     void appendDocumentNode() const;

   122     void germanUmlautToByteArray() const;

   123     void germanUmlautToFile() const;

   124     void setInvalidDataPolicy() const;

   125     void crashInSetContent() const;

   126     void doubleNamespaceDeclarations() const;

   127     void setContentQXmlReaderOverload() const;

   128     void toStringWithoutNewlines() const;

   129     void checkIntOverflow() const;

   130     void setContentWhitespace() const;

   131     void setContentWhitespace_data() const;

   132 

   133     void taskQTBUG4595_dontAssertWhenDocumentSpecifiesUnknownEncoding() const;

   134 

   135     void cleanupTestCase() const;

   136 

   137 private:

   138     static QDomDocument generateRequest();

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

   140     static int hasAttributesHelper( const QDomNode& node );

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

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

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

   144     static QString onNullWarning(const char *const functionName);

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

   146     static bool isFakeXMLDeclaration(const QDomNode &node);

   147 

   148     QList<QByteArray> m_excludedCodecs;

   149 };

   150 

   151 Q_DECLARE_METATYPE(QList<QVariant>)

   152 

   153 void tst_QDom::setContent_data()

   154 {

   155     const QString doc01(

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

   157         "<a1>\n"

   158         " <b1>\n"

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

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

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

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

   163         " </b1>\n"

   164         " <b2> </b2>\n"

   165         " <b3>\n"

   166         "  <c1/>\n"

   167         " </b3>\n"

   168         "</a1>\n"

   169         );

   170 

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

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

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

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

   175 

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

   177                        << QStringList()

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

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

   180                                    "<a1>\n"

   181                                    "    <b1>\n"

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

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

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

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

   186                                    "    </b1>\n"

   187                                    "    <b2/>\n"

   188                                    "    <b3>\n"

   189                                    "        <c1/>\n"

   190                                    "    </b3>\n"

   191                                    "</a1>\n");

   192 

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

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

   195                        << QStringList()

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

   197                                    "<a1>\n"

   198                                    " <b1>\n"

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

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

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

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

   203                                    " </b1>\n"

   204                                    " <b2> </b2>\n"

   205                                    " <b3>\n"

   206                                    "  <c1/>\n"

   207                                    " </b3>\n"

   208                                    "</a1>\n");

   209 

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

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

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

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

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

   215                                    "]>\n"

   216                                    "<a1>\n"

   217                                    "    <b1>\n"

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

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

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

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

   222                                    "    </b1>\n"

   223                                    "    <b2/>\n"

   224                                    "    <b3>\n"

   225                                    "        <c1/>\n"

   226                                    "    </b3>\n"

   227                                    "</a1>\n");

   228 

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

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

   231                        << QStringList()

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

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

   234                                    "]>\n"

   235                                    "<a1>\n"

   236                                    " <b1>\n"

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

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

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

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

   241                                    " </b1>\n"

   242                                    " <b2> </b2>\n"

   243                                    " <b3>\n"

   244                                    "  <c1/>\n"

   245                                    " </b3>\n"

   246                                    "</a1>\n");

   247 

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

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

   250                                 "</message>\n")

   251                      << QStringList() << QStringList()

   252                      << QString("<message>\n"

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

   254                                 "</message>\n");

   255 

   256 }

   257 

   258 void tst_QDom::setContent()

   259 {

   260     QFETCH( QString, doc );

   261 

   262     QXmlInputSource source;

   263     source.setData( doc );

   264 

   265     QFETCH( QStringList, featuresTrue );

   266     QFETCH( QStringList, featuresFalse );

   267     QXmlSimpleReader reader;

   268     QStringList::Iterator it;

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

   270         QVERIFY( reader.hasFeature( *it ) );

   271         reader.setFeature( *it, TRUE );

   272     }

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

   274         QVERIFY( reader.hasFeature( *it ) );

   275         reader.setFeature( *it, FALSE );

   276     }

   277 

   278     QDomDocument domDoc;

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

   280 

   281     QString eRes;

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

   283     domDoc.save( ts, 4 );

   284 

   285     QTEST( eRes, "res" );

   286 

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

   288     QDomDocument domDoc1;

   289     QDomDocument domDoc2;

   290     QVERIFY( domDoc1.setContent( doc ) );

   291     QVERIFY( domDoc2.setContent( eRes ) );

   292     QVERIFY( compareDocuments( domDoc1, domDoc2 ) );

   293 }

   294 

   295 void tst_QDom::toString_01_data()

   296 {

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

   298 

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

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

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

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

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

   304 

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

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

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

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

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

   310 

   311 }

   312 

   313 /*! \internal

   314 

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

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

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

   318   we are not intrested in different formatting, etc.

   319 

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

   321   and the two QDomDocuments are compared.

   322 */

   323 void tst_QDom::toString_01()

   324 {

   325     QFAIL("make test fail instead of timing out, will be fixed later (QT-2357)");

   326     QFETCH(QString, fileName);

   327 

   328     QFile f(fileName);

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

   330 

   331     QDomDocument doc;

   332     QString errorMsg;

   333     int errorLine;

   334     int errorCol;

   335 

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

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

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

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

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

   341         QString toStr = doc.toString( i );

   342 

   343         QDomDocument res;

   344         QVERIFY( res.setContent( toStr ) );

   345 

   346         QVERIFY( compareDocuments( doc, res ) );

   347     }

   348 }

   349 

   350 void tst_QDom::toString_02_data()

   351 {

   352     save_data();

   353 }

   354 

   355 /*

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

   357   as save()).

   358 */

   359 void tst_QDom::toString_02()

   360 {

   361     QFETCH( QString, doc );

   362     QFETCH( int, indent );

   363 

   364     QDomDocument domDoc;

   365     QVERIFY( domDoc.setContent( doc ) );

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

   367 }

   368 

   369 

   370 void tst_QDom::hasAttributes_data()

   371 {

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

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

   374 

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

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

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

   378                     "<?pi foo bar?>\n"

   379                     "<foo>\n"

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

   381                     "<foobar/>\n"

   382                     "</bar>\n"

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

   384                     "more text, pretty unintresting, though\n"

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

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

   387                     "</foo>\n"

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

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

   390 

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

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

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

   394 }

   395 

   396 /*

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

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

   399   attributes in it).

   400 */

   401 void tst_QDom::hasAttributes()

   402 {

   403     QFETCH( QByteArray, xmlDoc );

   404 

   405     QDomDocument doc;

   406     QVERIFY( doc.setContent( xmlDoc ) );

   407 

   408     int visitedNodes = hasAttributesHelper( doc );

   409     QTEST( visitedNodes, "visitedNodes" );

   410 }

   411 

   412 int tst_QDom::hasAttributesHelper( const QDomNode& node )

   413 {

   414     int visitedNodes = 1;

   415     if ( node.hasAttributes() ) {

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

   417             return -1;

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

   419     } else {

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

   421             return -1;

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

   423     }

   424 

   425     QDomNodeList children = node.childNodes();

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

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

   428         if (j < 0)

   429             return -1;

   430         visitedNodes += j;

   431     }

   432     return visitedNodes;

   433 }

   434 

   435 

   436 void tst_QDom::save_data()

   437 {

   438     const QString doc01(

   439             "<a1>\n"

   440             " <b1>\n"

   441             "  <c1>\n"

   442             "   <d1/>\n"

   443             "  </c1>\n"

   444             "  <c2/>\n"

   445             " </b1>\n"

   446             " <b2/>\n"

   447             " <b3>\n"

   448             "  <c1/>\n"

   449             " </b3>\n"

   450             "</a1>\n"

   451             );

   452 

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

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

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

   456 

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

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

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

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

   461 }

   462 

   463 void tst_QDom::save()

   464 {

   465     QFETCH( QString, doc );

   466     QFETCH( int, indent );

   467 

   468     QDomDocument domDoc;

   469     QVERIFY( domDoc.setContent( doc ) );

   470 

   471     QString eRes;

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

   473     domDoc.save( ts, indent );

   474 

   475     QTEST( eRes, "res" );

   476 }

   477 

   478 void tst_QDom::initTestCase()

   479 {

   480 #ifdef Q_CC_MINGW

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

   482 #endif

   483 

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

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

   486 

   487     QByteArray codecName;

   488 

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

   490 

   491 }

   492 

   493 void tst_QDom::saveWithSerialization() const

   494 {

   495     QFETCH(QString, fileName);

   496 

   497     QFile f(fileName);

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

   499 

   500     QDomDocument doc;

   501 

   502     // Read the document

   503     QVERIFY(doc.setContent(&f));

   504 

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

   506     QByteArray codecName;

   507 

   508     foreach(codecName, codecs) {

   509 

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

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

   512             continue;

   513 

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

   515         QByteArray storage;

   516         QBuffer writeDevice(&storage);

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

   518 

   519         QTextStream s(&writeDevice);

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

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

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

   523         s.setCodec(codec);

   524 

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

   526         s.flush();

   527         writeDevice.close();

   528 

   529         QBuffer readDevice(&storage);

   530         QVERIFY(readDevice.open(QIODevice::ReadOnly));

   531 

   532         QDomDocument result;

   533 

   534         QString msg;

   535         int line = 0;

   536         int column = 0;

   537 

   538         QVERIFY2(result.setContent(&readDevice, &msg, &line, &column),

   539                  qPrintable(QString::fromLatin1("Failed for codec %1: line %2, column %3: %4, content: %5")

   540                                                 .arg(QString::fromLatin1(codecName.constData()),

   541                                                      QString::number(line),

   542                                                      QString::number(column),

   543                                                      msg,

   544                                                      codec->toUnicode(storage))));

   545         if(!compareDocuments(doc, result))

   546         {

   547             QCOMPARE(doc.toString(), result.toString());

   548 

   549             /* We put this one here as well, in case the QCOMPARE above for some strange reason

   550              * nevertheless succeeds. */

   551             QVERIFY2(false, qPrintable(QString::fromLatin1("Failed for codec %1").arg(QString::fromLatin1(codecName.constData()))));

   552         }

   553     }

   554 }

   555 

   556 void tst_QDom::saveWithSerialization_data() const

   557 {

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

   559 

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

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

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

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

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

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

   566 

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

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

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

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

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

   572 }

   573 

   574 void tst_QDom::cloneNode_data()

   575 {

   576     const QString doc01(

   577             "<a1>\n"

   578             " <b1>\n"

   579             "  <c1>\n"

   580             "   <d1/>\n"

   581             "  </c1>\n"

   582             "  <c2/>\n"

   583             " </b1>\n"

   584             " <b2/>\n"

   585             " <b3>\n"

   586             "  <c1/>\n"

   587             " </b3>\n"

   588             "</a1>\n"

   589             );

   590     QList<QVariant> nodeB1;

   591     nodeB1 << 0;

   592 

   593     QList<QVariant> nodeC1;

   594     nodeC1 << 0 << 0;

   595 

   596     QList<QVariant> nodeC2;

   597     nodeC2 << 0 << 1;

   598 

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

   600     QTest::addColumn<QList<QVariant> >("pathToNode");

   601     QTest::addColumn<bool>("deep");

   602 

   603     QTest::newRow( "noDeep_01" ) << doc01 << nodeB1 << (bool)FALSE;

   604     QTest::newRow( "noDeep_02" ) << doc01 << nodeC1 << (bool)FALSE;

   605     QTest::newRow( "noDeep_03" ) << doc01 << nodeC2 << (bool)FALSE;

   606 

   607     QTest::newRow( "deep_01" ) << doc01 << nodeB1 << (bool)TRUE;

   608     QTest::newRow( "deep_02" ) << doc01 << nodeC1 << (bool)TRUE;

   609     QTest::newRow( "deep_03" ) << doc01 << nodeC2 << (bool)TRUE;

   610 }

   611 

   612 void tst_QDom::cloneNode()

   613 {

   614     QFETCH( QString, doc );

   615     QFETCH( QList<QVariant>, pathToNode );

   616     QFETCH( bool, deep );

   617     QDomDocument domDoc;

   618     QVERIFY( domDoc.setContent( doc ) );

   619     QDomNode node = findDomNode( domDoc, pathToNode );

   620     QVERIFY(!node.isNull());

   621 

   622     QDomNode clonedNode = node.cloneNode( deep );

   623     QVERIFY( compareNodes( node, clonedNode, deep ) );

   624 

   625     QDomNode parent = node.parentNode();

   626     if ( !parent.isNull() ) {

   627         node = parent.replaceChild( clonedNode, node ); // swap the nodes

   628         QVERIFY( !node.isNull() );

   629         QVERIFY( compareNodes( node, clonedNode, deep ) );

   630     }

   631 }

   632 

   633 

   634 void tst_QDom::ownerElementTask45192_data()

   635 {

   636     const QString doc(

   637         "<root>\n"

   638         " <item name=\"test\" >\n"

   639         " </item>\n"

   640         "</root>"

   641     );

   642 

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

   644     QTest::newRow("doc") << doc;

   645 }

   646 

   647 void tst_QDom::ownerElementTask45192()

   648 {

   649     QFETCH( QString, doc );

   650     QDomDocument domDoc;

   651     QVERIFY( domDoc.setContent( doc ) );

   652 

   653     QDomNode item = domDoc.documentElement().firstChild();

   654     QDomNode clone = item.cloneNode(false);

   655 

   656     QVERIFY( clone == clone.attributes().namedItem("name").toAttr().ownerElement() );

   657 }

   658 

   659 void tst_QDom::ownerDocument_data()

   660 {

   661     cloneNode_data();

   662 }

   663 

   664 #define OWNERDOCUMENT_CREATE_TEST( t, x ) \

   665 { \

   666     t n = x; \

   667     QVERIFY( n.ownerDocument() == domDoc ); \

   668 }

   669 

   670 #define OWNERDOCUMENT_IMPORTNODE_TEST( t, x ) \

   671 { \

   672     QDomNode importedNode; \

   673     t n = x; \

   674     QVERIFY( n.ownerDocument() != domDoc ); \

   675     importedNode = domDoc.importNode( n, deep ); \

   676     QVERIFY( n.ownerDocument() != domDoc ); \

   677     QVERIFY( importedNode.ownerDocument() == domDoc ); \

   678 }

   679 

   680 void tst_QDom::ownerDocument()

   681 {

   682     QFETCH( QString, doc );

   683     QFETCH( QList<QVariant>, pathToNode );

   684     QFETCH( bool, deep );

   685     QDomDocument domDoc;

   686     QVERIFY( domDoc.setContent( doc ) );

   687     QDomNode node = findDomNode( domDoc, pathToNode );

   688     QVERIFY(!node.isNull());

   689 

   690     QVERIFY( node.ownerDocument() == domDoc );

   691 

   692     // Does cloneNode() keep the ownerDocument()?

   693     {

   694         QDomNode clonedNode = node.cloneNode( deep );

   695         QVERIFY( node.ownerDocument() == domDoc );

   696         QVERIFY( clonedNode.ownerDocument() == domDoc );

   697     }

   698 

   699     // If the original DOM node is replaced with the cloned node, does this

   700     // keep the ownerDocument()?

   701     {

   702         QDomNode clonedNode = node.cloneNode( deep );

   703         QDomNode parent = node.parentNode();

   704         if ( !parent.isNull() ) {

   705             node = parent.replaceChild( clonedNode, node ); // swap the nodes

   706             QVERIFY( node.ownerDocument() == domDoc );

   707             QVERIFY( clonedNode.ownerDocument() == domDoc );

   708         }

   709     }

   710 

   711     // test QDomDocument::create...()

   712     {

   713         OWNERDOCUMENT_CREATE_TEST( QDomAttr,                    domDoc.createAttribute( "foo" ) );

   714         OWNERDOCUMENT_CREATE_TEST( QDomAttr,                    domDoc.createAttributeNS( "foo", "bar" ) );

   715         OWNERDOCUMENT_CREATE_TEST( QDomCDATASection,            domDoc.createCDATASection( "foo" ) );

   716         OWNERDOCUMENT_CREATE_TEST( QDomComment,                 domDoc.createComment( "foo" ) );

   717         OWNERDOCUMENT_CREATE_TEST( QDomDocumentFragment,        domDoc.createDocumentFragment() );

   718         OWNERDOCUMENT_CREATE_TEST( QDomElement,                 domDoc.createElement( "foo" ) );

   719         OWNERDOCUMENT_CREATE_TEST( QDomElement,                 domDoc.createElementNS( "foo", "bar" ) );

   720         OWNERDOCUMENT_CREATE_TEST( QDomEntityReference,         domDoc.createEntityReference( "foo" ) );

   721         OWNERDOCUMENT_CREATE_TEST( QDomProcessingInstruction,   domDoc.createProcessingInstruction( "foo", "bar" ) );

   722         OWNERDOCUMENT_CREATE_TEST( QDomText,                    domDoc.createTextNode( "foo" ) );

   723     }

   724 

   725     // test importNode()

   726     {

   727         QDomDocument doc2;

   728         OWNERDOCUMENT_IMPORTNODE_TEST( QDomAttr,                    doc2.createAttribute( "foo" ) );

   729         OWNERDOCUMENT_IMPORTNODE_TEST( QDomAttr,                    doc2.createAttributeNS( "foo", "bar" ) );

   730         OWNERDOCUMENT_IMPORTNODE_TEST( QDomCDATASection,            doc2.createCDATASection( "foo" ) );

   731         OWNERDOCUMENT_IMPORTNODE_TEST( QDomComment,                 doc2.createComment( "foo" ) );

   732         OWNERDOCUMENT_IMPORTNODE_TEST( QDomDocumentFragment,        doc2.createDocumentFragment() );

   733         OWNERDOCUMENT_IMPORTNODE_TEST( QDomElement,                 doc2.createElement( "foo" ) );

   734         OWNERDOCUMENT_IMPORTNODE_TEST( QDomElement,                 doc2.createElementNS( "foo", "bar" ) );

   735         OWNERDOCUMENT_IMPORTNODE_TEST( QDomEntityReference,         doc2.createEntityReference( "foo" ) );

   736         OWNERDOCUMENT_IMPORTNODE_TEST( QDomProcessingInstruction,   doc2.createProcessingInstruction( "foo", "bar" ) );

   737         OWNERDOCUMENT_IMPORTNODE_TEST( QDomText,                    doc2.createTextNode( "foo" ) );

   738     }

   739 }

   740 

   741 void tst_QDom::ownerDocumentTask27424_data()

   742 {

   743     QTest::addColumn<bool>("insertLevel1AfterCstr");

   744     QTest::addColumn<bool>("insertLevel2AfterCstr");

   745     QTest::addColumn<bool>("insertLevel3AfterCstr");

   746 

   747     QTest::newRow( "000" ) << (bool)FALSE << (bool)FALSE << (bool)FALSE;

   748     QTest::newRow( "001" ) << (bool)FALSE << (bool)FALSE << (bool)TRUE;

   749     QTest::newRow( "010" ) << (bool)FALSE << (bool)TRUE  << (bool)FALSE;

   750     QTest::newRow( "011" ) << (bool)FALSE << (bool)TRUE  << (bool)TRUE;

   751     QTest::newRow( "100" ) << (bool)TRUE  << (bool)FALSE << (bool)FALSE;

   752     QTest::newRow( "101" ) << (bool)TRUE  << (bool)FALSE << (bool)TRUE;

   753     QTest::newRow( "110" ) << (bool)TRUE  << (bool)TRUE  << (bool)FALSE;

   754     QTest::newRow( "111" ) << (bool)TRUE  << (bool)TRUE  << (bool)TRUE;

   755 }

   756 

   757 void tst_QDom::ownerDocumentTask27424()

   758 {

   759     QFETCH( bool, insertLevel1AfterCstr );

   760     QFETCH( bool, insertLevel2AfterCstr );

   761     QFETCH( bool, insertLevel3AfterCstr );

   762 

   763     QDomDocument doc("TestXML");

   764 

   765     QDomElement level1 = doc.createElement("Level_1");

   766     QVERIFY( level1.ownerDocument() == doc );

   767 

   768     if ( insertLevel1AfterCstr ) {

   769         doc.appendChild(level1);

   770         QVERIFY( level1.ownerDocument() == doc );

   771     }

   772 

   773     QDomElement level2 = level1.ownerDocument().createElement("Level_2");

   774     QVERIFY( level1.ownerDocument() == doc );

   775     QVERIFY( level2.ownerDocument() == doc );

   776 

   777     if ( insertLevel2AfterCstr ) {

   778         level1.appendChild(level2);

   779         QVERIFY( level1.ownerDocument() == doc );

   780         QVERIFY( level2.ownerDocument() == doc );

   781     }

   782 

   783     QDomElement level3 = level2.ownerDocument().createElement("Level_3");

   784     QVERIFY( level1.ownerDocument() == doc );

   785     QVERIFY( level2.ownerDocument() == doc );

   786     QVERIFY( level3.ownerDocument() == doc );

   787 

   788     if ( insertLevel3AfterCstr ) {

   789         level2.appendChild(level3);

   790         QVERIFY( level1.ownerDocument() == doc );

   791         QVERIFY( level2.ownerDocument() == doc );

   792         QVERIFY( level3.ownerDocument() == doc );

   793     }

   794 

   795     QDomNode level4 = level3.ownerDocument().createTextNode("This_is_a_value!");

   796     QVERIFY( level4.ownerDocument() == doc );

   797 

   798     level3.appendChild(level4);

   799     QVERIFY( level1.ownerDocument() == doc );

   800     QVERIFY( level2.ownerDocument() == doc );

   801     QVERIFY( level3.ownerDocument() == doc );

   802     QVERIFY( level4.ownerDocument() == doc );

   803 

   804     if ( !insertLevel3AfterCstr ) {

   805         level2.appendChild(level3);

   806         QVERIFY( level1.ownerDocument() == doc );

   807         QVERIFY( level2.ownerDocument() == doc );

   808         QVERIFY( level3.ownerDocument() == doc );

   809         QVERIFY( level4.ownerDocument() == doc );

   810     }

   811 

   812     if ( !insertLevel2AfterCstr ) {

   813         level1.appendChild(level2);

   814         QVERIFY( level1.ownerDocument() == doc );

   815         QVERIFY( level2.ownerDocument() == doc );

   816         QVERIFY( level3.ownerDocument() == doc );

   817         QVERIFY( level4.ownerDocument() == doc );

   818     }

   819 

   820     if ( !insertLevel1AfterCstr ) {

   821         doc.appendChild(level1);

   822         QVERIFY( level1.ownerDocument() == doc );

   823         QVERIFY( level2.ownerDocument() == doc );

   824         QVERIFY( level3.ownerDocument() == doc );

   825         QVERIFY( level4.ownerDocument() == doc );

   826     }

   827 }

   828 

   829 void tst_QDom::parentNode_data()

   830 {

   831     cloneNode_data();

   832 }

   833 

   834 #define PARENTNODE_CREATE_TEST( t, x ) \

   835 { \

   836     t n = x; \

   837     QVERIFY( n.parentNode().isNull() ); \

   838 }

   839 

   840 void tst_QDom::parentNode()

   841 {

   842     QFETCH( QString, doc );

   843     QFETCH( QList<QVariant>, pathToNode );

   844     QFETCH( bool, deep );

   845     QDomDocument domDoc;

   846     QVERIFY( domDoc.setContent( doc ) );

   847     QDomNode node = findDomNode( domDoc, pathToNode );

   848     QVERIFY(!node.isNull());

   849     Q_UNUSED(deep);

   850 

   851     // test QDomDocument::create...()

   852     {

   853         PARENTNODE_CREATE_TEST( QDomAttr,                   domDoc.createAttribute( "foo" ) );

   854         PARENTNODE_CREATE_TEST( QDomAttr,                   domDoc.createAttributeNS( "foo", "bar" ) );

   855         PARENTNODE_CREATE_TEST( QDomCDATASection,           domDoc.createCDATASection( "foo" ) );

   856         PARENTNODE_CREATE_TEST( QDomComment,                domDoc.createComment( "foo" ) );

   857         PARENTNODE_CREATE_TEST( QDomDocumentFragment,       domDoc.createDocumentFragment() );

   858         PARENTNODE_CREATE_TEST( QDomElement,                domDoc.createElement( "foo" ) );

   859         PARENTNODE_CREATE_TEST( QDomElement,                domDoc.createElementNS( "foo", "bar" ) );

   860         PARENTNODE_CREATE_TEST( QDomEntityReference,        domDoc.createEntityReference( "foo" ) );

   861         PARENTNODE_CREATE_TEST( QDomProcessingInstruction,  domDoc.createProcessingInstruction( "foo", "bar" ) );

   862         PARENTNODE_CREATE_TEST( QDomText,                   domDoc.createTextNode( "foo" ) );

   863     }

   864 }

   865 

   866 

   867 void tst_QDom::documentCreationTask27424_data()

   868 {

   869     QTest::addColumn<bool>("insertLevel1AfterCstr");

   870     QTest::addColumn<bool>("insertLevel2AfterCstr");

   871     QTest::addColumn<bool>("insertLevel3AfterCstr");

   872 

   873     QTest::newRow( "000" ) << (bool)FALSE << (bool)FALSE << (bool)FALSE;

   874     QTest::newRow( "001" ) << (bool)FALSE << (bool)FALSE << (bool)TRUE;

   875     QTest::newRow( "010" ) << (bool)FALSE << (bool)TRUE  << (bool)FALSE;

   876     QTest::newRow( "011" ) << (bool)FALSE << (bool)TRUE  << (bool)TRUE;

   877     QTest::newRow( "100" ) << (bool)TRUE  << (bool)FALSE << (bool)FALSE;

   878     QTest::newRow( "101" ) << (bool)TRUE  << (bool)FALSE << (bool)TRUE;

   879     QTest::newRow( "110" ) << (bool)TRUE  << (bool)TRUE  << (bool)FALSE;

   880     QTest::newRow( "111" ) << (bool)TRUE  << (bool)TRUE  << (bool)TRUE;

   881 }

   882 

   883 void tst_QDom::documentCreationTask27424()

   884 {

   885     QFETCH( bool, insertLevel1AfterCstr );

   886     QFETCH( bool, insertLevel2AfterCstr );

   887     QFETCH( bool, insertLevel3AfterCstr );

   888 

   889     QDomDocument docRes;

   890     QVERIFY( docRes.setContent( QString(

   891                 "<!DOCTYPE TestXML>\n"

   892                 "<Level_1>\n"

   893                 " <Level_2>\n"

   894                 "  <Level_3>This_is_a_value!</Level_3>\n"

   895                 " </Level_2>\n"

   896                 "</Level_1>"

   897                 ) ) );

   898 

   899     QDomDocument doc("TestXML");

   900 

   901     QDomElement level1 = doc.createElement("Level_1");

   902     if ( insertLevel1AfterCstr )

   903         doc.appendChild(level1);

   904 

   905     QDomElement level2 = level1.ownerDocument().createElement("Level_2");

   906     if ( insertLevel2AfterCstr )

   907         level1.appendChild(level2);

   908 

   909     QDomElement level3 = level2.ownerDocument().createElement("Level_3");

   910     if ( insertLevel3AfterCstr )

   911         level2.appendChild(level3);

   912 

   913     QDomNode level4 = level3.ownerDocument().createTextNode("This_is_a_value!");

   914     level3.appendChild(level4);

   915 

   916     if ( !insertLevel3AfterCstr )

   917         level2.appendChild(level3);

   918     if ( !insertLevel2AfterCstr )

   919         level1.appendChild(level2);

   920     if ( !insertLevel1AfterCstr )

   921         doc.appendChild(level1);

   922 

   923     QVERIFY( compareDocuments( doc, docRes ) );

   924 }

   925 

   926 

   927 bool tst_QDom::isFakeXMLDeclaration(const QDomNode &node)

   928 {

   929     return node.isProcessingInstruction() &&

   930            node.nodeName() == QLatin1String("xml");

   931 }

   932 

   933 bool tst_QDom::isDeepEqual(const QDomNode &n1, const QDomNode &n2)

   934 {

   935     const QDomNode::NodeType nt = n1.nodeType();

   936 

   937     if(nt != n2.nodeType())

   938         return false;

   939 

   940     if(n1.nodeName() != n2.nodeName()

   941        || n1.namespaceURI() != n2.namespaceURI()

   942        || n1.nodeValue() != n2.nodeValue())

   943         return false;

   944 

   945     /* Check the children. */

   946     const QDomNodeList children1(n1.childNodes());

   947     const QDomNodeList children2(n2.childNodes());

   948     uint len1 = children1.length();

   949     uint len2 = children2.length();

   950     uint i1 = 0;

   951     uint i2 = 0;

   952 

   953     if(len1 != 0 && isFakeXMLDeclaration(children1.at(0)))

   954             ++i1;

   955 

   956     if(len2 != 0 && isFakeXMLDeclaration(children2.at(0)))

   957             ++i2;

   958 

   959     if(len1 - i1 != len2 - i2)

   960         return false;

   961 

   962     // We jump over the first to skip the processing instructions that

   963     // are (incorrectly) used as XML declarations.

   964     for(; i1 < len1; ++i1)

   965     {

   966         if(!isDeepEqual(children1.at(i1), children2.at(i2)))

   967             return false;

   968 

   969         ++i2;

   970     }

   971 

   972     return true;

   973 }

   974 

   975 /*

   976     Returns TRUE if \a doc1 and \a doc2 represent the same XML document, i.e.

   977     they have the same informational content. Otherwise, this function returns

   978     FALSE.

   979 */

   980 bool tst_QDom::compareDocuments( const QDomDocument &doc1, const QDomDocument &doc2 )

   981 {

   982     return isDeepEqual(doc1, doc2);

   983 }

   984 

   985 /*

   986     Returns TRUE if \a node1 and \a node2 represent the same XML node, i.e.

   987     they have the same informational content. Otherwise, this function returns

   988     FALSE.

   989 

   990     If \a deep is TRUE, children of the nodes are also tested. If \a deep is

   991     FALSE, only \a node1 and \a node 2 are compared.

   992 */

   993 bool tst_QDom::compareNodes( const QDomNode &node1, const QDomNode &node2, bool deep )

   994 {

   995     if ( deep ) {

   996         QString str1;

   997         {

   998             QTextStream stream( &str1 );

   999             stream << node1;

  1000         }

  1001         QString str2;

  1002         {

  1003             QTextStream stream( &str2 );

  1004             stream << node2;

  1005         }

  1006         return str1 == str2;

  1007     }

  1008 

  1009     if ( node1.isNull() && node2.isNull() )

  1010         return TRUE;

  1011     // ### I am not sure if this test is complete

  1012     bool equal =     node1.nodeName() == node2.nodeName();

  1013     equal = equal && node1.nodeType() == node2.nodeType();

  1014     equal = equal && node1.localName() == node2.localName();

  1015     equal = equal && node1.nodeValue() == node2.nodeValue();

  1016     equal = equal && node1.prefix() == node2.prefix();

  1017 

  1018     return equal;

  1019 }

  1020 

  1021 /*

  1022     \a pathToNode is a list of indices to wanted node in \a doc. Returns the

  1023     wanted node.

  1024 */

  1025 QDomNode tst_QDom::findDomNode( const QDomDocument &doc, const QList<QVariant> &pathToNode )

  1026 {

  1027     QDomNode node = doc;

  1028     QList<QVariant>::const_iterator it;

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

  1030         QDomNodeList children = node.childNodes();

  1031         node = children.item( (*it).toInt() );

  1032 //        QVERIFY( !node.isNull() );

  1033     }

  1034     return node;

  1035 }

  1036 

  1037 void tst_QDom::browseElements()

  1038 {

  1039     QDomDocument doc;

  1040     QDomElement root = doc.createElement("foo");

  1041     doc.appendChild(root);

  1042     root.appendChild(doc.createElement("bar"));

  1043     root.appendChild(doc.createElement("bop"));

  1044     root.appendChild(doc.createElement("bar"));

  1045     root.appendChild(doc.createElement("bop"));

  1046 

  1047     QVERIFY(doc.firstChildElement("ding").isNull());

  1048     QDomElement foo = doc.firstChildElement("foo");

  1049     QVERIFY(!foo.isNull());

  1050     QVERIFY(foo.firstChildElement("ding").isNull());

  1051     QVERIFY(foo.nextSiblingElement("foo").isNull());

  1052     QVERIFY(foo.previousSiblingElement("bar").isNull());

  1053     QVERIFY(foo.nextSiblingElement().isNull());

  1054     QVERIFY(foo.previousSiblingElement().isNull());

  1055 

  1056     QDomElement bar = foo.firstChildElement("bar");

  1057     QVERIFY(!bar.isNull());

  1058     QVERIFY(bar.previousSiblingElement("bar").isNull());

  1059     QVERIFY(bar.previousSiblingElement().isNull());

  1060     QVERIFY(bar.nextSiblingElement("bar").tagName() == "bar");

  1061     QVERIFY(bar.nextSiblingElement("bar").nextSiblingElement("bar").isNull());

  1062 

  1063     QDomElement bop = foo.firstChildElement("bop");

  1064     QVERIFY(!bop.isNull());

  1065     QVERIFY(bar.nextSiblingElement() == bop);

  1066     QVERIFY(bop.nextSiblingElement("bop") == foo.lastChildElement("bop"));

  1067     QVERIFY(bop.previousSiblingElement("bar") == foo.firstChildElement("bar"));

  1068     QVERIFY(bop.previousSiblingElement("bar") == foo.firstChildElement());

  1069 }

  1070 

  1071 void tst_QDom::domNodeMapAndList()

  1072 {

  1073     QString xml_str = QString::fromLatin1("<foo ding='dong'></foo>");

  1074 

  1075     QDomDocument doc;

  1076     QVERIFY(doc.setContent(xml_str));

  1077 

  1078     QDomNamedNodeMap map = doc.documentElement().attributes();

  1079     QCOMPARE(map.item(0).nodeName(), QString("ding"));

  1080     QCOMPARE(map.item(1).nodeName(), QString()); // Make sure we don't assert

  1081 

  1082     QDomNodeList list = doc.elementsByTagName("foo");

  1083     QCOMPARE(list.item(0).nodeName(), QString("foo"));

  1084     QCOMPARE(list.item(1).nodeName(), QString()); // Make sure we don't assert

  1085 }

  1086 

  1087 // Verifies that a default-constructed QDomDocument is null, and that calling

  1088 // any of the factory functions causes it to be non-null.

  1089 #define TEST_NULL_DOCUMENT(func) \

  1090 { \

  1091     QDomDocument doc; \

  1092     QVERIFY(doc.isNull()); \

  1093     QVERIFY(!doc.func.isNull()); \

  1094     QVERIFY(!doc.isNull()); \

  1095 }

  1096 

  1097 void tst_QDom::nullDocument()

  1098 {

  1099     TEST_NULL_DOCUMENT(createAttribute("foo"))

  1100     TEST_NULL_DOCUMENT(createAttributeNS("http://foo/", "bar"))

  1101     TEST_NULL_DOCUMENT(createCDATASection("foo"))

  1102     TEST_NULL_DOCUMENT(createComment("foo"))

  1103     TEST_NULL_DOCUMENT(createDocumentFragment())

  1104     TEST_NULL_DOCUMENT(createElement("foo"))

  1105     TEST_NULL_DOCUMENT(createElementNS("http://foo/", "foo"))

  1106     TEST_NULL_DOCUMENT(createEntityReference("foo"))

  1107     TEST_NULL_DOCUMENT(createProcessingInstruction("foo", "bar"))

  1108     TEST_NULL_DOCUMENT(createTextNode("foo"))

  1109     QDomDocument doc2;

  1110     QDomElement elt = doc2.createElement("foo");

  1111     doc2.appendChild(elt);

  1112     TEST_NULL_DOCUMENT(importNode(elt, true))

  1113 }

  1114 

  1115 #undef TEST_NULL_DOCUMENT

  1116 

  1117 void tst_QDom::invalidName_data()

  1118 {

  1119     QTest::addColumn<QString>("in_name");

  1120     QTest::addColumn<bool>("ok_AcceptInvalidChars");

  1121     QTest::addColumn<bool>("ok_DropInvalidChars");

  1122     QTest::addColumn<bool>("ok_ReturnNullNode");

  1123     QTest::addColumn<QString>("out_name");

  1124 

  1125     QTest::newRow( "foo" )     << QString("foo")     << true  << true  << true  << QString("foo");

  1126     QTest::newRow( "_f.o-o:" ) << QString("_f.o-o:") << true  << true  << true  << QString("_f.o-o:");

  1127     QTest::newRow( "...:." )   << QString("...:.")   << true  << true  << false << QString(":.");

  1128     QTest::newRow( "empty" )   << QString()          << false << false << false << QString();

  1129     QTest::newRow( "~f~o~o~" ) << QString("~f~o~o~") << true  << true  << false << QString("foo");

  1130     QTest::newRow( "~" )       << QString("~")       << true  << false << false << QString();

  1131     QTest::newRow( "..." )     << QString("...")     << true  << false << false << QString();

  1132 }

  1133 

  1134 void tst_QDom::invalidName()