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

     2 **

     3 ** Copyright (C) 2010 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 <QtTest/QtTest>

    44 

    45 

    46 #include <qtextdocument.h>

    47 #include <qtextdocumentfragment.h>

    48 #include <qtexttable.h>

    49 #include <qtextlist.h>

    50 #include <qdebug.h>

    51 #include <private/qtextdocument_p.h>

    52 

    53 

    54 #include <qtextcursor.h>

    55 

    56 QT_FORWARD_DECLARE_CLASS(QTextDocument)

    57 

    58 //TESTED_CLASS=

    59 //TESTED_FILES=gui/text/qtextdocumentfragment.h gui/text/qtextdocumentfragment.cpp gui/text/qtexthtmlparser.cpp gui/text/qtexthtmlparser_p.h

    60 

    61 class tst_QTextDocumentFragment : public QObject

    62 {

    63     Q_OBJECT

    64 

    65 public:

    66     tst_QTextDocumentFragment();

    67     ~tst_QTextDocumentFragment();

    68 

    69 public slots:

    70     void init();

    71     void cleanup();

    72 private slots:

    73     void listCopying();

    74     void listZeroCopying();

    75     void listCopying2();

    76     void tableCopying();

    77     void tableCopyingWithColSpans();

    78     void tableColSpanAndWidth();

    79     void tableImport();

    80     void tableImport2();

    81     void tableImport3();

    82     void tableImport4();

    83     void tableImport5();

    84     void textCopy();

    85     void copyWholeDocument();

    86     void title();

    87     void html_listIndents1();

    88     void html_listIndents2();

    89     void html_listIndents3();

    90     void html_listIndents4();

    91     void html_listIndents5();

    92     void html_listIndents6();

    93     void blockCharFormat();

    94     void blockCharFormatCopied();

    95     void initialBlock();

    96     void clone();

    97     void dontRemoveInitialBlockIfItHoldsObjectIndexedCharFormat();

    98     void dosLineFeed();

    99     void unorderedListEnumeration();

   100     void resetHasBlockAfterClosedBlockTags();

   101     void ignoreStyleTags();

   102     void hrefAnchor();

   103     void namedAnchorFragments();

   104     void namedAnchorFragments2();

   105     void namedAnchorFragments3();

   106     void dontInheritAlignmentInTables();

   107     void cellBlockCount();

   108     void cellBlockCount2();

   109     void emptyTable();

   110     void emptyTable2();

   111     void emptyTable3();

   112     void doubleRowClose();

   113     void mayNotHaveChildren();

   114     void inheritAlignment();

   115     void dontEmitEmptyNodeWhenEmptyTagIsFollowedByCloseTag();

   116     void toPlainText();

   117     void copyTableRow();

   118     void copyTableColumn();

   119     void copySubTable();

   120     void html_textDecoration();

   121     void html_infiniteLoop();

   122     void html_blockIndent();

   123     void html_listIndent();

   124     void html_whitespace();

   125     void html_whitespace_data();

   126     void html_qt3Whitespace();

   127     void html_qt3WhitespaceWithFragments();

   128     void html_qt3WhitespaceAfterTags();

   129     void html_listStart1();

   130     void html_listStart2();

   131     void html_cssMargin();

   132     void html_hexEntities();

   133     void html_decEntities();

   134     void html_thCentered();

   135     void orderedListNumbering();

   136     void html_blockAfterList();

   137     void html_subAndSuperScript();

   138     void html_cssColors();

   139     void obeyFragmentMarkersInImport();

   140     void whitespaceWithFragmentMarkers();

   141     void html_emptyParapgraphs1();

   142     void html_emptyParapgraphs2();

   143     void html_emptyParagraphs3();

   144     void html_emptyParagraphs4();

   145     void html_font();

   146     void html_fontSize();

   147     void html_fontSizeAdjustment();

   148     void html_cssFontSize();

   149     void html_cssShorthandFont();

   150     void html_bodyBgColor();

   151     void html_qtBgColor();

   152     void html_blockLevelDiv();

   153     void html_spanNesting();

   154     void html_nestedLists();

   155     void noSpecialCharactersInPlainText();

   156     void html_doNotInheritBackground();

   157     void html_inheritBackgroundToInlineElements();

   158     void html_doNotInheritBackgroundFromBlockElements();

   159     void html_nobr();

   160     void fromPlainText();

   161     void fromPlainText2();

   162     void html_closingImageTag();

   163     void html_emptyDocument();

   164     void html_closingTag();

   165     void html_anchorAroundImage();

   166     void html_floatBorder();

   167     void html_frameImport();

   168     void html_frameImport2();

   169     void html_dontAddMarginsAcrossTableCells();

   170     void html_dontMergeCenterBlocks();

   171     void html_tableCellBgColor();

   172     void html_tableCellBgColor2();

   173     void html_cellSkip();

   174     void nonZeroMarginOnImport();

   175     void html_charFormatPropertiesUnset();

   176     void html_headings();

   177     void html_quotedFontFamily();

   178     void html_spanBackgroundColor();

   179     void defaultFont();

   180     void html_brokenTitle_data();

   181     void html_brokenTitle();

   182     void html_blockVsInline();

   183     void html_tbody();

   184     void html_nestedTables();

   185     void html_rowSpans();

   186     void html_rowSpans2();

   187     void html_implicitParagraphs();

   188     void html_missingCloseTag();

   189     void html_anchorColor();

   190     void html_lastParagraphClosing();

   191     void html_tableHeaderBodyFootParent();

   192     void html_columnWidths();

   193     void html_bodyBackground();

   194     void html_tableCellBackground();

   195     void css_bodyBackground();

   196     void css_tableCellBackground();

   197     void css_fontWeight();

   198     void css_float();

   199     void css_textIndent();

   200     void css_inline();

   201     void css_external();

   202     void css_import();

   203     void css_selectors_data();

   204     void css_selectors();

   205     void css_nodeNameCaseInsensitivity();

   206     void css_textUnderlineStyle_data();

   207     void css_textUnderlineStyle();

   208     void css_textUnderlineStyleAndDecoration();

   209     void css_listStyleType();

   210     void css_linkPseudo();

   211     void css_pageBreaks();

   212     void css_cellPaddings();

   213     void universalSelectors_data();

   214     void universalSelectors();

   215     void screenMedia();

   216     void htmlResourceLoading();

   217     void someCaseInsensitiveAttributeValues();

   218     void backgroundImage();

   219     void dontMergePreAndNonPre();

   220     void leftMarginInsideHtml();

   221     void html_margins();

   222     void newlineInsidePreShouldBecomeNewParagraph();

   223     void invalidColspan();

   224     void html_brokenTableWithJustTr();

   225     void html_brokenTableWithJustTd();

   226     void html_preNewlineHandling_data();

   227     void html_preNewlineHandling();

   228     void html_br();

   229     void html_dl();

   230     void html_tableStrangeNewline();

   231     void html_tableStrangeNewline2();

   232     void html_tableStrangeNewline3();

   233     void html_caption();

   234     void html_windowsEntities();

   235     void html_eatenText();

   236     void html_hr();

   237     void html_hrMargins();

   238     void html_blockQuoteMargins();

   239     void html_definitionListMargins();

   240     void html_listMargins();

   241     void html_titleAttribute();

   242     void html_compressDivs();

   243     void completeToPlainText();

   244     void copyContents();

   245     void html_textAfterHr();

   246     void blockTagClosing();

   247     void isEmpty();

   248     void html_alignmentInheritance();

   249     void html_ignoreEmptyDivs();

   250     void html_dontInheritAlignmentForFloatingImages();

   251     void html_verticalImageAlignment();

   252     void html_verticalCellAlignment();

   253     void html_borderColor();

   254     void html_borderStyle();

   255     void html_borderWidth();

   256     void html_userState();

   257     void html_rootFrameProperties();

   258     void html_alignmentPropertySet();

   259     void html_appendList();

   260     void html_appendList2();

   261     void html_qt3RichtextWhitespaceMode();

   262     void html_brAfterHr();

   263     void html_unclosedHead();

   264     void html_entities();

   265     void html_entities_data();

   266     void html_ignore_script();

   267     void html_directionWithHtml();

   268     void html_directionWithRichText();

   269     void html_metaInBody();

   270     void html_importImageWithoutAspectRatio();

   271     void html_fromFirefox();

   272 

   273 private:

   274     inline void setHtml(const QString &html)

   275     // don't take the shortcut in QTextDocument::setHtml

   276     { doc->clear(); QTextCursor(doc).insertFragment(QTextDocumentFragment::fromHtml(html)); }

   277 

   278     inline void appendHtml(const QString &html)

   279     {

   280         QTextCursor cursor(doc);

   281         cursor.movePosition(QTextCursor::End);

   282         cursor.insertHtml(html);

   283     }

   284 

   285     QTextDocument *doc;

   286     QTextCursor cursor;

   287 };

   288 

   289 tst_QTextDocumentFragment::tst_QTextDocumentFragment()

   290 {

   291     QImage img(16, 16, QImage::Format_ARGB32_Premultiplied);

   292     img.save("foo.png");

   293 }

   294 

   295 tst_QTextDocumentFragment::~tst_QTextDocumentFragment()

   296 {

   297     QFile::remove(QLatin1String("foo.png"));

   298 }

   299 

   300 void tst_QTextDocumentFragment::init()

   301 {

   302     doc = new QTextDocument;

   303     cursor = QTextCursor(doc);

   304 }

   305 

   306 void tst_QTextDocumentFragment::cleanup()

   307 {

   308     cursor = QTextCursor();

   309     delete doc;

   310     doc = 0;

   311 }

   312 

   313 #include <private/qtextdocument_p.h>

   314 #include <qdebug.h>

   315 static void dumpTable(const QTextDocumentPrivate *pt)

   316 {

   317     qDebug() << "---dump----";

   318     qDebug() << "all text:" << pt->buffer();

   319     for (QTextDocumentPrivate::FragmentIterator it = pt->begin();

   320          !it.atEnd(); ++it) {

   321         qDebug() << "Fragment at text position" << it.position() << "; stringPosition" << it.value()->stringPosition << "; size" << it.value()->size_array[0] << "format :" << it.value()->format << "frag: " << it.n;

   322         qDebug() << "    text:" << pt->buffer().mid(it.value()->stringPosition, it.value()->size_array[0]);

   323     }

   324     qDebug() << "----begin block dump----";

   325     for (QTextBlock it = pt->blocksBegin(); it.isValid(); it = it.next())

   326         qDebug() << "block at" << it.position() << "with length" << it.length() << "block alignment" << it.blockFormat().alignment();

   327     qDebug() << "---dump----";

   328 }

   329 static void dumpTable(QTextDocument *doc) { dumpTable(doc->docHandle()); }

   330 

   331 void tst_QTextDocumentFragment::listCopying()

   332 {

   333     cursor.insertList(QTextListFormat::ListDecimal);

   334 

   335     QTextFormat originalBlockFormat = cursor.blockFormat();

   336     QVERIFY(originalBlockFormat.objectIndex() != -1);

   337     int originalListItemIdx = cursor.blockFormat().objectIndex();

   338 

   339     cursor.insertText("Hello World");

   340 

   341     QTextDocumentFragment fragment(doc);

   342 

   343     cursor.insertFragment(fragment);

   344 

   345     QVERIFY(cursor.currentList());

   346     QVERIFY(cursor.blockFormat() != originalBlockFormat);

   347     QVERIFY(cursor.blockFormat().objectIndex() != originalListItemIdx);

   348 }

   349 

   350 void tst_QTextDocumentFragment::listZeroCopying()

   351 {

   352     // same testcase as above but using the zero-copying

   353 

   354     cursor.insertList(QTextListFormat::ListDecimal);

   355 

   356     QTextFormat originalBlockFormat = cursor.blockFormat();

   357     int originalListItemIdx = cursor.blockFormat().objectIndex();

   358 

   359     cursor.insertText("Hello World");

   360 

   361     QTextDocumentFragment fragment(doc);

   362     cursor.insertFragment(fragment);

   363 

   364     QVERIFY(cursor.currentList());

   365     QVERIFY(cursor.blockFormat() != originalBlockFormat);

   366     QVERIFY(cursor.blockFormat().objectIndex() != originalListItemIdx);

   367 }

   368 

   369 void tst_QTextDocumentFragment::listCopying2()

   370 {

   371     cursor.insertList(QTextListFormat::ListDecimal);

   372     cursor.insertText("Hello World");

   373 

   374     cursor.insertList(QTextListFormat::ListDisc);

   375     cursor.insertText("Hello World");

   376 

   377     QTextDocumentFragment fragment(doc);

   378 

   379     cursor.insertFragment(fragment);

   380 

   381     cursor.movePosition(QTextCursor::Start);

   382     int listItemCount = 0;

   383     do {

   384 	if (cursor.currentList())

   385 	    listItemCount++;

   386     } while (cursor.movePosition(QTextCursor::NextBlock));

   387 

   388     QCOMPARE(listItemCount, 4);

   389 

   390     // we call this here because it used to cause a failing assertion in the

   391     // list manager.

   392     doc->undo();

   393 }

   394 

   395 void tst_QTextDocumentFragment::tableCopying()

   396 {

   397     // this tests both, the fragment to use the direction insertion instead of using the

   398     // cursor, which might adjuts its position when inserting a table step by step, as well

   399     // as the pasiveness of the tablemanager.

   400     QTextDocumentFragment fragment;

   401     {

   402 	QTextDocument doc;

   403 	QTextCursor cursor(&doc);

   404 

   405 	QTextTableFormat fmt;

   406 	QTextTable *table = cursor.insertTable(2, 2, fmt);

   407 

   408 	table->cellAt(0, 0).firstCursorPosition().insertText("First Cell");

   409 	table->cellAt(0, 1).firstCursorPosition().insertText("Second Cell");

   410 	table->cellAt(1, 0).firstCursorPosition().insertText("Third Cell");

   411 	table->cellAt(1, 1).firstCursorPosition().insertText("Fourth Cell");

   412 

   413 	fragment = QTextDocumentFragment(&doc);

   414     }

   415     {

   416 	QTextDocument doc;

   417 	QTextCursor cursor(&doc);

   418 

   419 	cursor.insertText("FooBar");

   420 	cursor.insertBlock();

   421 	cursor.movePosition(QTextCursor::Left);

   422 

   423 	cursor.insertFragment(fragment);

   424 	cursor.movePosition(QTextCursor::Start);

   425 	cursor.movePosition(QTextCursor::NextBlock);

   426 

   427 	QTextTable *table = cursor.currentTable();

   428 	QVERIFY(table);

   429 	QCOMPARE(table->rows(), 2);

   430 	QCOMPARE(table->columns(), 2);

   431     }

   432 }

   433 

   434 void tst_QTextDocumentFragment::tableCopyingWithColSpans()

   435 {

   436     const char html[] = ""

   437 "<table border>"

   438 "  <tr>"

   439 "    <td>First Cell"

   440 "    <td>Second Cell"

   441 "  </tr>"

   442 "  <tr>"

   443 "    <td colspan=\"2\">Third Cell"

   444 "  </tr>"

   445 "  <tr>"

   446 "    <td>Fourth Cell"

   447 "    <td>Fifth Cell"

   448 "  </tr>"

   449 "</table>";

   450     setHtml(html);

   451 

   452     cursor.movePosition(QTextCursor::Start);

   453     cursor.movePosition(QTextCursor::NextBlock);

   454     QTextTable *table = cursor.currentTable();

   455     QVERIFY(table);

   456     QVERIFY(table->columns() == 2 && table->rows() == 3);

   457 

   458     cursor = table->cellAt(2, 0).lastCursorPosition();

   459     cursor.setPosition(table->cellAt(0, 0).firstPosition(), QTextCursor::KeepAnchor);

   460     QVERIFY(cursor.hasComplexSelection());

   461 

   462     int firstRow = 0, numRows = 0, firstCol = 0, numCols = 0;

   463     cursor.selectedTableCells(&firstRow, &numRows, &firstCol, &numCols);

   464     QCOMPARE(firstRow, 0);

   465     QCOMPARE(numRows, 3);

   466     QCOMPARE(firstCol, 0);

   467     QCOMPARE(numCols, 1);

   468 

   469     QTextDocumentFragment frag = cursor.selection();

   470     cleanup();

   471     init();

   472     cursor.insertFragment(frag);

   473 

   474     cursor.movePosition(QTextCursor::Start);

   475     cursor.movePosition(QTextCursor::NextBlock);

   476     table = cursor.currentTable();

   477     QVERIFY(table);

   478     QVERIFY(table->columns() == 1 && table->rows() == 3);

   479 }

   480 

   481 void tst_QTextDocumentFragment::tableColSpanAndWidth()

   482 {

   483     const char html[] = ""

   484 "<table border=\"0\">"

   485 "  <tr>"

   486 "    <td colspan=\"4\" width=\"400\">First Cell</td>"

   487 "  </tr>"

   488 "</table>";

   489     setHtml(html);

   490 

   491     cursor.movePosition(QTextCursor::Start);

   492     cursor.movePosition(QTextCursor::NextBlock);

   493     QTextTable *table = cursor.currentTable();

   494     QVERIFY(table);

   495     QVERIFY(table->columns() == 4 && table->rows() == 1);

   496     // make sure its approx 400 and not a multiple due to the colspan

   497     QVERIFY(doc->size().width()> 398.);

   498     QVERIFY(doc->size().width() < 420.);

   499 }

   500 

   501 void tst_QTextDocumentFragment::tableImport()

   502 {

   503     // used to cause a failing assertion, as HTMLImporter::closeTag was

   504     // called twice with the last node.

   505     QTextDocumentFragment fragment = QTextDocumentFragment::fromHtml(QString::fromLatin1("<table><tr><td>Hey</td><td>Blah"));

   506     QVERIFY(!fragment.isEmpty());

   507 }

   508 

   509 void tst_QTextDocumentFragment::tableImport2()

   510 {

   511     {

   512 	const char html[] = ""

   513 	    "<table>"

   514 	    "<tr><td>First Cell</td><td>Second Cell</td></tr>"

   515 	    "<tr><td>Third Cell</td><td>Fourth Cell</td></tr>"

   516 	    "</table>";

   517 

   518 	QTextDocument doc;

   519 	QTextCursor cursor(&doc);

   520 	cursor.insertFragment(QTextDocumentFragment::fromHtml(QByteArray::fromRawData(html, sizeof(html) / sizeof(html[0]))));

   521 

   522 	cursor.movePosition(QTextCursor::Start);

   523 	cursor.movePosition(QTextCursor::NextBlock);

   524 	QTextTable *table = cursor.currentTable();

   525 	QVERIFY(table);

   526 	QCOMPARE(table->columns(), 2);

   527 	QCOMPARE(table->rows(), 2);

   528     }

   529     {

   530 	const char html[] = ""

   531 	    "<table>"

   532 	    "<tr><td>First Cell</td><td>Second Cell</td></tr>"

   533 	    "<tr><td>Third Cell</td><td>"

   534 	    "                           <table>"

   535 	    "                           <tr><td>First Nested Cell</td><td>Second Nested Cell</td></tr>"

   536 	    "                           <tr><td>Third Nested Cell</td><td>Fourth Nested Cell</td></tr>"

   537 	    "                           <tr><td>Fifth Nested Cell</td><td>Sixth Nested Cell</td></tr>"

   538 	    "                           </table></td></tr>"

   539 	    "</table>";

   540 

   541 	QTextDocument doc;

   542 	QTextCursor cursor(&doc);

   543 	cursor.insertFragment(QTextDocumentFragment::fromHtml(QByteArray::fromRawData(html, sizeof(html) / sizeof(html[0]))));

   544 

   545 	cursor.movePosition(QTextCursor::Start);

   546 	cursor.movePosition(QTextCursor::NextBlock);

   547 	QTextTable *table = cursor.currentTable();

   548 	QVERIFY(table);

   549 	QCOMPARE(table->columns(), 2);

   550 	QCOMPARE(table->rows(), 2);

   551 

   552         /*

   553 	QTextCursor fourthCell = table->cellAt(1, 1).firstCursorPosition();

   554 	fourthCell.movePosition(QTextCursor::NextBlock);

   555 	table = fourthCell.currentTable();

   556 	QVERIFY(table);

   557 	QVERIFY(table != cursor.currentTable());

   558 	QCOMPARE(table->columns(), 2);

   559 	QCOMPARE(table->rows(), 3);

   560         */

   561     }

   562     {

   563 	const char buggyHtml[] = ""

   564 	    "<table>"

   565 	    "<tr><td>First Cell<td>Second Cell"

   566 	    "<tr><td>Third Cell<td>Fourth Cell"

   567 	    "</table>";

   568 

   569 	QTextDocument doc;

   570 	QTextCursor cursor(&doc);

   571 	cursor.insertFragment(QTextDocumentFragment::fromHtml(QByteArray::fromRawData(buggyHtml, sizeof(buggyHtml) / sizeof(buggyHtml[0]))));

   572 

   573 	cursor.movePosition(QTextCursor::Start);

   574 	cursor.movePosition(QTextCursor::NextBlock);

   575 	QTextTable *table = cursor.currentTable();

   576 	QVERIFY(table);

   577 	QCOMPARE(table->columns(), 2);

   578 	QCOMPARE(table->rows(), 2);

   579     }

   580     {

   581 	const char buggyHtml[] = ""

   582 	    "<table>"

   583 	    "<tr><th>First Cell<th>Second Cell"

   584 	    "<tr><td>Third Cell<td>Fourth Cell"

   585 	    "</table>";

   586 

   587 	QTextDocument doc;

   588 	QTextCursor cursor(&doc);

   589 	cursor.insertFragment(QTextDocumentFragment::fromHtml(QByteArray::fromRawData(buggyHtml, sizeof(buggyHtml) / sizeof(buggyHtml[0]))));

   590 

   591 	cursor.movePosition(QTextCursor::Start);

   592 	cursor.movePosition(QTextCursor::NextBlock);

   593 	QTextTable *table = cursor.currentTable();

   594 	QVERIFY(table);

   595 	QCOMPARE(table->columns(), 2);

   596 	QCOMPARE(table->rows(), 2);

   597     }

   598 

   599 }

   600 

   601 void tst_QTextDocumentFragment::tableImport3()

   602 {

   603     // ### would be better to have tree tests for QTextHtmlParser

   604     // make sure the p is a child of the td. If not the following td

   605     // ends up outside the table, causing an assertion

   606     const char html[] = "<table><tr><td><p></p></td><td></td></tr></table>";

   607     QTextDocumentFragment fragment = QTextDocumentFragment::fromHtml(QString::fromLatin1(html));

   608     QVERIFY(!fragment.isEmpty());

   609 }

   610 

   611 void tst_QTextDocumentFragment::tableImport4()

   612 {

   613     const char html[] = "<table>"

   614         "<tr><td>blah</td></tr>"

   615         "<tr><td>blah</td><td>blah</td></tr>"

   616         "</table>";

   617     cursor.insertFragment(QTextDocumentFragment::fromHtml(QString::fromLatin1(html)));

   618     cursor.movePosition(QTextCursor::Start);

   619     cursor.movePosition(QTextCursor::NextBlock);

   620     QVERIFY(cursor.currentTable());

   621     QCOMPARE(cursor.currentTable()->columns(), 2);

   622 }

   623 

   624 void tst_QTextDocumentFragment::tableImport5()

   625 {

   626     const char html[] = "<table>"

   627         "<tr>"

   628         " <td>Foo</td>"

   629         " <td>Bar</td>"

   630         " <td>Bleh</td>"

   631         "  <td>Blub</td>"

   632         "</tr>"

   633         "<tr>"

   634         "  <td>Ahh</td>"

   635         "  <td colspan=5>Gah</td>"

   636         "</tr>"

   637         "</table>";

   638 

   639     cursor.insertFragment(QTextDocumentFragment::fromHtml(QString::fromLatin1(html)));

   640     cursor.movePosition(QTextCursor::Start);

   641     cursor.movePosition(QTextCursor::NextBlock);

   642     QVERIFY(cursor.currentTable());

   643     QCOMPARE(cursor.currentTable()->rows(), 2);

   644     QCOMPARE(cursor.currentTable()->columns(), 6);

   645 }

   646 

   647 void tst_QTextDocumentFragment::textCopy()

   648 {

   649     /* this test used to cause failing assertions in QTextDocumentFragment */

   650     /* copy&paste 'lo\bwor' */

   651     cursor.insertText("Hello");

   652     cursor.insertBlock();

   653     cursor.insertText("World");

   654 

   655     cursor.movePosition(QTextCursor::Start);

   656     cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::MoveAnchor, 3);

   657     cursor.movePosition(QTextCursor::NextBlock, QTextCursor::KeepAnchor);

   658     cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor, 3);

   659 

   660     QTextDocumentFragment fragment(cursor);

   661     QVERIFY(!fragment.isEmpty());

   662     cursor.insertFragment(fragment);

   663 }

   664 

   665 void tst_QTextDocumentFragment::copyWholeDocument()

   666 {

   667     // used to cause the famous currentBlock.position() == pos + 1 failing assertion

   668     cursor.insertText("\nHey\nBlah\n");

   669     cursor.movePosition(QTextCursor::Start);

   670     cursor.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);

   671 

   672     QTextFrameFormat fmt = doc->rootFrame()->frameFormat();

   673     fmt.setBackground(Qt::blue);

   674     doc->rootFrame()->setFrameFormat(fmt);

   675 

   676     QTextDocumentFragment fragment(cursor);

   677     QVERIFY(true); // good if we reach this point :)

   678 

   679     cleanup();

   680     init();

   681 

   682     fmt.setBackground(Qt::red);

   683     doc->rootFrame()->setFrameFormat(fmt);

   684 

   685     cursor.insertFragment(fragment);

   686 

   687     QVERIFY(doc->rootFrame()->frameFormat().background().color() == Qt::red);

   688 }

   689 

   690 void tst_QTextDocumentFragment::title()

   691 {

   692     doc->setHtml(QString::fromLatin1("<html><head><title>Test</title></head><body>Blah</body></html>"));

   693     QCOMPARE(doc->metaInformation(QTextDocument::DocumentTitle), QString::fromLatin1("Test"));

   694 }

   695 

   696 void tst_QTextDocumentFragment::html_listIndents1()

   697 {

   698     const char html[] = "<ul><li>Hey</li><li>Hah</li></ul>";

   699     setHtml(QString::fromLatin1(html));

   700     cursor.movePosition(QTextCursor::Start);

   701     cursor.movePosition(QTextCursor::NextBlock);

   702     QTextList *list = cursor.currentList();

   703     QVERIFY(list);

   704     QCOMPARE(list->format().indent(), 1);

   705     QCOMPARE(cursor.block().blockFormat().indent(), 0);

   706 }

   707 

   708 void tst_QTextDocumentFragment::html_listIndents2()

   709 {

   710     const char html[] = "<ul><li>Hey<p>Hah</ul>";

   711     setHtml(QString::fromLatin1(html));

   712     cursor.movePosition(QTextCursor::Start);

   713     QTextList *list = cursor.currentList();

   714     QVERIFY(list);

   715     QCOMPARE(list->format().indent(), 1);

   716     QCOMPARE(cursor.block().blockFormat().indent(), 0);

   717 

   718     cursor.movePosition(QTextCursor::NextBlock);

   719     QCOMPARE(cursor.block().blockFormat().indent(), 1);

   720 }

   721 

   722 void tst_QTextDocumentFragment::html_listIndents3()

   723 {

   724     const char html[] = "<ul><li><p>Hah</ul>";

   725     setHtml(QString::fromLatin1(html));

   726     cursor.movePosition(QTextCursor::Start);

   727     QTextList *list = cursor.currentList();

   728     QVERIFY(list);

   729     QCOMPARE(list->format().indent(), 1);

   730     QCOMPARE(cursor.block().blockFormat().indent(), 0);

   731 }

   732 

   733 void tst_QTextDocumentFragment::html_listIndents4()

   734 {

   735     const char html[] = "<ul><li>Foo</ul><p>This should not have the same indent as Foo";

   736     setHtml(QString::fromLatin1(html));

   737     cursor.movePosition(QTextCursor::Start);

   738     QTextList *list = cursor.currentList();

   739     QVERIFY(list);

   740     QCOMPARE(list->format().indent(), 1);

   741 

   742     cursor.movePosition(QTextCursor::NextBlock);

   743     QVERIFY(!cursor.currentList());

   744     QCOMPARE(cursor.blockFormat().indent(), 0);

   745 }

   746 

   747 void tst_QTextDocumentFragment::html_listIndents5()

   748 {

   749     const char html[] = "<ul><li>Foo<p><li>Bar</li></ul>";

   750     setHtml(QString::fromLatin1(html));

   751     cursor.movePosition(QTextCursor::Start);

   752     QTextList *list = cursor.currentList();

   753     QVERIFY(list);

   754     QCOMPARE(list->format().indent(), 1);

   755 

   756     cursor.movePosition(QTextCursor::NextBlock);

   757     QVERIFY(cursor.currentList() == list);

   758     QCOMPARE(cursor.blockFormat().indent(), 0);

   759 }

   760 

   761 void tst_QTextDocumentFragment::html_listIndents6()

   762 {

   763     const char html[] = "<ul><li>Outer List<div class=\"testclass\"><ul><li>Nested Item 1</li></ul></div></li></ul>";

   764     setHtml(QString::fromLatin1(html));

   765     cursor.movePosition(QTextCursor::Start);

   766     QTextList *list = cursor.currentList();

   767     QVERIFY(list);

   768     QCOMPARE(list->format().indent(), 1);

   769 

   770     cursor.movePosition(QTextCursor::NextBlock);

   771     QVERIFY(cursor.currentList() != list);

   772     list = cursor.currentList();

   773     QVERIFY(list);

   774     QCOMPARE(list->format().indent(), 2);

   775 

   776     QCOMPARE(cursor.blockFormat().indent(), 0);

   777 }

   778 

   779 void tst_QTextDocumentFragment::blockCharFormat()

   780 {

   781     const char html[] = "<p style=\"font-style:italic\"><span style=\"font-style:normal\">Test</span></p>";

   782     setHtml(QString::fromLatin1(html));

   783     QVERIFY(doc->begin().charFormat().fontItalic());

   784 }

   785 

   786 void tst_QTextDocumentFragment::blockCharFormatCopied()

   787 {

   788     QTextCharFormat fmt;

   789     fmt.setForeground(Qt::green);

   790     cursor.setBlockCharFormat(fmt);

   791     cursor.insertText("Test", QTextCharFormat());

   792     QTextDocumentFragment frag(doc);

   793     cleanup();

   794     init();

   795     cursor.insertFragment(frag);

   796     QVERIFY(cursor.blockCharFormat() == fmt);

   797 }

   798 

   799 void tst_QTextDocumentFragment::initialBlock()

   800 {

   801     const char html[] = "<p>Test</p>";

   802     setHtml(QString::fromLatin1(html));

   803     QCOMPARE(doc->blockCount(), 1);

   804 }

   805 

   806 void tst_QTextDocumentFragment::clone()

   807 {

   808     QTextBlockFormat mod;

   809     mod.setAlignment(Qt::AlignCenter);

   810     cursor.mergeBlockFormat(mod);

   811     cursor.insertText("Blah");

   812     QVERIFY(cursor.blockFormat().alignment() == Qt::AlignCenter);

   813     QTextDocumentFragment frag(doc);

   814     cleanup();

   815     init();

   816     cursor.insertFragment(frag);

   817     cursor.movePosition(QTextCursor::Start);

   818     QVERIFY(cursor.blockFormat().alignment() == Qt::AlignCenter);

   819 }

   820 

   821 void tst_QTextDocumentFragment::dontRemoveInitialBlockIfItHoldsObjectIndexedCharFormat()

   822 {

   823     const char html[] = "<table><tr><td>cell one<td>cell two</tr><tr><td>cell three<td>cell four</tr></table>";

   824     QVERIFY(doc->begin().charFormat().objectIndex() == -1);

   825     setHtml(QString::fromLatin1(html));

   826     int cnt = 0;

   827 

   828     int objectIndexOfLast = -1;

   829     for (QTextBlock blk = doc->begin(); blk.isValid(); blk = blk.next()) {

   830         ++cnt;

   831         objectIndexOfLast = blk.charFormat().objectIndex();

   832     }

   833     //   beginning of frame for first cell

   834     // + beginning of frame for second cell

   835     // + beginning of frame for third cell

   836     // + beginning of frame for fourth cell

   837     // + end of frame

   838     // + initial block

   839     // ==> 6

   840     QCOMPARE(cnt, 6);

   841     QVERIFY(objectIndexOfLast != -1);

   842     QVERIFY(doc->begin().next().charFormat().objectIndex() != -1);

   843 }

   844 

   845 void tst_QTextDocumentFragment::dosLineFeed()

   846 {

   847     const char html[] = "<pre>Test\r\n</pre>Bar";

   848     setHtml(QString::fromLatin1(html));

   849     QVERIFY(!doc->toPlainText().contains('\r'));

   850     QCOMPARE(doc->toPlainText(), QString("Test\nBar"));

   851 }

   852 

   853 void tst_QTextDocumentFragment::unorderedListEnumeration()

   854 {

   855     const char html[] = "<ul><ul><ul><li>Blah</li></ul></ul>";

   856     setHtml(QString::fromLatin1(html));

   857     cursor.movePosition(QTextCursor::End);

   858     QVERIFY(cursor.currentList());

   859     QVERIFY(cursor.currentList()->format().style() == QTextListFormat::ListCircle);

   860 

   861     const char html2[] = "<ul><ul><ul type=disc><li>Blah</li></ul></ul>";

   862     setHtml(QString::fromLatin1(html2));

   863     cursor.movePosition(QTextCursor::End);

   864     QVERIFY(cursor.currentList());

   865     QVERIFY(cursor.currentList()->format().style() == QTextListFormat::ListDisc);

   866 

   867 }

   868 

   869 void tst_QTextDocumentFragment::resetHasBlockAfterClosedBlockTags()

   870 {

   871     // when closing tags we have to make sure hasBlock in import() gets resetted

   872     const char html[] = "<body><table><tr><td><td><p></table><p></body>";

   873     setHtml(QString::fromLatin1(html));

   874     QVERIFY(!doc->isEmpty());

   875 }

   876 

   877 void tst_QTextDocumentFragment::ignoreStyleTags()

   878 {

   879     const char html[] = "<body><style>Blah</style>Hello</body>";

   880     setHtml(QString::fromLatin1(html));

   881     QCOMPARE(doc->toPlainText(), QString("Hello"));

   882 }

   883 

   884 void tst_QTextDocumentFragment::hrefAnchor()

   885 {

   886     {

   887         const char html[] = "<a href=\"test\">blah</a>";

   888         setHtml(QString::fromLatin1(html));

   889         QVERIFY(doc->begin().begin().fragment().charFormat().isAnchor());

   890         QCOMPARE(doc->begin().begin().fragment().charFormat().anchorHref(), QString::fromAscii("test"));

   891         QVERIFY(doc->begin().begin().fragment().charFormat().fontUnderline() == true);

   892     }

   893 

   894     {

   895         // only hyperlinks should have special formatting

   896         const char html[] = "<a>blah</a>";

   897         setHtml(QString::fromLatin1(html));

   898         QVERIFY(doc->begin().begin().fragment().charFormat().isAnchor());

   899         QVERIFY(doc->begin().begin().fragment().charFormat().fontUnderline() == false);

   900     }

   901 }

   902 

   903 void tst_QTextDocumentFragment::namedAnchorFragments()

   904 {

   905     // named anchors should be 'invisible', but the fragment right after it should

   906     // hold the attribute

   907     const char html[] = "a<a name=\"test\" />blah";

   908     setHtml(QString::fromLatin1(html));

   909 

   910     QTextBlock firstBlock = doc->begin();

   911     QVERIFY(firstBlock.isValid());

   912 

   913     QTextBlock::Iterator it = firstBlock.begin();

   914     QVERIFY(!it.atEnd());

   915 

   916     // the 'a'

   917     QVERIFY(it.fragment().isValid());

   918     QCOMPARE(it.fragment().text(), QString::fromAscii("a"));

   919     QVERIFY(it.fragment().charFormat().isAnchor() == false);

   920 

   921     // the 'b' of 'blah' as separate fragment with the anchor attribute

   922     ++it;

   923     QVERIFY(it.fragment().isValid());

   924     QCOMPARE(it.fragment().text(), QString::fromAscii("b"));

   925     QVERIFY(it.fragment().charFormat().isAnchor());

   926 

   927     // the 'lah' of 'blah' as remainder

   928     ++it;

   929     QVERIFY(it.fragment().isValid());

   930     QVERIFY(it.fragment().text().startsWith("lah"));

   931     QVERIFY(it.fragment().charFormat().isAnchor() == false);

   932 }

   933 

   934 void tst_QTextDocumentFragment::namedAnchorFragments2()

   935 {

   936     const char html[] = "<p>    <a name=\"foo\"> Hello";

   937     setHtml(QString::fromLatin1(html));

   938 

   939     QCOMPARE(doc->toPlainText(), QString("Hello"));

   940 

   941     QTextBlock::Iterator it = doc->begin().begin();

   942     QVERIFY(!it.atEnd());

   943 

   944     QCOMPARE(it.fragment().text(), QString::fromAscii("H"));

   945     QVERIFY(it.fragment().charFormat().isAnchor());

   946 

   947     ++it;

   948 

   949     QCOMPARE(it.fragment().text(), QString::fromAscii("ello"));

   950     QVERIFY(!it.fragment().charFormat().isAnchor());

   951 }

   952 

   953 void tst_QTextDocumentFragment::namedAnchorFragments3()

   954 {

   955     setHtml("<a name=\"target\" /><a name=\"target2\"/><span>Text</span>");

   956 

   957     QCOMPARE(doc->toPlainText(), QString("Text"));

   958 

   959     QTextBlock::Iterator it = doc->begin().begin();

   960     QVERIFY(!it.atEnd());

   961 

   962     QCOMPARE(it.fragment().text(), QString::fromAscii("T"));

   963     QVERIFY(it.fragment().charFormat().isAnchor());

   964     QCOMPARE(it.fragment().charFormat().anchorName(), QString("target"));

   965     QStringList targets; targets << "target" << "target2";

   966     QCOMPARE(it.fragment().charFormat().anchorNames(), targets);

   967 

   968     ++it;

   969 

   970     QCOMPARE(it.fragment().text(), QString::fromAscii("ext"));

   971     QVERIFY(!it.fragment().charFormat().isAnchor());

   972 }

   973 

   974 void tst_QTextDocumentFragment::dontInheritAlignmentInTables()

   975 {

   976     const char html[] = "<table align=center><tr><td>Hey</td></tr></table>";

   977     setHtml(QString::fromLatin1(html));

   978 

   979     cursor.movePosition(QTextCursor::Start);

   980     cursor.movePosition(QTextCursor::NextBlock);

   981     QVERIFY(cursor.currentTable());

   982     QVERIFY(cursor.currentTable()->cellAt(0, 0).isValid());

   983     QVERIFY(cursor.currentTable()->cellAt(0, 0).firstCursorPosition().block().next().blockFormat().alignment() != Qt::AlignHCenter);

   984 }

   985 

   986 void tst_QTextDocumentFragment::cellBlockCount()

   987 {

   988     const char html[] = "<table><tr><td>Hey</td></tr></table>";

   989     setHtml(QString::fromLatin1(html));

   990 

   991     cursor.movePosition(QTextCursor::Start);

   992     cursor.movePosition(QTextCursor::NextBlock);

   993     QVERIFY(cursor.currentTable());

   994 

   995     QTextTableCell cell = cursor.currentTable()->cellAt(0, 0);

   996     QVERIFY(cell.isValid());

   997 

   998     int blockCount = 0;

   999     for (QTextFrame::iterator it = cell.begin(); !it.atEnd(); ++it) {

  1000         QVERIFY(it.currentFrame() == 0);

  1001         QVERIFY(it.currentBlock().isValid());

  1002         ++blockCount;

  1003     }

  1004     QCOMPARE(blockCount, 1);

  1005 }

  1006 

  1007 void tst_QTextDocumentFragment::cellBlockCount2()

  1008 {

  1009     const char html[] = "<table><tr><td><p>Hey</p></td></tr></table>";

  1010     setHtml(QString::fromLatin1(html));

  1011 

  1012     cursor.movePosition(QTextCursor::Start);

  1013     cursor.movePosition(QTextCursor::NextBlock);

  1014     QVERIFY(cursor.currentTable());

  1015 

  1016     QTextTableCell cell = cursor.currentTable()->cellAt(0, 0);

  1017     QVERIFY(cell.isValid());

  1018 

  1019     int blockCount = 0;

  1020     for (QTextFrame::iterator it = cell.begin(); !it.atEnd(); ++it) {

  1021         QVERIFY(it.currentFrame() == 0);

  1022         QVERIFY(it.currentBlock().isValid());

  1023         ++blockCount;

  1024     }

  1025     QCOMPARE(blockCount, 1);

  1026 }

  1027 

  1028 void tst_QTextDocumentFragment::emptyTable()

  1029 {

  1030     const char html[] = "<table></table>";

  1031     setHtml(QString::fromLatin1(html));

  1032     QVERIFY(true); // don't crash with a failing assertion

  1033 }

  1034 

  1035 void tst_QTextDocumentFragment::emptyTable2()

  1036 {

  1037     const char html[] = "<table></td></tr></table><p>blah</p>";

  1038     setHtml(QString::fromLatin1(html));

  1039     QVERIFY(true); // don't crash with a failing assertion

  1040 }

  1041 

  1042 void tst_QTextDocumentFragment::emptyTable3()

  1043 {

  1044     const char html[] = "<table><tr><td><table></table></td><td>Foobar</td></tr></table>";

  1045     setHtml(QString::fromLatin1(html));

  1046 

  1047     cursor.movePosition(QTextCursor::Start);

  1048     cursor.movePosition(QTextCursor::NextBlock);

  1049     QTextTable *table = cursor.currentTable();

  1050     QVERIFY(table);

  1051     QCOMPARE(table->rows(), 1);

  1052     QCOMPARE(table->columns(), 2);

  1053     QTextTableCell cell = table->cellAt(0, 0);

  1054     QVERIFY(cell.isValid());

  1055     QVERIFY(cell.firstPosition() == cell.lastPosition());

  1056     cell = table->cellAt(0, 1);

  1057     QTextCursor cursor = cell.firstCursorPosition();

  1058     cursor.setPosition(cell.lastPosition(), QTextCursor::KeepAnchor);

  1059     QCOMPARE(cursor.selectedText(), QString("Foobar"));

  1060 }

  1061 

  1062 void tst_QTextDocumentFragment::doubleRowClose()

  1063 {

  1064     const char html[] = "<table><tr><td>Blah</td></tr></tr><tr><td>Hm</td></tr></table>";

  1065     setHtml(QString::fromLatin1(html));

  1066     QVERIFY(true); // don't crash with a failing assertion

  1067 }

  1068 

  1069 void tst_QTextDocumentFragment::mayNotHaveChildren()

  1070 {

  1071     // make sure the Hey does not end up as tag text for the img tag

  1072     const char html[] = "<img />Hey";

  1073     setHtml(QString::fromLatin1(html));

  1074     QCOMPARE(doc->toPlainText().mid(1), QString::fromAscii("Hey"));

  1075 }

  1076 

  1077 void tst_QTextDocumentFragment::inheritAlignment()

  1078 {

  1079     // make sure attributes from the body tag get inherited

  1080     const char html[] = "<body align=right><p>Hey";

  1081     setHtml(QString::fromLatin1(html));

  1082     // html alignment is absolute

  1083     QVERIFY(doc->begin().blockFormat().alignment() == Qt::Alignment(Qt::AlignRight|Qt::AlignAbsolute));

  1084 }

  1085 

  1086 void tst_QTextDocumentFragment::dontEmitEmptyNodeWhenEmptyTagIsFollowedByCloseTag()

  1087 {

  1088     // make sure the Hey does not end up as tag text for the img tag

  1089     const char html[] = "<body align=right><p align=left>Blah<img></img><p>Hey";

  1090     setHtml(QString::fromLatin1(html));

  1091     QVERIFY(doc->begin().blockFormat().alignment() == Qt::Alignment(Qt::AlignLeft|Qt::AlignAbsolute));

  1092     QVERIFY(doc->begin().next().blockFormat().alignment() == Qt::Alignment(Qt::AlignRight|Qt::AlignAbsolute));

  1093 }

  1094 

  1095 void tst_QTextDocumentFragment::toPlainText()

  1096 {

  1097     QString input = "Hello\nWorld";

  1098     input += QChar::ParagraphSeparator;

  1099     input += "Blah";

  1100     doc->setPlainText(input);

  1101     QCOMPARE(doc->blockCount(), 3);

  1102 }

  1103 

  1104 void tst_QTextDocumentFragment::copyTableRow()

  1105 {

  1106     QTextDocumentFragment frag;

  1107     {

  1108         QTextTable *table = cursor.insertTable(2, 2);

  1109         table->cellAt(0, 0).firstCursorPosition().insertText("Blah");

  1110         table->cellAt(0, 1).firstCursorPosition().insertText("Foo");

  1111         table->cellAt(1, 0).firstCursorPosition().insertText("Bar");

  1112         table->cellAt(1, 1).firstCursorPosition().insertText("Hah");

  1113 

  1114         // select second row

  1115         cursor = table->cellAt(1, 1).firstCursorPosition();

  1116         cursor.movePosition(QTextCursor::PreviousBlock, QTextCursor::KeepAnchor);

  1117 

  1118         QCOMPARE(table->cellAt(cursor.position()).row(), 1);

  1119         QCOMPARE(table->cellAt(cursor.position()).column(), 0);

  1120         QCOMPARE(table->cellAt(cursor.anchor()).row(), 1);

  1121         QCOMPARE(table->cellAt(cursor.anchor()).column(), 1);

  1122 

  1123         frag = QTextDocumentFragment(cursor);

  1124     }

  1125     {

  1126         QTextDocument doc2;

  1127         cursor = QTextCursor(&doc2);

  1128         cursor.insertFragment(frag);

  1129 

  1130         cursor.movePosition(QTextCursor::Start);

  1131         cursor.movePosition(QTextCursor::NextBlock);

  1132         QTextTable *table = cursor.currentTable();

  1133 

  1134         QVERIFY(table);

  1135         QCOMPARE(table->columns(), 2);