--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/auto/qtextdocumentfragment/tst_qtextdocumentfragment.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,4020 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+
+
+#include <qtextdocument.h>
+#include <qtextdocumentfragment.h>
+#include <qtexttable.h>
+#include <qtextlist.h>
+#include <qdebug.h>
+#include <private/qtextdocument_p.h>
+
+
+#include <qtextcursor.h>
+
+QT_FORWARD_DECLARE_CLASS(QTextDocument)
+
+//TESTED_CLASS=
+//TESTED_FILES=gui/text/qtextdocumentfragment.h gui/text/qtextdocumentfragment.cpp gui/text/qtexthtmlparser.cpp gui/text/qtexthtmlparser_p.h
+
+class tst_QTextDocumentFragment : public QObject
+{
+ Q_OBJECT
+
+public:
+ tst_QTextDocumentFragment();
+ ~tst_QTextDocumentFragment();
+
+public slots:
+ void init();
+ void cleanup();
+private slots:
+ void listCopying();
+ void listZeroCopying();
+ void listCopying2();
+ void tableCopying();
+ void tableCopyingWithColSpans();
+ void tableColSpanAndWidth();
+ void tableImport();
+ void tableImport2();
+ void tableImport3();
+ void tableImport4();
+ void tableImport5();
+ void textCopy();
+ void copyWholeDocument();
+ void title();
+ void html_listIndents1();
+ void html_listIndents2();
+ void html_listIndents3();
+ void html_listIndents4();
+ void html_listIndents5();
+ void html_listIndents6();
+ void blockCharFormat();
+ void blockCharFormatCopied();
+ void initialBlock();
+ void clone();
+ void dontRemoveInitialBlockIfItHoldsObjectIndexedCharFormat();
+ void dosLineFeed();
+ void unorderedListEnumeration();
+ void resetHasBlockAfterClosedBlockTags();
+ void ignoreStyleTags();
+ void hrefAnchor();
+ void namedAnchorFragments();
+ void namedAnchorFragments2();
+ void namedAnchorFragments3();
+ void dontInheritAlignmentInTables();
+ void cellBlockCount();
+ void cellBlockCount2();
+ void emptyTable();
+ void emptyTable2();
+ void emptyTable3();
+ void doubleRowClose();
+ void mayNotHaveChildren();
+ void inheritAlignment();
+ void dontEmitEmptyNodeWhenEmptyTagIsFollowedByCloseTag();
+ void toPlainText();
+ void copyTableRow();
+ void copyTableColumn();
+ void copySubTable();
+ void html_textDecoration();
+ void html_infiniteLoop();
+ void html_blockIndent();
+ void html_listIndent();
+ void html_whitespace();
+ void html_whitespace_data();
+ void html_qt3Whitespace();
+ void html_qt3WhitespaceWithFragments();
+ void html_qt3WhitespaceAfterTags();
+ void html_listStart1();
+ void html_listStart2();
+ void html_cssMargin();
+ void html_hexEntities();
+ void html_decEntities();
+ void html_thCentered();
+ void orderedListNumbering();
+ void html_blockAfterList();
+ void html_subAndSuperScript();
+ void html_cssColors();
+ void obeyFragmentMarkersInImport();
+ void whitespaceWithFragmentMarkers();
+ void html_emptyParapgraphs1();
+ void html_emptyParapgraphs2();
+ void html_emptyParagraphs3();
+ void html_emptyParagraphs4();
+ void html_font();
+ void html_fontSize();
+ void html_fontSizeAdjustment();
+ void html_cssFontSize();
+ void html_cssShorthandFont();
+ void html_bodyBgColor();
+ void html_qtBgColor();
+ void html_blockLevelDiv();
+ void html_spanNesting();
+ void html_nestedLists();
+ void noSpecialCharactersInPlainText();
+ void html_doNotInheritBackground();
+ void html_inheritBackgroundToInlineElements();
+ void html_doNotInheritBackgroundFromBlockElements();
+ void html_nobr();
+ void fromPlainText();
+ void fromPlainText2();
+ void html_closingImageTag();
+ void html_emptyDocument();
+ void html_closingTag();
+ void html_anchorAroundImage();
+ void html_floatBorder();
+ void html_frameImport();
+ void html_frameImport2();
+ void html_dontAddMarginsAcrossTableCells();
+ void html_dontMergeCenterBlocks();
+ void html_tableCellBgColor();
+ void html_tableCellBgColor2();
+ void html_cellSkip();
+ void nonZeroMarginOnImport();
+ void html_charFormatPropertiesUnset();
+ void html_headings();
+ void html_quotedFontFamily();
+ void html_spanBackgroundColor();
+ void defaultFont();
+ void html_brokenTitle_data();
+ void html_brokenTitle();
+ void html_blockVsInline();
+ void html_tbody();
+ void html_nestedTables();
+ void html_rowSpans();
+ void html_rowSpans2();
+ void html_implicitParagraphs();
+ void html_missingCloseTag();
+ void html_anchorColor();
+ void html_lastParagraphClosing();
+ void html_tableHeaderBodyFootParent();
+ void html_columnWidths();
+ void html_bodyBackground();
+ void html_tableCellBackground();
+ void css_bodyBackground();
+ void css_tableCellBackground();
+ void css_fontWeight();
+ void css_float();
+ void css_textIndent();
+ void css_inline();
+ void css_external();
+ void css_import();
+ void css_selectors_data();
+ void css_selectors();
+ void css_nodeNameCaseInsensitivity();
+ void css_textUnderlineStyle_data();
+ void css_textUnderlineStyle();
+ void css_textUnderlineStyleAndDecoration();
+ void css_listStyleType();
+ void css_linkPseudo();
+ void css_pageBreaks();
+ void css_cellPaddings();
+ void universalSelectors_data();
+ void universalSelectors();
+ void screenMedia();
+ void htmlResourceLoading();
+ void someCaseInsensitiveAttributeValues();
+ void backgroundImage();
+ void dontMergePreAndNonPre();
+ void leftMarginInsideHtml();
+ void html_margins();
+ void newlineInsidePreShouldBecomeNewParagraph();
+ void invalidColspan();
+ void html_brokenTableWithJustTr();
+ void html_brokenTableWithJustTd();
+ void html_preNewlineHandling_data();
+ void html_preNewlineHandling();
+ void html_br();
+ void html_dl();
+ void html_tableStrangeNewline();
+ void html_tableStrangeNewline2();
+ void html_tableStrangeNewline3();
+ void html_caption();
+ void html_windowsEntities();
+ void html_eatenText();
+ void html_hr();
+ void html_hrMargins();
+ void html_blockQuoteMargins();
+ void html_definitionListMargins();
+ void html_listMargins();
+ void html_titleAttribute();
+ void html_compressDivs();
+ void completeToPlainText();
+ void copyContents();
+ void html_textAfterHr();
+ void blockTagClosing();
+ void isEmpty();
+ void html_alignmentInheritance();
+ void html_ignoreEmptyDivs();
+ void html_dontInheritAlignmentForFloatingImages();
+ void html_verticalImageAlignment();
+ void html_verticalCellAlignment();
+ void html_borderColor();
+ void html_borderStyle();
+ void html_borderWidth();
+ void html_userState();
+ void html_rootFrameProperties();
+ void html_alignmentPropertySet();
+ void html_appendList();
+ void html_appendList2();
+ void html_qt3RichtextWhitespaceMode();
+ void html_brAfterHr();
+ void html_unclosedHead();
+ void html_entities();
+ void html_entities_data();
+ void html_ignore_script();
+ void html_directionWithHtml();
+ void html_directionWithRichText();
+ void html_metaInBody();
+ void html_importImageWithoutAspectRatio();
+ void html_fromFirefox();
+
+private:
+ inline void setHtml(const QString &html)
+ // don't take the shortcut in QTextDocument::setHtml
+ { doc->clear(); QTextCursor(doc).insertFragment(QTextDocumentFragment::fromHtml(html)); }
+
+ inline void appendHtml(const QString &html)
+ {
+ QTextCursor cursor(doc);
+ cursor.movePosition(QTextCursor::End);
+ cursor.insertHtml(html);
+ }
+
+ QTextDocument *doc;
+ QTextCursor cursor;
+};
+
+tst_QTextDocumentFragment::tst_QTextDocumentFragment()
+{
+ QImage img(16, 16, QImage::Format_ARGB32_Premultiplied);
+ img.save("foo.png");
+}
+
+tst_QTextDocumentFragment::~tst_QTextDocumentFragment()
+{
+ QFile::remove(QLatin1String("foo.png"));
+}
+
+void tst_QTextDocumentFragment::init()
+{
+ doc = new QTextDocument;
+ cursor = QTextCursor(doc);
+}
+
+void tst_QTextDocumentFragment::cleanup()
+{
+ cursor = QTextCursor();
+ delete doc;
+ doc = 0;
+}
+
+#include <private/qtextdocument_p.h>
+#include <qdebug.h>
+static void dumpTable(const QTextDocumentPrivate *pt)
+{
+ qDebug() << "---dump----";
+ qDebug() << "all text:" << pt->buffer();
+ for (QTextDocumentPrivate::FragmentIterator it = pt->begin();
+ !it.atEnd(); ++it) {
+ qDebug() << "Fragment at text position" << it.position() << "; stringPosition" << it.value()->stringPosition << "; size" << it.value()->size_array[0] << "format :" << it.value()->format << "frag: " << it.n;
+ qDebug() << " text:" << pt->buffer().mid(it.value()->stringPosition, it.value()->size_array[0]);
+ }
+ qDebug() << "----begin block dump----";
+ for (QTextBlock it = pt->blocksBegin(); it.isValid(); it = it.next())
+ qDebug() << "block at" << it.position() << "with length" << it.length() << "block alignment" << it.blockFormat().alignment();
+ qDebug() << "---dump----";
+}
+static void dumpTable(QTextDocument *doc) { dumpTable(doc->docHandle()); }
+
+void tst_QTextDocumentFragment::listCopying()
+{
+ cursor.insertList(QTextListFormat::ListDecimal);
+
+ QTextFormat originalBlockFormat = cursor.blockFormat();
+ QVERIFY(originalBlockFormat.objectIndex() != -1);
+ int originalListItemIdx = cursor.blockFormat().objectIndex();
+
+ cursor.insertText("Hello World");
+
+ QTextDocumentFragment fragment(doc);
+
+ cursor.insertFragment(fragment);
+
+ QVERIFY(cursor.currentList());
+ QVERIFY(cursor.blockFormat() != originalBlockFormat);
+ QVERIFY(cursor.blockFormat().objectIndex() != originalListItemIdx);
+}
+
+void tst_QTextDocumentFragment::listZeroCopying()
+{
+ // same testcase as above but using the zero-copying
+
+ cursor.insertList(QTextListFormat::ListDecimal);
+
+ QTextFormat originalBlockFormat = cursor.blockFormat();
+ int originalListItemIdx = cursor.blockFormat().objectIndex();
+
+ cursor.insertText("Hello World");
+
+ QTextDocumentFragment fragment(doc);
+ cursor.insertFragment(fragment);
+
+ QVERIFY(cursor.currentList());
+ QVERIFY(cursor.blockFormat() != originalBlockFormat);
+ QVERIFY(cursor.blockFormat().objectIndex() != originalListItemIdx);
+}
+
+void tst_QTextDocumentFragment::listCopying2()
+{
+ cursor.insertList(QTextListFormat::ListDecimal);
+ cursor.insertText("Hello World");
+
+ cursor.insertList(QTextListFormat::ListDisc);
+ cursor.insertText("Hello World");
+
+ QTextDocumentFragment fragment(doc);
+
+ cursor.insertFragment(fragment);
+
+ cursor.movePosition(QTextCursor::Start);
+ int listItemCount = 0;
+ do {
+ if (cursor.currentList())
+ listItemCount++;
+ } while (cursor.movePosition(QTextCursor::NextBlock));
+
+ QCOMPARE(listItemCount, 4);
+
+ // we call this here because it used to cause a failing assertion in the
+ // list manager.
+ doc->undo();
+}
+
+void tst_QTextDocumentFragment::tableCopying()
+{
+ // this tests both, the fragment to use the direction insertion instead of using the
+ // cursor, which might adjuts its position when inserting a table step by step, as well
+ // as the pasiveness of the tablemanager.
+ QTextDocumentFragment fragment;
+ {
+ QTextDocument doc;
+ QTextCursor cursor(&doc);
+
+ QTextTableFormat fmt;
+ QTextTable *table = cursor.insertTable(2, 2, fmt);
+
+ table->cellAt(0, 0).firstCursorPosition().insertText("First Cell");
+ table->cellAt(0, 1).firstCursorPosition().insertText("Second Cell");
+ table->cellAt(1, 0).firstCursorPosition().insertText("Third Cell");
+ table->cellAt(1, 1).firstCursorPosition().insertText("Fourth Cell");
+
+ fragment = QTextDocumentFragment(&doc);
+ }
+ {
+ QTextDocument doc;
+ QTextCursor cursor(&doc);
+
+ cursor.insertText("FooBar");
+ cursor.insertBlock();
+ cursor.movePosition(QTextCursor::Left);
+
+ cursor.insertFragment(fragment);
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->rows(), 2);
+ QCOMPARE(table->columns(), 2);
+ }
+}
+
+void tst_QTextDocumentFragment::tableCopyingWithColSpans()
+{
+ const char html[] = ""
+"<table border>"
+" <tr>"
+" <td>First Cell"
+" <td>Second Cell"
+" </tr>"
+" <tr>"
+" <td colspan=\"2\">Third Cell"
+" </tr>"
+" <tr>"
+" <td>Fourth Cell"
+" <td>Fifth Cell"
+" </tr>"
+"</table>";
+ setHtml(html);
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QVERIFY(table->columns() == 2 && table->rows() == 3);
+
+ cursor = table->cellAt(2, 0).lastCursorPosition();
+ cursor.setPosition(table->cellAt(0, 0).firstPosition(), QTextCursor::KeepAnchor);
+ QVERIFY(cursor.hasComplexSelection());
+
+ int firstRow = 0, numRows = 0, firstCol = 0, numCols = 0;
+ cursor.selectedTableCells(&firstRow, &numRows, &firstCol, &numCols);
+ QCOMPARE(firstRow, 0);
+ QCOMPARE(numRows, 3);
+ QCOMPARE(firstCol, 0);
+ QCOMPARE(numCols, 1);
+
+ QTextDocumentFragment frag = cursor.selection();
+ cleanup();
+ init();
+ cursor.insertFragment(frag);
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ table = cursor.currentTable();
+ QVERIFY(table);
+ QVERIFY(table->columns() == 1 && table->rows() == 3);
+}
+
+void tst_QTextDocumentFragment::tableColSpanAndWidth()
+{
+ const char html[] = ""
+"<table border=\"0\">"
+" <tr>"
+" <td colspan=\"4\" width=\"400\">First Cell</td>"
+" </tr>"
+"</table>";
+ setHtml(html);
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QVERIFY(table->columns() == 4 && table->rows() == 1);
+ // make sure its approx 400 and not a multiple due to the colspan
+ QVERIFY(doc->size().width()> 398.);
+ QVERIFY(doc->size().width() < 420.);
+}
+
+void tst_QTextDocumentFragment::tableImport()
+{
+ // used to cause a failing assertion, as HTMLImporter::closeTag was
+ // called twice with the last node.
+ QTextDocumentFragment fragment = QTextDocumentFragment::fromHtml(QString::fromLatin1("<table><tr><td>Hey</td><td>Blah"));
+ QVERIFY(!fragment.isEmpty());
+}
+
+void tst_QTextDocumentFragment::tableImport2()
+{
+ {
+ const char html[] = ""
+ "<table>"
+ "<tr><td>First Cell</td><td>Second Cell</td></tr>"
+ "<tr><td>Third Cell</td><td>Fourth Cell</td></tr>"
+ "</table>";
+
+ QTextDocument doc;
+ QTextCursor cursor(&doc);
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QByteArray::fromRawData(html, sizeof(html) / sizeof(html[0]))));
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->columns(), 2);
+ QCOMPARE(table->rows(), 2);
+ }
+ {
+ const char html[] = ""
+ "<table>"
+ "<tr><td>First Cell</td><td>Second Cell</td></tr>"
+ "<tr><td>Third Cell</td><td>"
+ " <table>"
+ " <tr><td>First Nested Cell</td><td>Second Nested Cell</td></tr>"
+ " <tr><td>Third Nested Cell</td><td>Fourth Nested Cell</td></tr>"
+ " <tr><td>Fifth Nested Cell</td><td>Sixth Nested Cell</td></tr>"
+ " </table></td></tr>"
+ "</table>";
+
+ QTextDocument doc;
+ QTextCursor cursor(&doc);
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QByteArray::fromRawData(html, sizeof(html) / sizeof(html[0]))));
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->columns(), 2);
+ QCOMPARE(table->rows(), 2);
+
+ /*
+ QTextCursor fourthCell = table->cellAt(1, 1).firstCursorPosition();
+ fourthCell.movePosition(QTextCursor::NextBlock);
+ table = fourthCell.currentTable();
+ QVERIFY(table);
+ QVERIFY(table != cursor.currentTable());
+ QCOMPARE(table->columns(), 2);
+ QCOMPARE(table->rows(), 3);
+ */
+ }
+ {
+ const char buggyHtml[] = ""
+ "<table>"
+ "<tr><td>First Cell<td>Second Cell"
+ "<tr><td>Third Cell<td>Fourth Cell"
+ "</table>";
+
+ QTextDocument doc;
+ QTextCursor cursor(&doc);
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QByteArray::fromRawData(buggyHtml, sizeof(buggyHtml) / sizeof(buggyHtml[0]))));
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->columns(), 2);
+ QCOMPARE(table->rows(), 2);
+ }
+ {
+ const char buggyHtml[] = ""
+ "<table>"
+ "<tr><th>First Cell<th>Second Cell"
+ "<tr><td>Third Cell<td>Fourth Cell"
+ "</table>";
+
+ QTextDocument doc;
+ QTextCursor cursor(&doc);
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QByteArray::fromRawData(buggyHtml, sizeof(buggyHtml) / sizeof(buggyHtml[0]))));
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->columns(), 2);
+ QCOMPARE(table->rows(), 2);
+ }
+
+}
+
+void tst_QTextDocumentFragment::tableImport3()
+{
+ // ### would be better to have tree tests for QTextHtmlParser
+ // make sure the p is a child of the td. If not the following td
+ // ends up outside the table, causing an assertion
+ const char html[] = "<table><tr><td><p></p></td><td></td></tr></table>";
+ QTextDocumentFragment fragment = QTextDocumentFragment::fromHtml(QString::fromLatin1(html));
+ QVERIFY(!fragment.isEmpty());
+}
+
+void tst_QTextDocumentFragment::tableImport4()
+{
+ const char html[] = "<table>"
+ "<tr><td>blah</td></tr>"
+ "<tr><td>blah</td><td>blah</td></tr>"
+ "</table>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QString::fromLatin1(html)));
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QVERIFY(cursor.currentTable());
+ QCOMPARE(cursor.currentTable()->columns(), 2);
+}
+
+void tst_QTextDocumentFragment::tableImport5()
+{
+ const char html[] = "<table>"
+ "<tr>"
+ " <td>Foo</td>"
+ " <td>Bar</td>"
+ " <td>Bleh</td>"
+ " <td>Blub</td>"
+ "</tr>"
+ "<tr>"
+ " <td>Ahh</td>"
+ " <td colspan=5>Gah</td>"
+ "</tr>"
+ "</table>";
+
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QString::fromLatin1(html)));
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QVERIFY(cursor.currentTable());
+ QCOMPARE(cursor.currentTable()->rows(), 2);
+ QCOMPARE(cursor.currentTable()->columns(), 6);
+}
+
+void tst_QTextDocumentFragment::textCopy()
+{
+ /* this test used to cause failing assertions in QTextDocumentFragment */
+ /* copy&paste 'lo\bwor' */
+ cursor.insertText("Hello");
+ cursor.insertBlock();
+ cursor.insertText("World");
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::MoveAnchor, 3);
+ cursor.movePosition(QTextCursor::NextBlock, QTextCursor::KeepAnchor);
+ cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor, 3);
+
+ QTextDocumentFragment fragment(cursor);
+ QVERIFY(!fragment.isEmpty());
+ cursor.insertFragment(fragment);
+}
+
+void tst_QTextDocumentFragment::copyWholeDocument()
+{
+ // used to cause the famous currentBlock.position() == pos + 1 failing assertion
+ cursor.insertText("\nHey\nBlah\n");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
+
+ QTextFrameFormat fmt = doc->rootFrame()->frameFormat();
+ fmt.setBackground(Qt::blue);
+ doc->rootFrame()->setFrameFormat(fmt);
+
+ QTextDocumentFragment fragment(cursor);
+ QVERIFY(true); // good if we reach this point :)
+
+ cleanup();
+ init();
+
+ fmt.setBackground(Qt::red);
+ doc->rootFrame()->setFrameFormat(fmt);
+
+ cursor.insertFragment(fragment);
+
+ QVERIFY(doc->rootFrame()->frameFormat().background().color() == Qt::red);
+}
+
+void tst_QTextDocumentFragment::title()
+{
+ doc->setHtml(QString::fromLatin1("<html><head><title>Test</title></head><body>Blah</body></html>"));
+ QCOMPARE(doc->metaInformation(QTextDocument::DocumentTitle), QString::fromLatin1("Test"));
+}
+
+void tst_QTextDocumentFragment::html_listIndents1()
+{
+ const char html[] = "<ul><li>Hey</li><li>Hah</li></ul>";
+ setHtml(QString::fromLatin1(html));
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextList *list = cursor.currentList();
+ QVERIFY(list);
+ QCOMPARE(list->format().indent(), 1);
+ QCOMPARE(cursor.block().blockFormat().indent(), 0);
+}
+
+void tst_QTextDocumentFragment::html_listIndents2()
+{
+ const char html[] = "<ul><li>Hey<p>Hah</ul>";
+ setHtml(QString::fromLatin1(html));
+ cursor.movePosition(QTextCursor::Start);
+ QTextList *list = cursor.currentList();
+ QVERIFY(list);
+ QCOMPARE(list->format().indent(), 1);
+ QCOMPARE(cursor.block().blockFormat().indent(), 0);
+
+ cursor.movePosition(QTextCursor::NextBlock);
+ QCOMPARE(cursor.block().blockFormat().indent(), 1);
+}
+
+void tst_QTextDocumentFragment::html_listIndents3()
+{
+ const char html[] = "<ul><li><p>Hah</ul>";
+ setHtml(QString::fromLatin1(html));
+ cursor.movePosition(QTextCursor::Start);
+ QTextList *list = cursor.currentList();
+ QVERIFY(list);
+ QCOMPARE(list->format().indent(), 1);
+ QCOMPARE(cursor.block().blockFormat().indent(), 0);
+}
+
+void tst_QTextDocumentFragment::html_listIndents4()
+{
+ const char html[] = "<ul><li>Foo</ul><p>This should not have the same indent as Foo";
+ setHtml(QString::fromLatin1(html));
+ cursor.movePosition(QTextCursor::Start);
+ QTextList *list = cursor.currentList();
+ QVERIFY(list);
+ QCOMPARE(list->format().indent(), 1);
+
+ cursor.movePosition(QTextCursor::NextBlock);
+ QVERIFY(!cursor.currentList());
+ QCOMPARE(cursor.blockFormat().indent(), 0);
+}
+
+void tst_QTextDocumentFragment::html_listIndents5()
+{
+ const char html[] = "<ul><li>Foo<p><li>Bar</li></ul>";
+ setHtml(QString::fromLatin1(html));
+ cursor.movePosition(QTextCursor::Start);
+ QTextList *list = cursor.currentList();
+ QVERIFY(list);
+ QCOMPARE(list->format().indent(), 1);
+
+ cursor.movePosition(QTextCursor::NextBlock);
+ QVERIFY(cursor.currentList() == list);
+ QCOMPARE(cursor.blockFormat().indent(), 0);
+}
+
+void tst_QTextDocumentFragment::html_listIndents6()
+{
+ const char html[] = "<ul><li>Outer List<div class=\"testclass\"><ul><li>Nested Item 1</li></ul></div></li></ul>";
+ setHtml(QString::fromLatin1(html));
+ cursor.movePosition(QTextCursor::Start);
+ QTextList *list = cursor.currentList();
+ QVERIFY(list);
+ QCOMPARE(list->format().indent(), 1);
+
+ cursor.movePosition(QTextCursor::NextBlock);
+ QVERIFY(cursor.currentList() != list);
+ list = cursor.currentList();
+ QVERIFY(list);
+ QCOMPARE(list->format().indent(), 2);
+
+ QCOMPARE(cursor.blockFormat().indent(), 0);
+}
+
+void tst_QTextDocumentFragment::blockCharFormat()
+{
+ const char html[] = "<p style=\"font-style:italic\"><span style=\"font-style:normal\">Test</span></p>";
+ setHtml(QString::fromLatin1(html));
+ QVERIFY(doc->begin().charFormat().fontItalic());
+}
+
+void tst_QTextDocumentFragment::blockCharFormatCopied()
+{
+ QTextCharFormat fmt;
+ fmt.setForeground(Qt::green);
+ cursor.setBlockCharFormat(fmt);
+ cursor.insertText("Test", QTextCharFormat());
+ QTextDocumentFragment frag(doc);
+ cleanup();
+ init();
+ cursor.insertFragment(frag);
+ QVERIFY(cursor.blockCharFormat() == fmt);
+}
+
+void tst_QTextDocumentFragment::initialBlock()
+{
+ const char html[] = "<p>Test</p>";
+ setHtml(QString::fromLatin1(html));
+ QCOMPARE(doc->blockCount(), 1);
+}
+
+void tst_QTextDocumentFragment::clone()
+{
+ QTextBlockFormat mod;
+ mod.setAlignment(Qt::AlignCenter);
+ cursor.mergeBlockFormat(mod);
+ cursor.insertText("Blah");
+ QVERIFY(cursor.blockFormat().alignment() == Qt::AlignCenter);
+ QTextDocumentFragment frag(doc);
+ cleanup();
+ init();
+ cursor.insertFragment(frag);
+ cursor.movePosition(QTextCursor::Start);
+ QVERIFY(cursor.blockFormat().alignment() == Qt::AlignCenter);
+}
+
+void tst_QTextDocumentFragment::dontRemoveInitialBlockIfItHoldsObjectIndexedCharFormat()
+{
+ const char html[] = "<table><tr><td>cell one<td>cell two</tr><tr><td>cell three<td>cell four</tr></table>";
+ QVERIFY(doc->begin().charFormat().objectIndex() == -1);
+ setHtml(QString::fromLatin1(html));
+ int cnt = 0;
+
+ int objectIndexOfLast = -1;
+ for (QTextBlock blk = doc->begin(); blk.isValid(); blk = blk.next()) {
+ ++cnt;
+ objectIndexOfLast = blk.charFormat().objectIndex();
+ }
+ // beginning of frame for first cell
+ // + beginning of frame for second cell
+ // + beginning of frame for third cell
+ // + beginning of frame for fourth cell
+ // + end of frame
+ // + initial block
+ // ==> 6
+ QCOMPARE(cnt, 6);
+ QVERIFY(objectIndexOfLast != -1);
+ QVERIFY(doc->begin().next().charFormat().objectIndex() != -1);
+}
+
+void tst_QTextDocumentFragment::dosLineFeed()
+{
+ const char html[] = "<pre>Test\r\n</pre>Bar";
+ setHtml(QString::fromLatin1(html));
+ QVERIFY(!doc->toPlainText().contains('\r'));
+ QCOMPARE(doc->toPlainText(), QString("Test\nBar"));
+}
+
+void tst_QTextDocumentFragment::unorderedListEnumeration()
+{
+ const char html[] = "<ul><ul><ul><li>Blah</li></ul></ul>";
+ setHtml(QString::fromLatin1(html));
+ cursor.movePosition(QTextCursor::End);
+ QVERIFY(cursor.currentList());
+ QVERIFY(cursor.currentList()->format().style() == QTextListFormat::ListCircle);
+
+ const char html2[] = "<ul><ul><ul type=disc><li>Blah</li></ul></ul>";
+ setHtml(QString::fromLatin1(html2));
+ cursor.movePosition(QTextCursor::End);
+ QVERIFY(cursor.currentList());
+ QVERIFY(cursor.currentList()->format().style() == QTextListFormat::ListDisc);
+
+}
+
+void tst_QTextDocumentFragment::resetHasBlockAfterClosedBlockTags()
+{
+ // when closing tags we have to make sure hasBlock in import() gets resetted
+ const char html[] = "<body><table><tr><td><td><p></table><p></body>";
+ setHtml(QString::fromLatin1(html));
+ QVERIFY(!doc->isEmpty());
+}
+
+void tst_QTextDocumentFragment::ignoreStyleTags()
+{
+ const char html[] = "<body><style>Blah</style>Hello</body>";
+ setHtml(QString::fromLatin1(html));
+ QCOMPARE(doc->toPlainText(), QString("Hello"));
+}
+
+void tst_QTextDocumentFragment::hrefAnchor()
+{
+ {
+ const char html[] = "<a href=\"test\">blah</a>";
+ setHtml(QString::fromLatin1(html));
+ QVERIFY(doc->begin().begin().fragment().charFormat().isAnchor());
+ QCOMPARE(doc->begin().begin().fragment().charFormat().anchorHref(), QString::fromAscii("test"));
+ QVERIFY(doc->begin().begin().fragment().charFormat().fontUnderline() == true);
+ }
+
+ {
+ // only hyperlinks should have special formatting
+ const char html[] = "<a>blah</a>";
+ setHtml(QString::fromLatin1(html));
+ QVERIFY(doc->begin().begin().fragment().charFormat().isAnchor());
+ QVERIFY(doc->begin().begin().fragment().charFormat().fontUnderline() == false);
+ }
+}
+
+void tst_QTextDocumentFragment::namedAnchorFragments()
+{
+ // named anchors should be 'invisible', but the fragment right after it should
+ // hold the attribute
+ const char html[] = "a<a name=\"test\" />blah";
+ setHtml(QString::fromLatin1(html));
+
+ QTextBlock firstBlock = doc->begin();
+ QVERIFY(firstBlock.isValid());
+
+ QTextBlock::Iterator it = firstBlock.begin();
+ QVERIFY(!it.atEnd());
+
+ // the 'a'
+ QVERIFY(it.fragment().isValid());
+ QCOMPARE(it.fragment().text(), QString::fromAscii("a"));
+ QVERIFY(it.fragment().charFormat().isAnchor() == false);
+
+ // the 'b' of 'blah' as separate fragment with the anchor attribute
+ ++it;
+ QVERIFY(it.fragment().isValid());
+ QCOMPARE(it.fragment().text(), QString::fromAscii("b"));
+ QVERIFY(it.fragment().charFormat().isAnchor());
+
+ // the 'lah' of 'blah' as remainder
+ ++it;
+ QVERIFY(it.fragment().isValid());
+ QVERIFY(it.fragment().text().startsWith("lah"));
+ QVERIFY(it.fragment().charFormat().isAnchor() == false);
+}
+
+void tst_QTextDocumentFragment::namedAnchorFragments2()
+{
+ const char html[] = "<p> <a name=\"foo\"> Hello";
+ setHtml(QString::fromLatin1(html));
+
+ QCOMPARE(doc->toPlainText(), QString("Hello"));
+
+ QTextBlock::Iterator it = doc->begin().begin();
+ QVERIFY(!it.atEnd());
+
+ QCOMPARE(it.fragment().text(), QString::fromAscii("H"));
+ QVERIFY(it.fragment().charFormat().isAnchor());
+
+ ++it;
+
+ QCOMPARE(it.fragment().text(), QString::fromAscii("ello"));
+ QVERIFY(!it.fragment().charFormat().isAnchor());
+}
+
+void tst_QTextDocumentFragment::namedAnchorFragments3()
+{
+ setHtml("<a name=\"target\" /><a name=\"target2\"/><span>Text</span>");
+
+ QCOMPARE(doc->toPlainText(), QString("Text"));
+
+ QTextBlock::Iterator it = doc->begin().begin();
+ QVERIFY(!it.atEnd());
+
+ QCOMPARE(it.fragment().text(), QString::fromAscii("T"));
+ QVERIFY(it.fragment().charFormat().isAnchor());
+ QCOMPARE(it.fragment().charFormat().anchorName(), QString("target"));
+ QStringList targets; targets << "target" << "target2";
+ QCOMPARE(it.fragment().charFormat().anchorNames(), targets);
+
+ ++it;
+
+ QCOMPARE(it.fragment().text(), QString::fromAscii("ext"));
+ QVERIFY(!it.fragment().charFormat().isAnchor());
+}
+
+void tst_QTextDocumentFragment::dontInheritAlignmentInTables()
+{
+ const char html[] = "<table align=center><tr><td>Hey</td></tr></table>";
+ setHtml(QString::fromLatin1(html));
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QVERIFY(cursor.currentTable());
+ QVERIFY(cursor.currentTable()->cellAt(0, 0).isValid());
+ QVERIFY(cursor.currentTable()->cellAt(0, 0).firstCursorPosition().block().next().blockFormat().alignment() != Qt::AlignHCenter);
+}
+
+void tst_QTextDocumentFragment::cellBlockCount()
+{
+ const char html[] = "<table><tr><td>Hey</td></tr></table>";
+ setHtml(QString::fromLatin1(html));
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QVERIFY(cursor.currentTable());
+
+ QTextTableCell cell = cursor.currentTable()->cellAt(0, 0);
+ QVERIFY(cell.isValid());
+
+ int blockCount = 0;
+ for (QTextFrame::iterator it = cell.begin(); !it.atEnd(); ++it) {
+ QVERIFY(it.currentFrame() == 0);
+ QVERIFY(it.currentBlock().isValid());
+ ++blockCount;
+ }
+ QCOMPARE(blockCount, 1);
+}
+
+void tst_QTextDocumentFragment::cellBlockCount2()
+{
+ const char html[] = "<table><tr><td><p>Hey</p></td></tr></table>";
+ setHtml(QString::fromLatin1(html));
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QVERIFY(cursor.currentTable());
+
+ QTextTableCell cell = cursor.currentTable()->cellAt(0, 0);
+ QVERIFY(cell.isValid());
+
+ int blockCount = 0;
+ for (QTextFrame::iterator it = cell.begin(); !it.atEnd(); ++it) {
+ QVERIFY(it.currentFrame() == 0);
+ QVERIFY(it.currentBlock().isValid());
+ ++blockCount;
+ }
+ QCOMPARE(blockCount, 1);
+}
+
+void tst_QTextDocumentFragment::emptyTable()
+{
+ const char html[] = "<table></table>";
+ setHtml(QString::fromLatin1(html));
+ QVERIFY(true); // don't crash with a failing assertion
+}
+
+void tst_QTextDocumentFragment::emptyTable2()
+{
+ const char html[] = "<table></td></tr></table><p>blah</p>";
+ setHtml(QString::fromLatin1(html));
+ QVERIFY(true); // don't crash with a failing assertion
+}
+
+void tst_QTextDocumentFragment::emptyTable3()
+{
+ const char html[] = "<table><tr><td><table></table></td><td>Foobar</td></tr></table>";
+ setHtml(QString::fromLatin1(html));
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->rows(), 1);
+ QCOMPARE(table->columns(), 2);
+ QTextTableCell cell = table->cellAt(0, 0);
+ QVERIFY(cell.isValid());
+ QVERIFY(cell.firstPosition() == cell.lastPosition());
+ cell = table->cellAt(0, 1);
+ QTextCursor cursor = cell.firstCursorPosition();
+ cursor.setPosition(cell.lastPosition(), QTextCursor::KeepAnchor);
+ QCOMPARE(cursor.selectedText(), QString("Foobar"));
+}
+
+void tst_QTextDocumentFragment::doubleRowClose()
+{
+ const char html[] = "<table><tr><td>Blah</td></tr></tr><tr><td>Hm</td></tr></table>";
+ setHtml(QString::fromLatin1(html));
+ QVERIFY(true); // don't crash with a failing assertion
+}
+
+void tst_QTextDocumentFragment::mayNotHaveChildren()
+{
+ // make sure the Hey does not end up as tag text for the img tag
+ const char html[] = "<img />Hey";
+ setHtml(QString::fromLatin1(html));
+ QCOMPARE(doc->toPlainText().mid(1), QString::fromAscii("Hey"));
+}
+
+void tst_QTextDocumentFragment::inheritAlignment()
+{
+ // make sure attributes from the body tag get inherited
+ const char html[] = "<body align=right><p>Hey";
+ setHtml(QString::fromLatin1(html));
+ // html alignment is absolute
+ QVERIFY(doc->begin().blockFormat().alignment() == Qt::Alignment(Qt::AlignRight|Qt::AlignAbsolute));
+}
+
+void tst_QTextDocumentFragment::dontEmitEmptyNodeWhenEmptyTagIsFollowedByCloseTag()
+{
+ // make sure the Hey does not end up as tag text for the img tag
+ const char html[] = "<body align=right><p align=left>Blah<img></img><p>Hey";
+ setHtml(QString::fromLatin1(html));
+ QVERIFY(doc->begin().blockFormat().alignment() == Qt::Alignment(Qt::AlignLeft|Qt::AlignAbsolute));
+ QVERIFY(doc->begin().next().blockFormat().alignment() == Qt::Alignment(Qt::AlignRight|Qt::AlignAbsolute));
+}
+
+void tst_QTextDocumentFragment::toPlainText()
+{
+ QString input = "Hello\nWorld";
+ input += QChar::ParagraphSeparator;
+ input += "Blah";
+ doc->setPlainText(input);
+ QCOMPARE(doc->blockCount(), 3);
+}
+
+void tst_QTextDocumentFragment::copyTableRow()
+{
+ QTextDocumentFragment frag;
+ {
+ QTextTable *table = cursor.insertTable(2, 2);
+ table->cellAt(0, 0).firstCursorPosition().insertText("Blah");
+ table->cellAt(0, 1).firstCursorPosition().insertText("Foo");
+ table->cellAt(1, 0).firstCursorPosition().insertText("Bar");
+ table->cellAt(1, 1).firstCursorPosition().insertText("Hah");
+
+ // select second row
+ cursor = table->cellAt(1, 1).firstCursorPosition();
+ cursor.movePosition(QTextCursor::PreviousBlock, QTextCursor::KeepAnchor);
+
+ QCOMPARE(table->cellAt(cursor.position()).row(), 1);
+ QCOMPARE(table->cellAt(cursor.position()).column(), 0);
+ QCOMPARE(table->cellAt(cursor.anchor()).row(), 1);
+ QCOMPARE(table->cellAt(cursor.anchor()).column(), 1);
+
+ frag = QTextDocumentFragment(cursor);
+ }
+ {
+ QTextDocument doc2;
+ cursor = QTextCursor(&doc2);
+ cursor.insertFragment(frag);
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+
+ QVERIFY(table);
+ QCOMPARE(table->columns(), 2);
+ QCOMPARE(table->rows(), 1);
+
+ QCOMPARE(table->cellAt(0, 0).firstCursorPosition().block().text(), QString("Bar"));
+ QCOMPARE(table->cellAt(0, 1).firstCursorPosition().block().text(), QString("Hah"));
+ }
+}
+
+void tst_QTextDocumentFragment::copyTableColumn()
+{
+ QTextDocumentFragment frag;
+ {
+ QTextTable *table = cursor.insertTable(2, 2);
+ table->cellAt(0, 0).firstCursorPosition().insertText("Blah");
+ table->cellAt(0, 1).firstCursorPosition().insertText("Foo");
+ table->cellAt(1, 0).firstCursorPosition().insertText("Bar");
+ table->cellAt(1, 1).firstCursorPosition().insertText("Hah");
+
+ // select second column
+ cursor = table->cellAt(0, 1).firstCursorPosition();
+ cursor.movePosition(QTextCursor::Down, QTextCursor::KeepAnchor);
+
+ QCOMPARE(table->cellAt(cursor.anchor()).row(), 0);
+ QCOMPARE(table->cellAt(cursor.anchor()).column(), 1);
+ QCOMPARE(table->cellAt(cursor.position()).row(), 1);
+ QCOMPARE(table->cellAt(cursor.position()).column(), 1);
+
+ frag = QTextDocumentFragment(cursor);
+ }
+ {
+ QTextDocument doc2;
+ cursor = QTextCursor(&doc2);
+ cursor.insertFragment(frag);
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+
+ QVERIFY(table);
+ QCOMPARE(table->columns(), 1);
+ QCOMPARE(table->rows(), 2);
+
+ QCOMPARE(table->cellAt(0, 0).firstCursorPosition().block().text(), QString("Foo"));
+ QCOMPARE(table->cellAt(1, 0).firstCursorPosition().block().text(), QString("Hah"));
+ }
+}
+
+void tst_QTextDocumentFragment::copySubTable()
+{
+ QTextDocumentFragment frag;
+ {
+ QTextTableFormat fmt;
+ QVector<QTextLength> constraints;
+ constraints << QTextLength(QTextLength::PercentageLength, 16);
+ constraints << QTextLength(QTextLength::PercentageLength, 28);
+ constraints << QTextLength(QTextLength::PercentageLength, 28);
+ constraints << QTextLength(QTextLength::PercentageLength, 28);
+ fmt.setColumnWidthConstraints(constraints);
+
+ QTextTable *table = cursor.insertTable(4, 4, fmt);
+ for (int row = 0; row < 4; ++row)
+ for (int col = 0; col < 4; ++col)
+ table->cellAt(row, col).firstCursorPosition().insertText(QString("%1/%2").arg(row).arg(col));
+
+ QCOMPARE(table->format().columnWidthConstraints().count(), table->columns());
+
+ // select 2x2 subtable
+ cursor = table->cellAt(1, 1).firstCursorPosition();
+ cursor.movePosition(QTextCursor::Down, QTextCursor::KeepAnchor);
+ cursor.movePosition(QTextCursor::Right, QTextCursor::KeepAnchor);
+
+ QCOMPARE(table->cellAt(cursor.anchor()).row(), 1);
+ QCOMPARE(table->cellAt(cursor.anchor()).column(), 1);
+ QCOMPARE(table->cellAt(cursor.position()).row(), 2);
+ QCOMPARE(table->cellAt(cursor.position()).column(), 2);
+
+ frag = QTextDocumentFragment(cursor);
+ }
+ {
+ QTextDocument doc2;
+ cursor = QTextCursor(&doc2);
+ cursor.insertFragment(frag);
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+
+ QVERIFY(table);
+ QVERIFY(table->format().columnWidthConstraints().isEmpty());
+ QCOMPARE(table->columns(), 2);
+ QCOMPARE(table->rows(), 2);
+
+ QCOMPARE(table->cellAt(0, 0).firstCursorPosition().block().text(), QString("1/1"));
+ QCOMPARE(table->cellAt(0, 1).firstCursorPosition().block().text(), QString("1/2"));
+ QCOMPARE(table->cellAt(1, 0).firstCursorPosition().block().text(), QString("2/1"));
+ QCOMPARE(table->cellAt(1, 1).firstCursorPosition().block().text(), QString("2/2"));
+ }
+}
+
+void tst_QTextDocumentFragment::html_textDecoration()
+{
+ const char html[] = "<span style='text-decoration: overline line-through underline'>Blah</span>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QByteArray::fromRawData(html, sizeof(html) / sizeof(html[0]))));
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().fontUnderline());
+ QVERIFY(cursor.charFormat().fontOverline());
+ QVERIFY(cursor.charFormat().fontStrikeOut());
+}
+
+void tst_QTextDocumentFragment::html_infiniteLoop()
+{
+ {
+ // used to cause an infinite loop due to the lack of a space after the
+ // tag name
+ const char html[] = "<ahref=\"argl\">Link</a>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(html));
+ QVERIFY(true);
+ }
+
+ {
+ const char html[] = "<a href=\"\"a<";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(html));
+ QVERIFY(true);
+ }
+}
+
+void tst_QTextDocumentFragment::html_blockIndent()
+{
+ const char html[] = "<p style=\"-qt-block-indent:3;\">Test</p>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(html));
+ QCOMPARE(cursor.blockFormat().indent(), 3);
+}
+
+void tst_QTextDocumentFragment::html_listIndent()
+{
+ const char html[] = "<ul style=\"-qt-list-indent:4;\"><li>Blah</ul>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(html));
+ QVERIFY(cursor.currentList());
+ QCOMPARE(cursor.currentList()->format().indent(), 4);
+}
+
+void tst_QTextDocumentFragment::html_whitespace_data()
+{
+ QTest::addColumn<QString>("html");
+ QTest::addColumn<QString>("expectedPlainText");
+
+ QTest::newRow("1") << QString("<span>This is some test</span><span> with spaces between words</span>")
+ << QString("This is some test with spaces between words");
+
+ QTest::newRow("2") << QString("<span> </span><span>nowhitespacehereplease</span>")
+ << QString::fromLatin1("nowhitespacehereplease");
+
+ QTest::newRow("3") << QString("<span style=\"white-space: pre;\"> white space here </span>")
+ << QString::fromLatin1(" white space here ");
+
+ QTest::newRow("4") << QString("<span style=\"white-space: pre-wrap;\"> white space here </span>")
+ << QString::fromLatin1(" white space here ");
+
+ QTest::newRow("5") << QString("<a href=\"One.html\">One</a> <a href=\"Two.html\">Two</a> <b>Three</b>\n"
+ "<b>Four</b>")
+ << QString::fromLatin1("One Two Three Four");
+
+ QTest::newRow("6") << QString("<p>Testing: <b><i><u>BoldItalic</u></i></b> <i>Italic</i></p>")
+ << QString("Testing: BoldItalic Italic");
+
+ QTest::newRow("7") << QString("<table><tr><td>Blah</td></tr></table> <table border><tr><td>Foo</td></tr></table>")
+ << QString("\nBlah\n\nFoo\n");
+
+ QTest::newRow("8") << QString("<table><tr><td><i>Blah</i></td></tr></table> <i>Blub</i>")
+ << QString("\nBlah\nBlub");
+
+ QTest::newRow("task116492") << QString("<p>a<font=\"Times\"> b </font>c</p>")
+ << QString("a b c");
+
+ QTest::newRow("task121653") << QString("abc<b> def</b>")
+ << QString("abc def");
+
+ QTest::newRow("task122650") << QString("<p>Foo</p> Bar")
+ << QString("Foo\nBar");
+
+ QTest::newRow("task122650-2") << QString("<p>Foo</p> <p> Bar")
+ << QString("Foo \nBar");
+
+ QTest::newRow("task122650-3") << QString("<html>Before<pre>\nTest</pre>")
+ << QString("Before\nTest");
+
+ QTest::newRow("br-with-whitespace") << QString("Foo<br>\nBlah")
+ << QString("Foo\nBlah");
+
+ QTest::newRow("collapse-p-with-newline") << QString("Foo<p>\n<p>\n<p>\n<p>\n<p>\n<p>\nBar")
+ << QString("Foo\nBar");
+
+ QTest::newRow("table") << QString("<table><tr><td>Blah</td></tr></table>\nTest")
+ << QString("\nBlah\nTest");
+
+ QTest::newRow("table2") << QString("<table><tr><td><pre>\nTest\n</pre></td>\n </tr></table>")
+ << QString("\nTest\n");
+
+ QTest::newRow("table3") << QString("<table><tr><td><pre>\nTest\n</pre> \n \n </td></tr></table>")
+ << QString("\nTest \n");
+}
+
+void tst_QTextDocumentFragment::html_whitespace()
+{
+ QFETCH(QString, html);
+ QFETCH(QString, expectedPlainText);
+
+ setHtml(html);
+
+ QCOMPARE(doc->toPlainText(), expectedPlainText);
+}
+
+void tst_QTextDocumentFragment::html_qt3Whitespace()
+{
+ QString text = "This text has some whitespace"
+ "\n and \nnewlines that \n should be ignored\n\n";
+ const QString html = QString("<html><head><meta name=\"qrichtext\" content=\"1\" /></head><body>")
+ + text
+ + QString("</body></html>");
+
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(html));
+
+ text.remove(QChar::fromLatin1('\n'));
+
+ QCOMPARE(doc->toPlainText(), text);
+}
+
+void tst_QTextDocumentFragment::html_qt3WhitespaceWithFragments()
+{
+ QString text = "This text has some whitespace"
+ "\n and \nnewlines that \n should be ignored\n\n";
+ const QString html = QString("<html><head><meta name=\"qrichtext\" content=\"1\" /></head><body>"
+ "blah blah<!--StartFragment--><span>")
+ + text
+ + QString("</span><!--EndFragment--></body></html>");
+
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(html));
+
+ text.remove(QChar::fromLatin1('\n'));
+
+ QCOMPARE(doc->toPlainText(), text);
+}
+
+void tst_QTextDocumentFragment::html_qt3WhitespaceAfterTags()
+{
+ QString text = " This text has some whitespace ";
+ const QString html = QString("<html><head><meta name=\"qrichtext\" content=\"1\" /></head><body><span>")
+ + text
+ + QString("</span></body></html>");
+
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(html));
+
+ QCOMPARE(doc->toPlainText(), text);
+}
+
+void tst_QTextDocumentFragment::html_listStart1()
+{
+ // don't create a block for the <ul> element, even if there's some whitespace between
+ // it and the <li>
+ const char html[] = "<ul> <li>list item</li><ul>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QByteArray::fromRawData(html, sizeof(html) / sizeof(html[0]))));
+
+ QCOMPARE(doc->blockCount(), 1);
+}
+
+void tst_QTextDocumentFragment::html_listStart2()
+{
+ // unlike with html_listStart1 we want a block showing the 'buggy' text here
+ const char html[] = "<ul>buggy, but text should appear<li>list item</li><ul>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QByteArray::fromRawData(html, sizeof(html) / sizeof(html[0]))));
+
+ QCOMPARE(doc->blockCount(), 2);
+}
+
+void tst_QTextDocumentFragment::html_cssMargin()
+{
+ const char html[] = "<p style=\"margin-top: 1px; margin-bottom: 2px; margin-left: 3px; margin-right: 4px\">Test</p>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(html));
+ const QTextBlockFormat fmt = cursor.blockFormat();
+ QCOMPARE(fmt.topMargin(), qreal(1));
+ QCOMPARE(fmt.bottomMargin(), qreal(2));
+ QCOMPARE(fmt.leftMargin(), qreal(3));
+ QCOMPARE(fmt.rightMargin(), qreal(4));
+}
+
+void tst_QTextDocumentFragment::html_hexEntities()
+{
+ const char html[] = "@";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(html));
+ QCOMPARE(doc->begin().begin().fragment().text(), QString("@"));
+}
+
+void tst_QTextDocumentFragment::html_decEntities()
+{
+ const char html[] = "@";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(html));
+ QCOMPARE(doc->begin().begin().fragment().text(), QString("@"));
+}
+
+void tst_QTextDocumentFragment::html_thCentered()
+{
+ const char html[] = "<table><tr><th>This should be centered</th></tr></table>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(html));
+
+ cursor.movePosition(QTextCursor::PreviousBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+
+ QVERIFY(table->cellAt(0, 0).begin().currentBlock().blockFormat().alignment() == Qt::AlignCenter);
+}
+
+void tst_QTextDocumentFragment::orderedListNumbering()
+{
+ // Supporter issue 45941 - make sure _two_ separate lists
+ // are imported, which have their own numbering
+ const char html[] = "<html><body>"
+ "<ol><li>elem 1</li></ol>"
+ "<ol><li>elem 1</li></ol>"
+ "</body></html>";
+
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(html));
+
+ int numberOfLists = 0;
+
+ cursor.movePosition(QTextCursor::Start);
+ QTextList *lastList = 0;
+ do {
+ QTextList *list = cursor.currentList();
+ if (list && list != lastList) {
+ lastList = list;
+ ++numberOfLists;
+ }
+ } while (cursor.movePosition(QTextCursor::NextBlock));
+
+ QCOMPARE(numberOfLists, 2);
+}
+
+void tst_QTextDocumentFragment::html_blockAfterList()
+{
+ const char html[] = "<ul><li>Foo</ul>This should be a separate paragraph and not be indented at the same level as Foo";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(html));
+
+ cursor.movePosition(QTextCursor::Start);
+
+ QVERIFY(cursor.currentList());
+ QCOMPARE(cursor.currentList()->format().indent(), 1);
+
+ QVERIFY(cursor.movePosition(QTextCursor::NextBlock));
+ QVERIFY(!cursor.currentList());
+ QCOMPARE(cursor.blockFormat().indent(), 0);
+}
+
+void tst_QTextDocumentFragment::html_subAndSuperScript()
+{
+ const char subHtml[] = "<sub>Subby</sub>";
+ const char superHtml[] = "<sup>Super</sup>";
+ const char subHtmlCss[] = "<span style=\"vertical-align: sub\">Subby</span>";
+ const char superHtmlCss[] = "<span style=\"vertical-align: super\">Super</span>";
+ const char alignmentInherited[] = "<sub><font face=\"Verdana\">Subby</font></sub>";
+
+ setHtml(subHtml);
+ QVERIFY(cursor.charFormat().verticalAlignment() == QTextCharFormat::AlignSubScript);
+
+ setHtml(subHtmlCss);
+ QVERIFY(cursor.charFormat().verticalAlignment() == QTextCharFormat::AlignSubScript);
+
+ setHtml(superHtml);
+ QVERIFY(cursor.charFormat().verticalAlignment() == QTextCharFormat::AlignSuperScript);
+
+ setHtml(superHtmlCss);
+ QVERIFY(cursor.charFormat().verticalAlignment() == QTextCharFormat::AlignSuperScript);
+
+ setHtml(alignmentInherited);
+ QVERIFY(cursor.charFormat().verticalAlignment() == QTextCharFormat::AlignSubScript);
+}
+
+void tst_QTextDocumentFragment::html_cssColors()
+{
+ const char color[] = "<span style=\"color:red\"><span style=\"color:blue\">Blue</span></span>";
+ setHtml(color);
+ QVERIFY(cursor.charFormat().foreground().color() == Qt::blue);
+
+ const char rgbColor[] = "<span style=\"color:red\"><span style=\"color:rgb(0, 0, 255)\">Blue</span></span>";
+ setHtml(rgbColor);
+ QVERIFY(cursor.charFormat().foreground().color() == Qt::blue);
+}
+
+void tst_QTextDocumentFragment::obeyFragmentMarkersInImport()
+{
+ const char html[] = "This leading text should not appear<!--StartFragment--><span>Text</span><!--EndFragment-->This text at the end should not appear";
+ setHtml(html);
+
+ QCOMPARE(doc->toPlainText(), QString("Text"));
+}
+
+void tst_QTextDocumentFragment::whitespaceWithFragmentMarkers()
+{
+ QString text(" text with leading and trailing whitespace ");
+ const char html[] = "This leading text should not appear<!--StartFragment-->%1<!--EndFragment-->This text at the end should not appear";
+ setHtml(QString::fromLatin1(html).arg(text));
+
+ QString expected("text with leading and trailing whitespace ");
+ QCOMPARE(doc->toPlainText(), expected);
+}
+
+void tst_QTextDocumentFragment::html_emptyParapgraphs1()
+{
+ const char html[] = "<p style=\"-qt-paragraph-type:empty;\"> </p><p>Two paragraphs</p>";
+ setHtml(html);
+
+ QCOMPARE(doc->blockCount(), 2);
+ QVERIFY(doc->begin().text().isEmpty());
+ QCOMPARE(doc->begin().next().text(), QString("Two paragraphs"));
+}
+
+void tst_QTextDocumentFragment::html_emptyParapgraphs2()
+{
+ const char html[] = "<p style=\"margin-left:80px\"></p><p>One paragraph</p>";
+ setHtml(html);
+
+ QCOMPARE(doc->blockCount(), 1);
+ QCOMPARE(cursor.blockFormat().leftMargin(), qreal(0));
+
+ const char html2[] = "<p style=\"margin-left:80px\"></p>One paragraph";
+ setHtml(html2);
+ QCOMPARE(doc->blockCount(), 1);
+ QCOMPARE(cursor.blockFormat().leftMargin(), qreal(0));
+
+ const char html3[] = "<p style=\"margin-left:80px\">Foo</p><p></p>Two paragraphs";
+ setHtml(html3);
+ QCOMPARE(doc->blockCount(), 2);
+ cursor = QTextCursor(doc);
+ QCOMPARE(cursor.blockFormat().leftMargin(), qreal(80));
+ QCOMPARE(cursor.block().next().blockFormat().leftMargin(), qreal(0));
+}
+
+void tst_QTextDocumentFragment::html_emptyParagraphs3()
+{
+ const char html[] = "<ul><p>Foo</p><p></p></ul><h4>Bar</h4>";
+
+ setHtml(html);
+
+ QCOMPARE(doc->blockCount(), 2);
+
+ cursor = QTextCursor(doc);
+ QCOMPARE(cursor.block().next().blockFormat().indent(), 0);
+}
+
+void tst_QTextDocumentFragment::html_emptyParagraphs4()
+{
+ const char html[] = "<p>foo</p><p style=\"page-break-before: always\"></p><p>bar</p>";
+ setHtml(html);
+
+ QTextBlock block = doc->begin();
+ QVERIFY(block.isValid());
+ QCOMPARE(block.text(), QString("foo"));
+ block = block.next();
+ QVERIFY(block.isValid());
+ QTextBlockFormat bf = block.blockFormat();
+ QVERIFY(bf.hasProperty(QTextFormat::PageBreakPolicy));
+ QCOMPARE(bf.pageBreakPolicy(), QTextFormat::PageBreak_AlwaysBefore);
+ QCOMPARE(block.text(), QString("bar"));
+
+ const char html2[] = "<p>foo</p><p style=\"page-break-after: always\"></p><p>bar</p>";
+ setHtml(html2);
+
+ block = doc->begin();
+ QVERIFY(block.isValid());
+ QCOMPARE(block.text(), QString("foo"));
+ block = block.next();
+ QVERIFY(block.isValid());
+ bf = block.blockFormat();
+ QVERIFY(bf.hasProperty(QTextFormat::PageBreakPolicy));
+ QCOMPARE(bf.pageBreakPolicy(), QTextFormat::PageBreak_AlwaysBefore); // after the empty line means it should appear for 'bar'
+ QCOMPARE(block.text(), QString("bar"));
+}
+
+void tst_QTextDocumentFragment::html_font()
+{
+ const char html[] = "<font color=\"blue\"><p>Hah</p></font>";
+ setHtml(html);
+
+ QVERIFY(cursor.charFormat().foreground().color() == Qt::blue);
+ QVERIFY(cursor.blockCharFormat().foreground().color() == Qt::blue);
+}
+
+void tst_QTextDocumentFragment::html_fontSize()
+{
+ const char html[] = "<font size=\"2\">Hah</font>";
+ setHtml(html);
+
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontSizeAdjustment).toInt(), -1);
+}
+
+void tst_QTextDocumentFragment::html_fontSizeAdjustment()
+{
+ const char html[] = "<font size=\"7\"><b>Hah</b></font>";
+ setHtml(html);
+
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontSizeAdjustment).toInt(), 4);
+ QCOMPARE(cursor.charFormat().fontWeight(), int(QFont::Bold));
+}
+
+void tst_QTextDocumentFragment::html_cssFontSize()
+{
+ const char html[] = "<span style=\"font-size: 50pt\">Foo</span>";
+ setHtml(html);
+
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontPointSize).toInt(), 50);
+
+ const char html2[] = "<span style=\"font-size: 50px\">Foo</span>";
+ setHtml(html2);
+
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontPixelSize).toInt(), 50);
+
+ const char html3[] = "<span style=\"font-size: large\">Foo</span>";
+ setHtml(html3);
+
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontSizeAdjustment).toInt(), 1);
+}
+
+void tst_QTextDocumentFragment::html_cssShorthandFont()
+{
+ {
+ const char html[] = "<span style=\"font: 50px sans-serif\">Foo</span>";
+ setHtml(html);
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontPixelSize).toInt(), 50);
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontFamily).toString(), QString("sans-serif"));
+ }
+ {
+ const char html[] = "<span style=\"font: 50pt sans-serif\">Foo</span>";
+ setHtml(html);
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontPointSize).toInt(), 50);
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontFamily).toString(), QString("sans-serif"));
+ }
+ {
+ const char html[] = "<span style='font:7.0pt \"Times New Roman\"'>Foo</span>";
+ setHtml(html);
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontPointSize).toInt(), 7);
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontFamily).toString(), QString("Times New Roman"));
+ }
+ {
+ const char html[] = "<span style='font:bold 7.0pt'>Foo</span>";
+ setHtml(html);
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontWeight).toInt(), int(QFont::Bold));
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontPointSize).toInt(), 7);
+ }
+ {
+ const char html[] = "<span style='font:bold italic 7.0pt'>Foo</span>";
+ setHtml(html);
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontWeight).toInt(), int(QFont::Bold));
+ QCOMPARE(cursor.charFormat().property(QTextFormat::FontItalic).toBool(), true);
+ }
+}
+
+void tst_QTextDocumentFragment::html_bodyBgColor()
+{
+ const char html[] = "<body bgcolor=\"blue\">Foo</body>";
+ doc->setHtml(html);
+
+ QVERIFY(doc->rootFrame()->frameFormat().background().color() == Qt::blue);
+}
+
+void tst_QTextDocumentFragment::html_qtBgColor()
+{
+ const char html[] = "<qt bgcolor=\"blue\">Foo</qt>";
+ doc->setHtml(html);
+
+ QVERIFY(doc->rootFrame()->frameFormat().background().color() == Qt::blue);
+}
+
+void tst_QTextDocumentFragment::html_bodyBackground()
+{
+ const char html[] = "<body background=\"foo.png\">Foo</body>";
+ doc->setHtml(html);
+
+ QVERIFY(doc->rootFrame()->frameFormat().background().style() == Qt::TexturePattern);
+}
+
+void tst_QTextDocumentFragment::html_tableCellBackground()
+{
+ const char html[] = "<body><table><tr><td background=\"foo.png\">Foo</td></tr></table></body>";
+ doc->setHtml(html);
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+
+ QTextTableCell cell = table->cellAt(0, 0);
+ QVERIFY(cell.format().background().style() == Qt::TexturePattern);
+}
+
+void tst_QTextDocumentFragment::css_bodyBackground()
+{
+ const char html[] = "<body style=\"background-image:url('foo.png')\">Foo</body>";
+ doc->setHtml(html);
+
+ QVERIFY(doc->rootFrame()->frameFormat().background().style() == Qt::TexturePattern);
+}
+
+void tst_QTextDocumentFragment::css_tableCellBackground()
+{
+ const char html[] = "<body><table><tr><td style=\"background-image:url('foo.png')\">Foo</td></tr></table></body>";
+ doc->setHtml(html);
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+
+ QTextTableCell cell = table->cellAt(0, 0);
+ QVERIFY(cell.format().background().style() == Qt::TexturePattern);
+}
+
+void tst_QTextDocumentFragment::css_cellPaddings()
+{
+ const char html[] = "<body><table><tr><td style=\"padding-left:1\">Foo</td>"
+ "<td style=\"padding-right:1\"></td><td style=\"padding-top:10\"></td>"
+ "<td style=\"padding-bottom:5\"></td><td style=\"padding:15\"></td></tr></table></body>";
+ doc->setHtml(html);
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+
+ QTextTableCell cell = table->cellAt(0, 0);
+ QCOMPARE(cell.format().toTableCellFormat().leftPadding(), qreal(1));
+ cell = table->cellAt(0, 1);
+ QCOMPARE(cell.format().toTableCellFormat().rightPadding(), qreal(1));
+ cell = table->cellAt(0, 2);
+ QCOMPARE(cell.format().toTableCellFormat().topPadding(), qreal(10));
+ cell = table->cellAt(0, 3);
+ QCOMPARE(cell.format().toTableCellFormat().bottomPadding(), qreal(5));
+ cell = table->cellAt(0, 4);
+ QCOMPARE(cell.format().toTableCellFormat().leftPadding(), qreal(15));
+ QCOMPARE(cell.format().toTableCellFormat().rightPadding(), qreal(15));
+ QCOMPARE(cell.format().toTableCellFormat().topPadding(), qreal(15));
+ QCOMPARE(cell.format().toTableCellFormat().bottomPadding(), qreal(15));
+}
+
+void tst_QTextDocumentFragment::html_blockLevelDiv()
+{
+ const char html[] = "<div align=right><b>Hello World";
+ setHtml(html);
+
+ QCOMPARE(doc->begin().blockFormat().alignment(), Qt::AlignRight|Qt::AlignAbsolute);
+ QVERIFY(doc->begin().next() == doc->end());
+}
+
+void tst_QTextDocumentFragment::html_spanNesting()
+{
+ const char html[] = "<span style=\"color:black\">a<span style=\"color:red\">b<span style=\"color:black\">c</span></span>d</span>";
+ setHtml(html);
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().foreground() == Qt::black);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().foreground() == Qt::red);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().foreground() == Qt::black);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().foreground() == Qt::black);
+}
+
+void tst_QTextDocumentFragment::html_nestedLists()
+{
+ const char html[] = "<p><ul><li>Foo<ul><li>In nested list</li></ul></li><li>Last item</li></ul></p>";
+ setHtml(html);
+
+ cursor.movePosition(QTextCursor::Start);
+ QTextList *firstList = cursor.currentList();
+ QVERIFY(firstList);
+ QCOMPARE(firstList->format().indent(), 1);
+
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextList *secondList = cursor.currentList();
+ QVERIFY(secondList);
+ QVERIFY(secondList != firstList);
+ QCOMPARE(cursor.currentList()->format().indent(), 2);
+
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextList *thirdList = cursor.currentList();
+ QVERIFY(thirdList);
+ QVERIFY(thirdList == firstList);
+}
+
+void tst_QTextDocumentFragment::noSpecialCharactersInPlainText()
+{
+ cursor.insertTable(2, 2);
+ cursor.insertBlock();
+ cursor.insertText(QString(QChar::LineSeparator));
+ cursor.insertText(QString(QChar::Nbsp));
+
+ QString plain = doc->toPlainText();
+ QVERIFY(!plain.contains(QChar::ParagraphSeparator));
+ QVERIFY(!plain.contains(QChar::Nbsp));
+ QVERIFY(!plain.contains(QTextBeginningOfFrame));
+ QVERIFY(!plain.contains(QTextEndOfFrame));
+ QVERIFY(!plain.contains(QChar::LineSeparator));
+
+ plain = QTextDocumentFragment(doc).toPlainText();
+ QVERIFY(!plain.contains(QChar::ParagraphSeparator));
+ QVERIFY(!plain.contains(QChar::Nbsp));
+ QVERIFY(!plain.contains(QTextBeginningOfFrame));
+ QVERIFY(!plain.contains(QTextEndOfFrame));
+ QVERIFY(!plain.contains(QChar::LineSeparator));
+}
+
+void tst_QTextDocumentFragment::html_doNotInheritBackground()
+{
+ const char html[] = "<html><body bgcolor=\"blue\"><p>Blah</p></body></html>";
+ doc->setHtml(html);
+
+ for (QTextBlock block = doc->begin();
+ block.isValid(); block = block.next()) {
+ QVERIFY(block.blockFormat().hasProperty(QTextFormat::BackgroundBrush) == false);
+ }
+
+ QVERIFY(doc->rootFrame()->frameFormat().hasProperty(QTextFormat::BackgroundBrush));
+ QVERIFY(doc->rootFrame()->frameFormat().background().color() == Qt::blue);
+}
+
+void tst_QTextDocumentFragment::html_inheritBackgroundToInlineElements()
+{
+ const char html[] = "<span style=\"background: blue\">Foo<span>Bar</span></span>";
+ doc->setHtml(html);
+
+ int fragmentCount = 0;
+
+ QTextBlock block = doc->begin();
+ for (QTextBlock::Iterator it = block.begin();
+ !it.atEnd(); ++it, ++fragmentCount) {
+
+ const QTextFragment fragment = it.fragment();
+ if (fragmentCount == 0) {
+ QCOMPARE(fragment.text(), QString("FooBar"));
+ QVERIFY(fragment.charFormat().background().color() == Qt::blue);
+ }
+ }
+
+ QCOMPARE(fragmentCount, 1);
+}
+
+void tst_QTextDocumentFragment::html_doNotInheritBackgroundFromBlockElements()
+{
+ const char html[] = "<p style=\"background: blue\"><span>Foo</span></span>";
+ doc->setHtml(html);
+
+ int fragmentCount = 0;
+
+ QTextBlock block = doc->begin();
+ for (QTextBlock::Iterator it = block.begin();
+ !it.atEnd(); ++it, ++fragmentCount) {
+
+ const QTextFragment fragment = it.fragment();
+ if (fragmentCount == 0) {
+ QCOMPARE(fragment.text(), QString("Foo"));
+ QVERIFY(!fragment.charFormat().hasProperty(QTextFormat::BackgroundBrush));
+ }
+ }
+
+ QCOMPARE(fragmentCount, 1);
+}
+void tst_QTextDocumentFragment::html_nobr()
+{
+ const QString input = "Blah Foo Bar";
+ const QString html = QString::fromLatin1("<html><body><p><nobr>") + input + QString::fromLatin1("</nobr></p></body></html>");
+ setHtml(html);
+
+ QString text = doc->begin().begin().fragment().text();
+ QString expectedText = input;
+ expectedText.replace(QRegExp("\\s+"), QString(QChar::Nbsp));
+ QCOMPARE(text, expectedText);
+}
+
+void tst_QTextDocumentFragment::fromPlainText()
+{
+ QString plainText;
+ plainText = "Hello\nWorld\r\nBlub";
+ plainText += QChar::ParagraphSeparator;
+ // TextEdit on OS 10 gives us OS 9 style linefeeds
+ // when copy & pasteing multi-line plaintext.
+ plainText += "OS9IsOldSchool\r";
+ plainText += "Last Parag";
+
+ doc->setPlainText(plainText);
+
+ int blockCount = 0;
+ for (QTextBlock block = doc->begin(); block.isValid(); block = block.next()) {
+ QVERIFY(!block.text().contains(QLatin1Char('\n')));
+ QVERIFY(!block.text().contains(QLatin1Char('\r')));
+ QVERIFY(!block.text().contains(QChar::ParagraphSeparator));
+
+ if (blockCount == 0)
+ QCOMPARE(block.text(), QString("Hello"));
+ else if (blockCount == 1)
+ QCOMPARE(block.text(), QString("World"));
+ else if (blockCount == 2)
+ QCOMPARE(block.text(), QString("Blub"));
+ else if (blockCount == 3)
+ QCOMPARE(block.text(), QString("OS9IsOldSchool"));
+ else if (blockCount == 4)
+ QCOMPARE(block.text(), QString("Last Parag"));
+
+
+ ++blockCount;
+ }
+
+ QCOMPARE(blockCount, 5);
+}
+
+void tst_QTextDocumentFragment::fromPlainText2()
+{
+ doc->setPlainText("Hello World");
+ QCOMPARE(QTextDocumentFragment(doc).toPlainText(), doc->toPlainText());
+}
+
+void tst_QTextDocumentFragment::html_closingImageTag()
+{
+ const char html[] = "<span style=\"font-size: 10pt\"><span style=\"font-size: 40pt\">Blah<img src=\"blah\"></img>Foo</span></span>";
+ setHtml(html);
+
+ int fragmentCount = 0;
+
+ QTextBlock block = doc->begin();
+ for (QTextBlock::Iterator it = block.begin();
+ !it.atEnd(); ++it, ++fragmentCount) {
+
+ const QTextFragment fragment = it.fragment();
+ if (fragmentCount == 0) {
+ QCOMPARE(fragment.text(), QString("Blah"));
+ QCOMPARE(fragment.charFormat().fontPointSize(), qreal(40));
+ } else if (fragmentCount == 1) {
+ QCOMPARE(fragment.text(), QString(QChar::ObjectReplacementCharacter));
+ } else if (fragmentCount == 2) {
+ QCOMPARE(fragment.text(), QString("Foo"));
+ QCOMPARE(fragment.charFormat().fontPointSize(), qreal(40));
+ }
+ }
+
+ QCOMPARE(fragmentCount, 3);
+}
+
+void tst_QTextDocumentFragment::html_emptyDocument()
+{
+ const char html[] = "<html><body><p style=\"-qt-paragraph-type:empty;\"></p></body></html>";
+ setHtml(html);
+ QCOMPARE(doc->blockCount(), 1);
+}
+
+void tst_QTextDocumentFragment::html_closingTag()
+{
+ const char html[] = "<i />text";
+ setHtml(html);
+
+ QVERIFY(!cursor.charFormat().fontItalic());
+}
+
+void tst_QTextDocumentFragment::html_anchorAroundImage()
+{
+ const char html[] = "<a href=\"http://www.troll.no\"><img src=test.png></a>";
+ setHtml(html);
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QTextImageFormat fmt = cursor.charFormat().toImageFormat();
+ QCOMPARE(fmt.name(), QString("test.png"));
+ QVERIFY(fmt.isAnchor());
+ QCOMPARE(fmt.anchorHref(), QString("http://www.troll.no"));
+}
+
+void tst_QTextDocumentFragment::html_floatBorder()
+{
+ const char html[] = "<table border=1.2><tr><td>Foo";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QString::fromLatin1(html)));
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QVERIFY(cursor.currentTable());
+ QCOMPARE(cursor.currentTable()->format().border(), qreal(1.2));
+}
+
+void tst_QTextDocumentFragment::html_frameImport()
+{
+ QTextFrameFormat ffmt;
+ ffmt.setBorder(1);
+ ffmt.setPosition(QTextFrameFormat::FloatRight);
+ ffmt.setMargin(2);
+ ffmt.setWidth(100);
+ ffmt.setHeight(50);
+ ffmt.setBackground(QColor("#00ff00"));
+ cursor.insertFrame(ffmt);
+ cursor.insertText("Hello World");
+
+ QTextDocumentFragment frag(doc);
+ cleanup();
+ init();
+ frag = QTextDocumentFragment::fromHtml(frag.toHtml());
+ cursor.insertFragment(frag);
+
+ QList<QTextFrame *> childFrames = doc->rootFrame()->childFrames();
+ QVERIFY(childFrames.count() == 1);
+ QTextFrame *frame = childFrames.first();
+ QCOMPARE(frame->frameFormat().margin(), ffmt.margin());
+ QCOMPARE(frame->frameFormat().border(), ffmt.border());
+}
+
+void tst_QTextDocumentFragment::html_frameImport2()
+{
+ QTextFrameFormat ffmt;
+ ffmt.setBorder(1);
+ ffmt.setPosition(QTextFrameFormat::FloatRight);
+ ffmt.setLeftMargin(200);
+ ffmt.setTopMargin(100);
+ ffmt.setBottomMargin(50);
+ ffmt.setRightMargin(250);
+ ffmt.setWidth(100);
+ ffmt.setHeight(50);
+ ffmt.setBackground(QColor("#00ff00"));
+ cursor.insertFrame(ffmt);
+ cursor.insertText("Hello World");
+
+ QTextDocumentFragment frag(doc);
+ cleanup();
+ init();
+ frag = QTextDocumentFragment::fromHtml(frag.toHtml());
+ cursor.insertFragment(frag);
+
+ QList<QTextFrame *> childFrames = doc->rootFrame()->childFrames();
+ QVERIFY(childFrames.count() == 1);
+ QTextFrame *frame = childFrames.first();
+ QCOMPARE(frame->frameFormat().topMargin(), ffmt.topMargin());
+ QCOMPARE(frame->frameFormat().bottomMargin(), ffmt.bottomMargin());
+ QCOMPARE(frame->frameFormat().leftMargin(), ffmt.leftMargin());
+ QCOMPARE(frame->frameFormat().rightMargin(), ffmt.rightMargin());
+ QCOMPARE(frame->frameFormat().border(), ffmt.border());
+}
+
+void tst_QTextDocumentFragment::html_dontAddMarginsAcrossTableCells()
+{
+ const char html[] = "<table style=\"margin-left: 100px;\"><tr><td><p style=\"margin-left:50px;\">Foo</p></td></tr></table>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QString::fromLatin1(html)));
+
+ QList<QTextFrame *> childFrames = doc->rootFrame()->childFrames();
+ QVERIFY(childFrames.count() == 1);
+ QTextFrame *frame = childFrames.first();
+ cursor = frame->firstCursorPosition();
+ QCOMPARE(cursor.blockFormat().leftMargin(), qreal(50.0));
+}
+
+void tst_QTextDocumentFragment::html_dontMergeCenterBlocks()
+{
+ const char html[] = "<center>This should be centered</center>And this should not be centered anymore";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QString::fromLatin1(html)));
+
+ QCOMPARE(doc->blockCount(), 2);
+ QTextBlock blk = doc->begin();
+ QVERIFY(blk.blockFormat().alignment() == Qt::AlignCenter);
+ blk = blk.next();
+ QVERIFY(blk.blockFormat().alignment() != Qt::AlignCenter);
+}
+
+void tst_QTextDocumentFragment::html_tableCellBgColor()
+{
+ const char html[] = "<table><tr><td bgcolor=\"blue\">Test<p>Second Parag</p></td></tr></table>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QString::fromLatin1(html)));
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+
+ QTextTableCell cell = table->cellAt(0, 0);
+ QVERIFY(cell.format().background().color() == Qt::blue);
+}
+
+void tst_QTextDocumentFragment::html_tableCellBgColor2()
+{
+ const char html[] = "<table><tr><td bgcolor=\"blue\"><table><tr><td>Blah</td></tr></table></td></tr></table>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QString::fromLatin1(html)));
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+
+ QTextTableCell cell = table->cellAt(0, 0);
+ QVERIFY(cell.format().background().color() == Qt::blue);
+
+ QTextFrame::Iterator it = cell.begin();
+ QVERIFY(!it.atEnd());
+ QVERIFY(it.currentFrame() == 0);
+ QVERIFY(it.currentBlock().isValid());
+
+ ++it;
+ QVERIFY(!it.atEnd());
+ QVERIFY(it.currentFrame() != 0);
+ QVERIFY(!it.currentBlock().isValid());
+
+ ++it;
+ QVERIFY(!it.atEnd());
+ QVERIFY(it.currentFrame() == 0);
+ QVERIFY(it.currentBlock().isValid());
+ QVERIFY(it.currentBlock().blockFormat().background() == QBrush(Qt::NoBrush));
+
+ ++it;
+ QVERIFY(it.atEnd());
+}
+
+void tst_QTextDocumentFragment::html_cellSkip()
+{
+ const char html[] = ""
+"<table border>"
+" <tr>"
+" <td>First Cell</td>"
+" </tr>"
+" <tr>"
+" <td>Second Cell</td>"
+" <td>Third Cell</td>"
+" </tr>"
+"</table>";
+
+ setHtml(html);
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QVERIFY(table->columns() == 2 && table->rows() == 2);
+
+ QCOMPARE(table->cellAt(0, 0).firstCursorPosition().block().text(), QString("First Cell"));
+ QVERIFY(table->cellAt(0, 1).firstCursorPosition().block().text().isEmpty());
+ QCOMPARE(table->cellAt(1, 0).firstCursorPosition().block().text(), QString("Second Cell"));
+ QCOMPARE(table->cellAt(1, 1).firstCursorPosition().block().text(), QString("Third Cell"));
+}
+
+void tst_QTextDocumentFragment::nonZeroMarginOnImport()
+{
+ // specify bgcolor so that the html import creates a root frame format
+ setHtml("<html><body bgcolor=\"#00ff00\"><b>Hello World</b></body></html>");
+ QVERIFY(doc->rootFrame()->frameFormat().margin() > 0.0);
+}
+
+void tst_QTextDocumentFragment::html_charFormatPropertiesUnset()
+{
+ setHtml("Hello World");
+ QVERIFY(doc->begin().begin().fragment().charFormat().properties().isEmpty());
+}
+
+void tst_QTextDocumentFragment::html_headings()
+{
+ setHtml("<h1>foo</h1>bar");
+ QCOMPARE(doc->blockCount(), 2);
+}
+
+void tst_QTextDocumentFragment::html_quotedFontFamily()
+{
+ setHtml("<div style=\"font-family: 'Foo Bar';\">Test</div>");
+ QCOMPARE(doc->begin().begin().fragment().charFormat().fontFamily(), QString("Foo Bar"));
+
+ setHtml("<div style='font-family: \"Foo Bar\";'>Test</div>");
+ QCOMPARE(doc->begin().begin().fragment().charFormat().fontFamily(), QString("Foo Bar"));
+}
+
+void tst_QTextDocumentFragment::defaultFont()
+{
+ QFont f;
+ f.setFamily("Courier New");
+ f.setBold(true);
+ f.setItalic(true);
+ f.setStrikeOut(true); // set here but deliberately ignored for the html export
+ f.setPointSize(100);
+ doc->setDefaultFont(f);
+ doc->setPlainText("Hello World");
+ const QString html = doc->toHtml();
+ QLatin1String str("<body style=\" font-family:'Courier New'; font-size:100pt; font-weight:600; font-style:italic;\">");
+ QVERIFY(html.contains(str));
+}
+
+void tst_QTextDocumentFragment::html_spanBackgroundColor()
+{
+ setHtml("<span style=\"background-color: blue\">Foo</span>");
+ QVERIFY(doc->begin().begin().fragment().charFormat().background().color() == QColor(Qt::blue));
+}
+
+void tst_QTextDocumentFragment::html_brokenTitle_data()
+{
+ QTest::addColumn<QString>("html");
+ QTest::addColumn<QString>("expectedBody");
+ QTest::addColumn<QString>("expectedTitle");
+
+ QTest::newRow("brokentitle") << QString("<html><head><title>Foo<b>bar</b></title></head><body>Blah</body></html>")
+ << QString("Blah") << QString("Foo");
+ QTest::newRow("brokentitle2") << QString("<html><head><title>Foo<font color=red>i</font>t<font color=red>i</font>Blub</title></head><body>Blah</body></html>")
+ << QString("Blah") << QString("Foo");
+ QTest::newRow("entities") << QString("<html><head><title>Foo<bar</title></head><body>Blah</body></html>")
+ << QString("Blah") << QString("Foo<bar");
+ QTest::newRow("unclosedtitle") << QString("<html><head><title>Foo</head><body>Blah</body></html>")
+ << QString("Blah") << QString("Foo");
+}
+
+void tst_QTextDocumentFragment::html_brokenTitle()
+{
+ QFETCH(QString, html);
+ QFETCH(QString, expectedBody);
+ QFETCH(QString, expectedTitle);
+ doc->setHtml(html);
+ QCOMPARE(doc->toPlainText(), expectedBody);
+ QCOMPARE(doc->metaInformation(QTextDocument::DocumentTitle), expectedTitle);
+}
+
+void tst_QTextDocumentFragment::html_blockVsInline()
+{
+ {
+ setHtml("<html><body><div><b>Foo<div>Bar");
+ QVERIFY(cursor.charFormat().fontWeight() == QFont::Bold);
+ QVERIFY(cursor.blockCharFormat().fontWeight() == QFont::Bold);
+ }
+ {
+ setHtml("<html><body><p><b>Foo<p>Bar");
+ QVERIFY(cursor.charFormat().fontWeight() != QFont::Bold);
+ QVERIFY(cursor.blockCharFormat().fontWeight() != QFont::Bold);
+ }
+ {
+ setHtml("<html><body><b><center>Foo</center></b>");
+ QVERIFY(cursor.charFormat().fontWeight() == QFont::Bold);
+ QVERIFY(cursor.blockCharFormat().fontWeight() == QFont::Bold);
+ }
+ {
+ setHtml("<html><body><b><p>Foo");
+ QVERIFY(cursor.charFormat().fontWeight() == QFont::Bold);
+ QVERIFY(cursor.blockCharFormat().fontWeight() == QFont::Bold);
+ }
+ {
+ setHtml("<html><body><b><p>Foo<p>Bar");
+ QVERIFY(cursor.charFormat().fontWeight() == QFont::Bold);
+ QVERIFY(cursor.blockCharFormat().fontWeight() == QFont::Bold);
+ }
+ {
+ setHtml("<div><b>Foo<div>Bar");
+ QVERIFY(cursor.charFormat().fontWeight() == QFont::Bold);
+ QVERIFY(cursor.blockCharFormat().fontWeight() == QFont::Bold);
+ }
+ {
+ setHtml("<p><b>Foo<p>Bar");
+ QVERIFY(cursor.charFormat().fontWeight() != QFont::Bold);
+ QVERIFY(cursor.blockCharFormat().fontWeight() != QFont::Bold);
+ }
+ {
+ setHtml("<b><center>Foo</center></b>");
+ QVERIFY(cursor.charFormat().fontWeight() == QFont::Bold);
+ QVERIFY(cursor.blockCharFormat().fontWeight() == QFont::Bold);
+ }
+ {
+ setHtml("<b><p>Foo");
+ QVERIFY(cursor.charFormat().fontWeight() == QFont::Bold);
+ QVERIFY(cursor.blockCharFormat().fontWeight() == QFont::Bold);
+ }
+ {
+ setHtml("<b><p>Foo<p>Bar");
+ QVERIFY(cursor.charFormat().fontWeight() == QFont::Bold);
+ QVERIFY(cursor.blockCharFormat().fontWeight() == QFont::Bold);
+ }
+}
+
+void tst_QTextDocumentFragment::html_tbody()
+{
+ setHtml("<table><thead><tr><td>First Cell</td></tr></thead><tbody><tr><td>Second Cell</td></tr></tbody></table>");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->columns(), 1);
+ QCOMPARE(table->rows(), 2);
+ QCOMPARE(table->format().headerRowCount(), 1);
+ QCOMPARE(table->cellAt(0, 0).firstCursorPosition().block().text(), QString("First Cell"));
+ QCOMPARE(table->cellAt(1, 0).firstCursorPosition().block().text(), QString("Second Cell"));
+}
+
+void tst_QTextDocumentFragment::html_nestedTables()
+{
+ setHtml("<table>"
+ " <tr><td>"
+ ""
+ " <table>"
+ " <tr><td>Hello</td></tr>"
+ " </table>"
+ ""
+ " <table>"
+ " <tr><td>World</td></tr>"
+ " </table>"
+ ""
+ " </td></tr>"
+ "</table>"
+ );
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->rows(), 1);
+ QCOMPARE(table->columns(), 1);
+
+ cursor = table->cellAt(0, 0).firstCursorPosition();
+ cursor.movePosition(QTextCursor::NextBlock);
+
+ QTextTable *firstNestedTable = cursor.currentTable();
+ QVERIFY(firstNestedTable);
+ QVERIFY(firstNestedTable->parentFrame() == table);
+ QCOMPARE(firstNestedTable->rows(), 1);
+ QCOMPARE(firstNestedTable->columns(), 1);
+ QCOMPARE(firstNestedTable->cellAt(0, 0).firstCursorPosition().block().text(), QString("Hello"));
+
+ while (cursor.currentTable() == firstNestedTable
+ && cursor.movePosition(QTextCursor::NextBlock))
+ ;
+
+ QVERIFY(!cursor.isNull());
+ QVERIFY(cursor.currentTable() == table);
+
+ cursor.movePosition(QTextCursor::NextBlock);
+
+ QTextTable *secondNestedTable = cursor.currentTable();
+ QVERIFY(secondNestedTable);
+ QVERIFY(secondNestedTable->parentFrame() == table);
+ QCOMPARE(secondNestedTable->rows(), 1);
+ QCOMPARE(secondNestedTable->columns(), 1);
+ QCOMPARE(secondNestedTable->cellAt(0, 0).firstCursorPosition().block().text(), QString("World"));
+}
+
+void tst_QTextDocumentFragment::html_rowSpans()
+{
+ setHtml(""
+ "<table border=\"1\" width=\"100%\">"
+ " <tr>"
+ " <td rowspan=\"2\">blah</td>"
+ " <td rowspan=\"2\">foo</td>"
+ " </tr>"
+ " <tr></tr>"
+ " <tr>"
+ " <td rowspan=\"2\">blubb</td>"
+ " <td rowspan=\"2\">baz</td>"
+ " </tr>"
+ " <tr></tr>"
+ "</table>");
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->rows(), 4);
+ QCOMPARE(table->columns(), 2);
+
+ QCOMPARE(table->cellAt(0, 0).firstCursorPosition().block().text(), QString("blah"));
+ QCOMPARE(table->cellAt(0, 1).firstCursorPosition().block().text(), QString("foo"));
+
+ QCOMPARE(table->cellAt(1, 0).firstCursorPosition().block().text(), QString("blah"));
+ QCOMPARE(table->cellAt(1, 1).firstCursorPosition().block().text(), QString("foo"));
+
+ QCOMPARE(table->cellAt(2, 0).firstCursorPosition().block().text(), QString("blubb"));
+ QCOMPARE(table->cellAt(2, 1).firstCursorPosition().block().text(), QString("baz"));
+
+ QCOMPARE(table->cellAt(3, 0).firstCursorPosition().block().text(), QString("blubb"));
+ QCOMPARE(table->cellAt(3, 1).firstCursorPosition().block().text(), QString("baz"));
+}
+
+void tst_QTextDocumentFragment::html_rowSpans2()
+{
+ setHtml(""
+ "<html><body>"
+ "<table border=\"1\">"
+ "<tr>"
+ "<td>Row 1 col 1</td>"
+ "</tr>"
+ "<tr>"
+ "<td rowspan=\"3\">Row 2 col 1, rowspan 3</td>"
+ "<td>Row 2 col 2</td>"
+ "</tr>"
+ "<tr>"
+ "<td rowspan=\"2\">Row 3 col 2, rowspan 2</td>"
+ "</tr>"
+ "<tr>"
+ "</tr>"
+ "</table>"
+ "</body></html>");
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->rows(), 4);
+ QCOMPARE(table->columns(), 2);
+ QCOMPARE(table->cellAt(0, 1).rowSpan(), 1);
+ QCOMPARE(table->cellAt(1, 0).rowSpan(), 3);
+ QCOMPARE(table->cellAt(2, 1).rowSpan(), 2);
+}
+
+void tst_QTextDocumentFragment::html_implicitParagraphs()
+{
+ setHtml("<p>foo</p>bar");
+ QCOMPARE(doc->blockCount(), 2);
+}
+
+void tst_QTextDocumentFragment::html_missingCloseTag()
+{
+ setHtml("<font color=\"red\"><span style=\"color:blue\">blue</span></span> red</font>");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().foreground().color() == Qt::blue);
+ cursor.movePosition(QTextCursor::NextWord);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().foreground().color() == Qt::red);
+}
+
+void tst_QTextDocumentFragment::html_anchorColor()
+{
+ setHtml("<span style=\"color: red;\">Red</span>");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().foreground().color() == Qt::red);
+
+ setHtml("<span style=\"color: red;\"><a href=\"http://www.kde.org/\">Blue</a></span>");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().foreground().color() == QApplication::palette().link().color());
+
+ setHtml("<span style=\"color: red;\"><a href=\"http://www.kde.org/\" style=\"color: yellow;\">Green</a></span>");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().foreground().color() == Qt::yellow);
+}
+
+void tst_QTextDocumentFragment::html_lastParagraphClosing()
+{
+ setHtml("<p>Foo<b>Bar</b>Baz");
+ QCOMPARE(doc->blockCount(), 1);
+}
+
+void tst_QTextDocumentFragment::html_tableHeaderBodyFootParent()
+{
+ // don't get confused by strange tags, keep tbody/thead/tfoot children of
+ // the table tag
+ setHtml("<table><col><col><col><tbody><tr><td>Hey</td></tr></tbody></table>");
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->columns(), 1);
+ QCOMPARE(table->rows(), 1);
+ QCOMPARE(table->cellAt(0, 0).firstCursorPosition().block().text(), QString("Hey"));
+
+ setHtml("<table><col><col><col><thead><tr><td>Hey</td></tr></thead></table>");
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->columns(), 1);
+ QCOMPARE(table->rows(), 1);
+ QCOMPARE(table->cellAt(0, 0).firstCursorPosition().block().text(), QString("Hey"));
+
+ setHtml("<table><col><col><col><tfoot><tr><td>Hey</td></tr></tfoot></table>");
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->columns(), 1);
+ QCOMPARE(table->rows(), 1);
+ QCOMPARE(table->cellAt(0, 0).firstCursorPosition().block().text(), QString("Hey"));
+}
+
+void tst_QTextDocumentFragment::html_columnWidths()
+{
+ setHtml("<table>"
+ " <tr>"
+ " <td colspan=\"2\">Foo</td>"
+ " </tr>"
+ " <tr>"
+ " <td>Bar</td>"
+ " <td width=\"1%\">Baz</td>"
+ " </tr>"
+ "</table>");
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->columns(), 2);
+ QCOMPARE(table->rows(), 2);
+ QTextTableFormat fmt = table->format();
+
+ const QVector<QTextLength> columnWidths = fmt.columnWidthConstraints();
+ QCOMPARE(columnWidths.count(), 2);
+ QVERIFY(columnWidths.at(0).type() == QTextLength::VariableLength);
+ QVERIFY(columnWidths.at(1).type() == QTextLength::PercentageLength);
+ QVERIFY(columnWidths.at(1).rawValue() == 1);
+}
+
+void tst_QTextDocumentFragment::css_fontWeight()
+{
+ setHtml("<p style=\"font-weight:bold\">blah</p>");
+ QVERIFY(doc->begin().charFormat().fontWeight() == QFont::Bold);
+ setHtml("<p style=\"font-weight:600\">blah</p>");
+ QVERIFY(doc->begin().charFormat().fontWeight() == QFont::Bold);
+
+}
+
+void tst_QTextDocumentFragment::css_float()
+{
+ setHtml("<img src=\"foo\" style=\"float: right\">");
+ QTextCharFormat fmt = doc->begin().begin().fragment().charFormat();
+ QVERIFY(fmt.isImageFormat());
+ QTextObject *o = doc->objectForFormat(fmt);
+ QVERIFY(o);
+ QTextFormat f = o->format();
+ QVERIFY(f.isFrameFormat());
+ QVERIFY(f.toFrameFormat().position() == QTextFrameFormat::FloatRight);
+
+ setHtml("<img src=\"foo\" align=right>");
+ fmt = doc->begin().begin().fragment().charFormat();
+ QVERIFY(fmt.isImageFormat());
+ o = doc->objectForFormat(fmt);
+ QVERIFY(o);
+ f = o->format();
+ QVERIFY(f.isFrameFormat());
+ QVERIFY(f.toFrameFormat().position() == QTextFrameFormat::FloatRight);
+
+ setHtml("<img src=\"foo\" align=left>");
+ fmt = doc->begin().begin().fragment().charFormat();
+ QVERIFY(fmt.isImageFormat());
+ o = doc->objectForFormat(fmt);
+ QVERIFY(o);
+ f = o->format();
+ QVERIFY(f.isFrameFormat());
+ QVERIFY(f.toFrameFormat().position() == QTextFrameFormat::FloatLeft);
+}
+
+void tst_QTextDocumentFragment::css_textIndent()
+{
+ setHtml("<p style=\"text-indent: 42px\">foo</p>");
+ QTextBlockFormat fmt = doc->begin().blockFormat();
+ QCOMPARE(fmt.textIndent(), qreal(42));
+}
+
+void tst_QTextDocumentFragment::css_inline()
+{
+ setHtml(""
+ "<style>"
+ " p { background-color: green;}"
+ "</style>"
+ "<p>test</p>"
+ );
+ QTextBlockFormat fmt = doc->begin().blockFormat();
+ QVERIFY(fmt.background().color() == QColor("green"));
+}
+
+void tst_QTextDocumentFragment::css_external()
+{
+ doc->addResource(QTextDocument::StyleSheetResource, QUrl("test.css"), QString("p { background-color: green; }"));
+ doc->setHtml(""
+ "<link href=\"test.css\" type=\"text/css\" />"
+ "<p>test</p>"
+ );
+ QTextBlockFormat fmt = doc->begin().blockFormat();
+ QVERIFY(fmt.background().color() == QColor("green"));
+}
+
+void tst_QTextDocumentFragment::css_import()
+{
+ doc->addResource(QTextDocument::StyleSheetResource, QUrl("test.css"), QString("@import \"other.css\";"));
+ doc->addResource(QTextDocument::StyleSheetResource, QUrl("other.css"), QString("@import url(\"other2.css\");"));
+ doc->addResource(QTextDocument::StyleSheetResource, QUrl("other2.css"), QString("p { background-color: green; }"));
+ doc->setHtml(""
+ "<link href=\"test.css\" type=\"text/css\" />"
+ "<p>test</p>"
+ );
+ QTextBlockFormat fmt = doc->begin().blockFormat();
+ QVERIFY(fmt.background().color() == QColor("green"));
+
+ doc->setHtml(""
+ "<style>@import \"test.css\" screen;</style>"
+ "<p>test</p>"
+ );
+ fmt = doc->begin().blockFormat();
+ QVERIFY(fmt.background().color() == QColor("green"));
+}
+
+void tst_QTextDocumentFragment::css_selectors_data()
+{
+ QTest::addColumn<bool>("match");
+ QTest::addColumn<QString>("selector");
+ QTest::addColumn<QString>("attributes");
+
+ QTest::newRow("plain") << true << QString() << QString();
+
+ QTest::newRow("class") << true << QString(".foo") << QString("class=foo");
+ QTest::newRow("notclass") << false << QString(".foo") << QString("class=bar");
+
+ QTest::newRow("attrset") << true << QString("[justset]") << QString("justset");
+ QTest::newRow("notattrset") << false << QString("[justset]") << QString("otherattribute");
+
+ QTest::newRow("attrmatch") << true << QString("[foo=bar]") << QString("foo=bar");
+ QTest::newRow("noattrmatch") << false << QString("[foo=bar]") << QString("foo=xyz");
+
+ QTest::newRow("contains") << true << QString("[foo~=bar]") << QString("foo=\"baz bleh bar\"");
+ QTest::newRow("notcontains") << false << QString("[foo~=bar]") << QString("foo=\"test\"");
+
+ QTest::newRow("beingswith") << true << QString("[foo|=bar]") << QString("foo=\"bar-bleh\"");
+ QTest::newRow("notbeingswith") << false << QString("[foo|=bar]") << QString("foo=\"bleh-bar\"");
+
+ QTest::newRow("attr2") << true << QString("[bar=foo]") << QString("bleh=bar bar=foo");
+}
+
+void tst_QTextDocumentFragment::css_selectors()
+{
+ QFETCH(bool, match);
+ QFETCH(QString, selector);
+ QFETCH(QString, attributes);
+
+ QString html = QString(""
+ "<style>"
+ " p { background-color: green }"
+ " p%1 { background-color: red }"
+ "</style>"
+ "<p %2>test</p>"
+ ).arg(selector).arg(attributes);
+ setHtml(html);
+
+ QTextBlockFormat fmt = doc->begin().blockFormat();
+ if (match)
+ QVERIFY(fmt.background().color() == QColor("red"));
+ else
+ QVERIFY(fmt.background().color() == QColor("green"));
+}
+
+void tst_QTextDocumentFragment::css_nodeNameCaseInsensitivity()
+{
+ setHtml("<style>"
+ "P { background-color: green }"
+ "</style>"
+ "<p>test</p>");
+ QTextBlockFormat fmt = doc->begin().blockFormat();
+ QVERIFY(fmt.background().color() == QColor("green"));
+}
+
+void tst_QTextDocumentFragment::css_textUnderlineStyle_data()
+{
+ QTest::addColumn<QString>("styleName");
+ QTest::addColumn<int>("expectedStyle");
+
+ QTest::newRow("none") << QString("none") << int(QTextCharFormat::NoUnderline);
+ QTest::newRow("solid") << QString("solid") << int(QTextCharFormat::SingleUnderline);
+ QTest::newRow("dash") << QString("dashed") << int(QTextCharFormat::DashUnderline);
+ QTest::newRow("dot") << QString("dotted") << int(QTextCharFormat::DotLine);
+ QTest::newRow("dashdot") << QString("dot-dash") << int(QTextCharFormat::DashDotLine);
+ QTest::newRow("dashdotdot") << QString("dot-dot-dash") << int(QTextCharFormat::DashDotDotLine);
+ QTest::newRow("wave") << QString("wave") << int(QTextCharFormat::WaveUnderline);
+}
+
+void tst_QTextDocumentFragment::css_textUnderlineStyle()
+{
+ QFETCH(QString, styleName);
+ QFETCH(int, expectedStyle);
+
+ QString html = QString::fromLatin1("<span style=\"text-underline-style: %1\">Blah</span>").arg(styleName);
+ doc->setHtml(html);
+
+ QTextFragment fragment = doc->begin().begin().fragment();
+ QVERIFY(fragment.isValid());
+ QCOMPARE(int(fragment.charFormat().underlineStyle()), expectedStyle);
+}
+
+void tst_QTextDocumentFragment::css_textUnderlineStyleAndDecoration()
+{
+ doc->setHtml("<span style=\"text-decoration: overline; text-underline-style: solid\">Test</span>");
+
+ QTextFragment fragment = doc->begin().begin().fragment();
+ QVERIFY(fragment.isValid());
+ QVERIFY(fragment.charFormat().underlineStyle() == QTextCharFormat::SingleUnderline);
+ QVERIFY(fragment.charFormat().fontOverline());
+
+ doc->setHtml("<span style=\"text-underline-style: solid; text-decoration: overline\">Test</span>");
+
+ fragment = doc->begin().begin().fragment();
+ QVERIFY(fragment.isValid());
+ QVERIFY(fragment.charFormat().underlineStyle() == QTextCharFormat::SingleUnderline);
+ QVERIFY(fragment.charFormat().fontOverline());
+}
+
+void tst_QTextDocumentFragment::css_listStyleType()
+{
+ doc->setHtml("<ol style=\"list-style-type: disc\"><li>Blah</li></ol>");
+ cursor.movePosition(QTextCursor::End);
+ QVERIFY(cursor.currentList());
+ QVERIFY(cursor.currentList()->format().style() == QTextListFormat::ListDisc);
+
+ doc->setHtml("<ul style=\"list-style-type: square\"><li>Blah</li></ul>");
+ cursor.movePosition(QTextCursor::End);
+ QVERIFY(cursor.currentList());
+ QVERIFY(cursor.currentList()->format().style() == QTextListFormat::ListSquare);
+
+ doc->setHtml("<ul style=\"list-style-type: circle\"><li>Blah</li></ul>");
+ cursor.movePosition(QTextCursor::End);
+ QVERIFY(cursor.currentList());
+ QVERIFY(cursor.currentList()->format().style() == QTextListFormat::ListCircle);
+
+ doc->setHtml("<ul style=\"list-style-type: decimal\"><li>Blah</li></ul>");
+ cursor.movePosition(QTextCursor::End);
+ QVERIFY(cursor.currentList());
+ QVERIFY(cursor.currentList()->format().style() == QTextListFormat::ListDecimal);
+
+ doc->setHtml("<ul style=\"list-style-type: lower-alpha\"><li>Blah</li></ul>");
+ cursor.movePosition(QTextCursor::End);
+ QVERIFY(cursor.currentList());
+ QVERIFY(cursor.currentList()->format().style() == QTextListFormat::ListLowerAlpha);
+
+ doc->setHtml("<ul style=\"list-style-type: upper-alpha\"><li>Blah</li></ul>");
+ cursor.movePosition(QTextCursor::End);
+ QVERIFY(cursor.currentList());
+ QVERIFY(cursor.currentList()->format().style() == QTextListFormat::ListUpperAlpha);
+
+ doc->setHtml("<ul style=\"list-style-type: upper-roman\"><li>Blah</li></ul>");
+ cursor.movePosition(QTextCursor::End);
+ QVERIFY(cursor.currentList());
+ QVERIFY(cursor.currentList()->format().style() == QTextListFormat::ListUpperRoman);
+
+ doc->setHtml("<ul style=\"list-style-type: lower-roman\"><li>Blah</li></ul>");
+ cursor.movePosition(QTextCursor::End);
+ QVERIFY(cursor.currentList());
+ QVERIFY(cursor.currentList()->format().style() == QTextListFormat::ListLowerRoman);
+
+ // ignore the unsupported list-style-position inside the list-style shorthand property
+ doc->setHtml("<ul style=\"list-style: outside decimal\"><li>Blah</li></ul>");
+ cursor.movePosition(QTextCursor::End);
+ QVERIFY(cursor.currentList());
+ QVERIFY(cursor.currentList()->format().style() == QTextListFormat::ListDecimal);
+}
+
+void tst_QTextDocumentFragment::css_linkPseudo()
+{
+ doc->setHtml("<a href=\"foobar\">Blah</a>");
+ QVERIFY(doc->begin().begin().fragment().charFormat().fontUnderline());
+
+ doc->setHtml("<style>a { text-decoration: none; }</style><a href=\"foobar\">Blah</a>");
+ QVERIFY(!doc->begin().begin().fragment().charFormat().fontUnderline());
+
+ doc->setHtml("<style>a:link { text-decoration: none; }</style><a href=\"foobar\">Blah</a>");
+ QVERIFY(!doc->begin().begin().fragment().charFormat().fontUnderline());
+}
+
+void tst_QTextDocumentFragment::css_pageBreaks()
+{
+ doc->setHtml("<p>Foo</p>");
+ QVERIFY(doc->begin().blockFormat().pageBreakPolicy() == QTextFormat::PageBreak_Auto);
+
+ doc->setHtml("<p style=\" page-break-before:always;\">Foo</p>");
+ QVERIFY(doc->begin().blockFormat().pageBreakPolicy() == QTextFormat::PageBreak_AlwaysBefore);
+
+ doc->setHtml("<p style=\" page-break-after:always;\">Foo</p>");
+ QVERIFY(doc->begin().blockFormat().pageBreakPolicy() == QTextFormat::PageBreak_AlwaysAfter);
+
+ doc->setHtml("<p style=\" page-break-before:always; page-break-after:always;\">Foo</p>");
+ QVERIFY(doc->begin().blockFormat().pageBreakPolicy() == (QTextFormat::PageBreak_AlwaysAfter | QTextFormat::PageBreak_AlwaysBefore));
+}
+
+void tst_QTextDocumentFragment::universalSelectors_data()
+{
+ QTest::addColumn<bool>("match");
+ QTest::addColumn<QString>("selector");
+ QTest::addColumn<QString>("attributes");
+
+ QTest::newRow("1") << true << QString("*") << QString();
+ QTest::newRow("2") << false << QString() << QString(); // invalid totally empty selector
+
+ QTest::newRow("3") << false << QString("*[foo=bar]") << QString("foo=bleh");
+ QTest::newRow("4") << true << QString("*[foo=bar]") << QString("foo=bar");
+
+ QTest::newRow("5") << false << QString("[foo=bar]") << QString("foo=bleh");
+ QTest::newRow("6") << true << QString("[foo=bar]") << QString("foo=bar");
+
+ QTest::newRow("7") << true << QString(".charfmt1") << QString("class=charfmt1");
+}
+
+void tst_QTextDocumentFragment::universalSelectors()
+{
+ QFETCH(bool, match);
+ QFETCH(QString, selector);
+ QFETCH(QString, attributes);
+
+ QString html = QString(""
+ "<style>"
+ "%1 { background-color: green }"
+ "</style>"
+ "<p %2>test</p>"
+ ).arg(selector).arg(attributes);
+
+ setHtml(html);
+
+ QTextBlockFormat fmt = doc->begin().blockFormat();
+ if (match)
+ QVERIFY(fmt.background().color() == QColor("green"));
+ else
+ QVERIFY(!fmt.hasProperty(QTextFormat::BackgroundBrush));
+}
+
+void tst_QTextDocumentFragment::screenMedia()
+{
+ setHtml("<style>"
+ "@media screen {"
+ "p { background-color: green }"
+ "}"
+ "</style>"
+ "<p>test</p>"
+ "");
+ QTextBlockFormat fmt = doc->begin().blockFormat();
+ QVERIFY(fmt.background().color() == QColor("green"));
+
+ setHtml("<style>"
+ "@media foobar {"
+ "p { background-color: green }"
+ "}"
+ "</style>"
+ "<p>test</p>"
+ "");
+ fmt = doc->begin().blockFormat();
+ QVERIFY(fmt.background().color() != QColor("green"));
+
+ setHtml("<style>"
+ "@media sCrEeN {"
+ "p { background-color: green }"
+ "}"
+ "</style>"
+ "<p>test</p>"
+ "");
+ fmt = doc->begin().blockFormat();
+ QVERIFY(fmt.background().color() == QColor("green"));
+}
+
+void tst_QTextDocumentFragment::htmlResourceLoading()
+{
+ const QString html("<link href=\"test.css\" type=\"text/css\" />"
+ "<p>test</p>");
+
+ QTextDocument tmp;
+ tmp.addResource(QTextDocument::StyleSheetResource, QUrl("test.css"), QString("p { background-color: green; }"));
+ QTextDocumentFragment frag = QTextDocumentFragment::fromHtml(html, &tmp);
+ doc->clear();
+ QTextCursor(doc).insertFragment(frag);
+ QTextBlockFormat fmt = doc->begin().blockFormat();
+ QVERIFY(fmt.background().color() == QColor("green"));
+}
+
+void tst_QTextDocumentFragment::someCaseInsensitiveAttributeValues()
+{
+ const char html1[] = "<ul type=sQUarE><li>Blah</li></ul>";
+ setHtml(QString::fromLatin1(html1));
+ cursor.movePosition(QTextCursor::End);
+ QVERIFY(cursor.currentList());
+ QVERIFY(cursor.currentList()->format().style() == QTextListFormat::ListSquare);
+
+ const char html2[] = "<div align=ceNTeR><b>Hello World";
+ setHtml(html2);
+
+ QCOMPARE(doc->begin().blockFormat().alignment(), Qt::AlignHCenter);
+
+ const char html3[] = "<p dir=rTL><b>Hello World";
+ setHtml(html3);
+
+ QCOMPARE(doc->begin().blockFormat().layoutDirection(), Qt::RightToLeft);
+}
+
+class TestDocument : public QTextDocument
+{
+public:
+ inline TestDocument() {}
+
+ QPixmap testPixmap;
+
+ virtual QVariant loadResource(int type, const QUrl &name) {
+ if (name.toString() == QLatin1String("testPixmap")) {
+ return testPixmap;
+ }
+ return QTextDocument::loadResource(type, name);
+ }
+};
+
+void tst_QTextDocumentFragment::backgroundImage()
+{
+ TestDocument doc;
+ doc.testPixmap = QPixmap(100, 100);
+ doc.testPixmap.fill(Qt::blue);
+ doc.setHtml("<p style=\"background-image: url(testPixmap)\">Hello</p>");
+ QBrush bg = doc.begin().blockFormat().background();
+ QVERIFY(bg.style() == Qt::TexturePattern);
+ QVERIFY(bg.texture().serialNumber() == doc.testPixmap.serialNumber());
+}
+
+void tst_QTextDocumentFragment::dontMergePreAndNonPre()
+{
+ doc->setHtml("<pre>Pre text</pre>Text that should be wrapped");
+ QCOMPARE(doc->blockCount(), 2);
+ QCOMPARE(doc->begin().text(), QString("Pre text"));
+ QCOMPARE(doc->begin().next().text(), QString("Text that should be wrapped"));
+}
+
+void tst_QTextDocumentFragment::leftMarginInsideHtml()
+{
+ doc->setHtml("<html><dl><dd>Blah");
+ QCOMPARE(doc->blockCount(), 1);
+ QVERIFY(doc->begin().blockFormat().leftMargin() > 0);
+}
+
+void tst_QTextDocumentFragment::html_margins()
+{
+ doc->setHtml("<p style=\"margin-left: 42px\">Test");
+ QCOMPARE(doc->blockCount(), 1);
+ QCOMPARE(doc->begin().blockFormat().topMargin(), 12.);
+ QCOMPARE(doc->begin().blockFormat().bottomMargin(), 12.);
+ QCOMPARE(doc->begin().blockFormat().leftMargin(), 42.);
+}
+
+void tst_QTextDocumentFragment::newlineInsidePreShouldBecomeNewParagraph()
+{
+ // rationale: we used to map newlines inside <pre> to QChar::LineSeparator, but
+ // if you display a lot of text inside pre it all ended up inside one single paragraph,
+ // which doesn't scale very well with our text engine. Paragraphs spanning thousands of
+ // lines are not a common use-case otherwise.
+
+ doc->setHtml("<pre>Foo\nBar</pre>");
+ QCOMPARE(doc->blockCount(), 2);
+ QTextBlock block = doc->begin();
+ QCOMPARE(block.blockFormat().topMargin(), qreal(12));
+ QVERIFY(qIsNull(block.blockFormat().bottomMargin()));
+
+ block = block.next();
+
+ QVERIFY(qIsNull(block.blockFormat().topMargin()));
+ QCOMPARE(block.blockFormat().bottomMargin(), qreal(12));
+
+ doc->setHtml("<pre style=\"margin-top: 32px; margin-bottom: 45px; margin-left: 50px\">Foo\nBar</pre>");
+ QCOMPARE(doc->blockCount(), 2);
+ block = doc->begin();
+ QCOMPARE(block.blockFormat().topMargin(), qreal(32));
+ QVERIFY(qIsNull(block.blockFormat().bottomMargin()));
+ QCOMPARE(block.blockFormat().leftMargin(), qreal(50));
+
+ block = block.next();
+
+ QVERIFY(qIsNull(block.blockFormat().topMargin()));
+ QCOMPARE(block.blockFormat().bottomMargin(), qreal(45));
+ QCOMPARE(block.blockFormat().leftMargin(), qreal(50));
+
+}
+
+void tst_QTextDocumentFragment::invalidColspan()
+{
+ doc->setHtml("<table><tr rowspan=-1><td colspan=-1>Blah</td></tr></table>");
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->columns(), 1);
+ QCOMPARE(table->rows(), 1);
+}
+
+void tst_QTextDocumentFragment::html_brokenTableWithJustTr()
+{
+ doc->setHtml("<tr><td>First Cell</td><tr><td>Second Cell");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->rows(), 2);
+ QCOMPARE(table->columns(), 1);
+ QCOMPARE(table->cellAt(0, 0).firstCursorPosition().block().text(), QString("First Cell"));
+ QCOMPARE(table->cellAt(1, 0).firstCursorPosition().block().text(), QString("Second Cell"));
+
+ doc->setHtml(""
+ "<col width=286 style='mso-width-source:userset;mso-width-alt:10459;width:215pt'>"
+ "<col width=64 span=3 style='width:48pt'>"
+ "<tr height=17 style='height:12.75pt'>"
+ "<td height=17 width=286 style='height:12.75pt;width:215pt'>1a</td>"
+ "<td width=64 style='width:48pt'>1b</td>"
+ "<td width=64 style='width:48pt'>1c</td>"
+ "<td width=64 style='width:48pt'>1d</td>"
+ "</tr>"
+ "<tr height=17 style='height:12.75pt'>"
+ "<td height=17 style='height:12.75pt'>|2a</td>"
+ "<td>2b</td>"
+ "<td>2c</td>"
+ "<td>2d</td>"
+ "</tr>");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->rows(), 2);
+ QCOMPARE(table->columns(), 4);
+}
+
+void tst_QTextDocumentFragment::html_brokenTableWithJustTd()
+{
+ doc->setHtml("<td>First Cell</td><td>Second Cell");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->rows(), 1);
+ QCOMPARE(table->columns(), 2);
+ QCOMPARE(table->cellAt(0, 0).firstCursorPosition().block().text(), QString("First Cell"));
+ QCOMPARE(table->cellAt(0, 1).firstCursorPosition().block().text(), QString("Second Cell"));
+
+ doc->setHtml("<td height=17 width=286 style='height:12.75pt;width:215pt'>1a</td>"
+ "<td width=64 style='width:48pt'>1b</td>"
+ "<td width=64 style='width:48pt'>1c</td>"
+ "<td width=64 style='width:48pt'>1d</td>");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->rows(), 1);
+ QCOMPARE(table->columns(), 4);
+}
+
+void tst_QTextDocumentFragment::html_preNewlineHandling_data()
+{
+ QTest::addColumn<QString>("html");
+ QTest::addColumn<QString>("expectedPlainText");
+
+ QTest::newRow("pre1") << QString("Foo<pre>Bar")
+ << QString("Foo\nBar");
+ QTest::newRow("pre2") << QString("Foo<pre>\nBar")
+ << QString("Foo\nBar");
+ QTest::newRow("pre2") << QString("Foo<pre>\n\nBar")
+ << QString("Foo\n\nBar");
+ QTest::newRow("pre4") << QString("<html>Foo<pre>\nBar")
+ << QString("Foo\nBar");
+ QTest::newRow("pre5") << QString("<pre>Foo\n</pre>\nBar")
+ << QString("Foo\nBar");
+ QTest::newRow("pre6") << QString("<pre>Foo<b>Bar</b>Blah\n</pre>\nMooh")
+ << QString("FooBarBlah\nMooh");
+ QTest::newRow("pre7") << QString("<pre>\nPara1\n</pre>\n<pre>\nPara2\n</pre>")
+ << QString("Para1\nPara2");
+}
+
+void tst_QTextDocumentFragment::html_preNewlineHandling()
+{
+ QFETCH(QString, html);
+
+ doc->setHtml(html);
+ QTEST(doc->toPlainText(), "expectedPlainText");
+}
+
+void tst_QTextDocumentFragment::html_br()
+{
+ doc->setHtml("Foo<br><br><br>Blah");
+ QCOMPARE(doc->toPlainText(), QString("Foo\n\n\nBlah"));
+}
+
+void tst_QTextDocumentFragment::html_dl()
+{
+ doc->setHtml("<dl><dt>term<dd>data</dl>Text afterwards");
+ QCOMPARE(doc->toPlainText(), QString("term\ndata\nText afterwards"));
+}
+
+void tst_QTextDocumentFragment::html_tableStrangeNewline()
+{
+ doc->setHtml("<table><tr><td>Foo</td></tr>\n</table>");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->rows(), 1);
+ QCOMPARE(table->columns(), 1);
+ const QTextTableCell cell = table->cellAt(0, 0);
+ QCOMPARE(cell.firstCursorPosition().block().text(), QString("Foo"));
+ QVERIFY(cell.firstCursorPosition().block() == cell.lastCursorPosition().block());
+}
+
+void tst_QTextDocumentFragment::html_tableStrangeNewline2()
+{
+ doc->setHtml("<table><tr><td>Foo</td></tr><tr>\n<td/></tr></table>");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->rows(), 2);
+ QCOMPARE(table->columns(), 1);
+ const QTextTableCell cell = table->cellAt(0, 0);
+ QCOMPARE(cell.firstCursorPosition().block().text(), QString("Foo"));
+ QVERIFY(cell.firstCursorPosition().block() == cell.lastCursorPosition().block());
+}
+
+void tst_QTextDocumentFragment::html_tableStrangeNewline3()
+{
+ doc->setHtml("<table border>"
+ "<tr>"
+ "<td>"
+ "<ul>"
+ "<li>Meh</li>"
+ "</ul>"
+ "</td>"
+ "<td>\n"
+ "<ul>"
+ "<li>Foo</li>"
+ "</ul>"
+ "</td>"
+ "</tr>"
+ "</table>");
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->rows(), 1);
+ QCOMPARE(table->columns(), 2);
+
+ QTextTableCell cell = table->cellAt(0, 0);
+ QCOMPARE(cell.firstCursorPosition().block().text(), QString("Meh"));
+ QVERIFY(cell.firstCursorPosition().block() == cell.lastCursorPosition().block());
+
+ cell = table->cellAt(0, 1);
+ QCOMPARE(cell.firstCursorPosition().block().text(), QString("Foo"));
+ QVERIFY(cell.firstCursorPosition().block() == cell.lastCursorPosition().block());
+}
+
+void tst_QTextDocumentFragment::html_caption()
+{
+ doc->setHtml("<table border align=center>"
+ "<caption>This <b> is a</b> Caption!</caption>"
+ "<tr><td>Blah</td></tr>"
+ "</table>");
+
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+
+ QCOMPARE(cursor.block().text(), QString("This is a Caption!"));
+ QVERIFY(cursor.blockFormat().alignment() == Qt::AlignHCenter);
+
+ cursor.movePosition(QTextCursor::NextBlock);
+ QTextTable *table = cursor.currentTable();
+ QVERIFY(table);
+ QCOMPARE(table->rows(), 1);
+ QCOMPARE(table->columns(), 1);
+
+ QTextTableCell cell = table->cellAt(0, 0);
+ QCOMPARE(cell.firstCursorPosition().block().text(), QString("Blah"));
+}
+
+static const uint windowsLatin1ExtendedCharacters[0xA0 - 0x80] = {
+ 0x20ac, // 0x80
+ 0x0081, // 0x81 direct mapping
+ 0x201a, // 0x82
+ 0x0192, // 0x83
+ 0x201e, // 0x84
+ 0x2026, // 0x85
+ 0x2020, // 0x86
+ 0x2021, // 0x87
+ 0x02C6, // 0x88
+ 0x2030, // 0x89
+ 0x0160, // 0x8A
+ 0x2039, // 0x8B
+ 0x0152, // 0x8C
+ 0x008D, // 0x8D direct mapping
+ 0x017D, // 0x8E
+ 0x008F, // 0x8F directmapping
+ 0x0090, // 0x90 directmapping
+ 0x2018, // 0x91
+ 0x2019, // 0x92
+ 0x201C, // 0x93
+ 0X201D, // 0x94
+ 0x2022, // 0x95
+ 0x2013, // 0x96
+ 0x2014, // 0x97
+ 0x02DC, // 0x98
+ 0x2122, // 0x99
+ 0x0161, // 0x9A
+ 0x203A, // 0x9B
+ 0x0153, // 0x9C
+ 0x009D, // 0x9D direct mapping
+ 0x017E, // 0x9E
+ 0x0178 // 0x9F
+};
+
+void tst_QTextDocumentFragment::html_windowsEntities()
+{
+ for (uint i = 0; i < sizeof(windowsLatin1ExtendedCharacters)/sizeof(windowsLatin1ExtendedCharacters[0]); ++i) {
+ QString html = QString::number(i + 0x80);
+ html.prepend("<p>&#");
+ html.append(";");
+ doc->setHtml(html);
+ QCOMPARE(doc->toPlainText(), QString(QChar(windowsLatin1ExtendedCharacters[i])));
+ }
+}
+
+void tst_QTextDocumentFragment::html_eatenText()
+{
+ doc->setHtml("<h1>Test1</h1>\nTest2<h1>Test3</h1>");
+ cursor.movePosition(QTextCursor::Start);
+ QCOMPARE(cursor.block().text(), QString("Test1"));
+ cursor.movePosition(QTextCursor::NextBlock);
+ QCOMPARE(cursor.block().text(), QString("Test2"));
+ cursor.movePosition(QTextCursor::NextBlock);
+ QCOMPARE(cursor.block().text(), QString("Test3"));
+}
+
+void tst_QTextDocumentFragment::html_hr()
+{
+ doc->setHtml("<hr />");
+ QCOMPARE(doc->blockCount(), 1);
+ QVERIFY(doc->begin().blockFormat().hasProperty(QTextFormat::BlockTrailingHorizontalRulerWidth));
+}
+
+void tst_QTextDocumentFragment::html_hrMargins()
+{
+ doc->setHtml("<p>Test<hr/>Blah");
+ QCOMPARE(doc->blockCount(), 3);
+
+ cursor.movePosition(QTextCursor::Start);
+ QTextBlock block = cursor.block();
+ QCOMPARE(block.text(), QString("Test"));
+ QVERIFY(block.blockFormat().bottomMargin() <= qreal(12.));
+ QTextBlock first = block;
+
+ cursor.movePosition(QTextCursor::NextBlock);
+ block = cursor.block();
+ QTextBlock hr = block;
+ QVERIFY(qMax(first.blockFormat().bottomMargin(), block.blockFormat().topMargin()) > 0);
+
+ cursor.movePosition(QTextCursor::NextBlock);
+ block = cursor.block();
+
+ QCOMPARE(block.text(), QString("Blah"));
+}
+
+void tst_QTextDocumentFragment::html_blockQuoteMargins()
+{
+ doc->setHtml("<blockquote>Bar</blockquote>");
+ QCOMPARE(doc->blockCount(), 1);
+ cursor.movePosition(QTextCursor::Start);
+ QTextBlock block = cursor.block();
+ QCOMPARE(block.text(), QString("Bar"));
+ QCOMPARE(block.blockFormat().leftMargin(), qreal(40.));
+ QCOMPARE(block.blockFormat().rightMargin(), qreal(40.));
+ QCOMPARE(block.blockFormat().topMargin(), qreal(12.));
+ QCOMPARE(block.blockFormat().bottomMargin(), qreal(12.));
+}
+
+void tst_QTextDocumentFragment::html_definitionListMargins()
+{
+ doc->setHtml("Foo<dl><dt>tag<dd>data</dl>Bar");
+ QCOMPARE(doc->blockCount(), 4);
+
+ cursor.movePosition(QTextCursor::Start);
+ QTextBlock block = cursor.block();
+ QCOMPARE(block.text(), QString("Foo"));
+
+ block = block.next();
+ QCOMPARE(block.text(), QString("tag"));
+ QCOMPARE(block.blockFormat().topMargin(), qreal(8.));
+
+ block = block.next();
+ QCOMPARE(block.text(), QString("data"));
+ QCOMPARE(block.blockFormat().bottomMargin(), qreal(8.));
+
+ block = block.next();
+ QCOMPARE(block.text(), QString("Bar"));
+}
+
+void tst_QTextDocumentFragment::html_listMargins()
+{
+ doc->setHtml("Foo<ol><li>First<li>Second</ol>Bar");
+ QCOMPARE(doc->blockCount(), 4);
+
+ cursor.movePosition(QTextCursor::Start);
+ QTextBlock block = cursor.block();
+ QCOMPARE(block.text(), QString("Foo"));
+
+ block = block.next();
+ QCOMPARE(block.text(), QString("First"));
+ QCOMPARE(block.blockFormat().topMargin(), qreal(12.));
+
+ block = block.next();
+ QCOMPARE(block.text(), QString("Second"));
+ QCOMPARE(block.blockFormat().bottomMargin(), qreal(12.));
+
+ block = block.next();
+ QCOMPARE(block.text(), QString("Bar"));
+}
+
+void tst_QTextDocumentFragment::html_titleAttribute()
+{
+ doc->setHtml("<span title=\"this is my title\">Test</span>");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QCOMPARE(cursor.charFormat().toolTip(), QString("this is my title"));
+}
+
+void tst_QTextDocumentFragment::html_compressDivs()
+{
+ doc->setHtml("<p/><div/><div/><div/><div/>Test");
+ QCOMPARE(doc->blockCount(), 1);
+ QCOMPARE(doc->begin().text(), QString("Test"));
+}
+
+void tst_QTextDocumentFragment::completeToPlainText()
+{
+ doc->setPlainText("Hello\nWorld");
+ QCOMPARE(doc->toPlainText(), QString("Hello\nWorld"));
+ QTextDocumentFragment fragment(doc);
+ QCOMPARE(fragment.toPlainText(), QString("Hello\nWorld"));
+}
+
+void tst_QTextDocumentFragment::copyContents()
+{
+ doc->setPlainText("Hello");
+ QFont f;
+ doc->setDefaultFont(f);
+ QTextFragment fragment = doc->begin().begin().fragment();
+ QCOMPARE(fragment.text(), QString("Hello"));
+ QCOMPARE(fragment.charFormat().font().pointSize(), f.pointSize());
+
+ QTextDocumentFragment frag(doc);
+ doc->clear();
+ f.setPointSize(48);
+ doc->setDefaultFont(f);
+ QTextCursor(doc).insertFragment(QTextDocumentFragment::fromHtml(frag.toHtml()));
+ fragment = doc->begin().begin().fragment();
+ QCOMPARE(fragment.text(), QString("Hello"));
+ QCOMPARE(fragment.charFormat().font().pointSize(), f.pointSize());
+}
+
+void tst_QTextDocumentFragment::html_textAfterHr()
+{
+ doc->setHtml("<hr><nobr><b>After the centered text</b></nobr>");
+ QCOMPARE(doc->blockCount(), 2);
+ QTextBlock block = doc->begin();
+ QVERIFY(block.text().isEmpty());
+ QVERIFY(block.blockFormat().hasProperty(QTextFormat::BlockTrailingHorizontalRulerWidth));
+ block = block.next();
+
+ QString txt("After the centered text");
+ txt.replace(QLatin1Char(' '), QChar::Nbsp);
+ QCOMPARE(block.text(), txt);
+ QVERIFY(!block.blockFormat().hasProperty(QTextFormat::BlockTrailingHorizontalRulerWidth));
+}
+
+void tst_QTextDocumentFragment::blockTagClosing()
+{
+ doc->setHtml("<p>foo<p>bar<span>baz</span>");
+ QCOMPARE(doc->blockCount(), 2);
+ QTextBlock block = doc->begin();
+ QCOMPARE(block.text(), QString("foo"));
+ block = block.next();
+ QCOMPARE(block.text(), QString("barbaz"));
+}
+
+void tst_QTextDocumentFragment::isEmpty()
+{
+ QTextDocumentFragment frag;
+ QVERIFY(frag.isEmpty());
+ frag = QTextDocumentFragment::fromHtml("test");
+ QVERIFY(!frag.isEmpty());
+ frag = QTextDocumentFragment::fromHtml("<hr />");
+ QVERIFY(!frag.isEmpty());
+}
+
+void tst_QTextDocumentFragment::html_alignmentInheritance()
+{
+ doc->setHtml("<center>Centered text<hr></center><b>After the centered text</b>");
+ QCOMPARE(doc->blockCount(), 3);
+ QTextBlock block = doc->begin();
+ QVERIFY(block.blockFormat().alignment() & Qt::AlignHCenter);
+ block = block.next();
+ QVERIFY(block.blockFormat().alignment() & Qt::AlignHCenter);
+ block = block.next();
+ QVERIFY(!(block.blockFormat().alignment() & Qt::AlignHCenter));
+}
+
+void tst_QTextDocumentFragment::html_ignoreEmptyDivs()
+{
+ doc->setHtml("<p><div/><b>Foo</b>");
+ QCOMPARE(doc->blockCount(), 1);
+ QCOMPARE(doc->begin().text(), QString("Foo"));
+}
+
+void tst_QTextDocumentFragment::html_dontInheritAlignmentForFloatingImages()
+{
+ doc->setHtml("<p align=right><img align=unknownignored src=\"foo\" /></p>");
+ QTextCharFormat fmt = doc->begin().begin().fragment().charFormat();
+ QVERIFY(fmt.isImageFormat());
+ QTextObject *o = doc->objectForFormat(fmt);
+ QVERIFY(o);
+ QTextFormat f = o->format();
+ QVERIFY(f.isFrameFormat());
+ QVERIFY(f.toFrameFormat().position() == QTextFrameFormat::InFlow);
+}
+
+void tst_QTextDocumentFragment::html_verticalImageAlignment()
+{
+ doc->setHtml("<img src=\"foo\"/>");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().isImageFormat());
+ QTextImageFormat fmt = cursor.charFormat().toImageFormat();
+ QVERIFY(fmt.verticalAlignment() == QTextCharFormat::AlignNormal);
+
+ doc->setHtml("<img src=\"foo\" align=middle />");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().isImageFormat());
+ fmt = cursor.charFormat().toImageFormat();
+ QVERIFY(fmt.verticalAlignment() == QTextCharFormat::AlignMiddle);
+
+ doc->setHtml("<img src=\"foo\" style=\"vertical-align: middle\" />");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().isImageFormat());
+ fmt = cursor.charFormat().toImageFormat();
+ QVERIFY(fmt.verticalAlignment() == QTextCharFormat::AlignMiddle);
+
+ doc->setHtml("<img src=\"foo\" align=top />");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().isImageFormat());
+ fmt = cursor.charFormat().toImageFormat();
+ QVERIFY(fmt.verticalAlignment() == QTextCharFormat::AlignTop);
+
+ doc->setHtml("<img src=\"foo\" style=\"vertical-align: top\" />");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().isImageFormat());
+ fmt = cursor.charFormat().toImageFormat();
+ QVERIFY(fmt.verticalAlignment() == QTextCharFormat::AlignTop);
+}
+
+void tst_QTextDocumentFragment::html_verticalCellAlignment()
+{
+ const char *alt[] =
+ {
+ // vertical-align property
+ "<table>"
+ "<tr>"
+ "<td style=\"vertical-align: middle\"></td>"
+ "<td style=\"vertical-align: top\"></td>"
+ "<td style=\"vertical-align: bottom\"></td>"
+ "</tr>"
+ "</table>",
+ // valign property
+ "<table>"
+ "<tr>"
+ "<td valign=\"middle\"></td>"
+ "<td valign=\"top\"></td>"
+ "<td valign=\"bottom\"></td>"
+ "</tr>"
+ "</table>",
+ // test td override of tr property
+ "<table>"
+ "<tr valign=\"bottom\">"
+ "<td valign=\"middle\"></td>"
+ "<td valign=\"top\"></td>"
+ "<td></td>"
+ "</tr>"
+ "</table>"
+ };
+
+ const int numTestCases = sizeof(alt) / sizeof(*alt);
+ for (int i = 0; i < numTestCases; ++i) {
+ doc->setHtml(alt[i]);
+
+ QTextTable *table = qobject_cast<QTextTable *>(doc->rootFrame()->childFrames().at(0));
+ QVERIFY(table);
+
+ QCOMPARE(table->cellAt(0, 0).format().verticalAlignment(), QTextCharFormat::AlignMiddle);
+ QCOMPARE(table->cellAt(0, 1).format().verticalAlignment(), QTextCharFormat::AlignTop);
+ QCOMPARE(table->cellAt(0, 2).format().verticalAlignment(), QTextCharFormat::AlignBottom);
+ }
+}
+
+void tst_QTextDocumentFragment::html_borderColor()
+{
+ const char html[] = "<table border=1 style=\"border-color:#0000ff;\"><tr><td>Foo</td></tr></table>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QString::fromLatin1(html)));
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QVERIFY(cursor.currentTable());
+ QCOMPARE(cursor.currentTable()->format().borderStyle(), QTextFrameFormat::BorderStyle_Outset);
+ QCOMPARE(cursor.currentTable()->format().borderBrush(), QBrush(QColor("#0000ff")));
+}
+
+void tst_QTextDocumentFragment::html_borderStyle()
+{
+ const char html[] = "<table border=1 style=\"border-style:solid;\"><tr><td>Foo</td></tr></table>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QString::fromLatin1(html)));
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QVERIFY(cursor.currentTable());
+ QCOMPARE(cursor.currentTable()->format().borderStyle(), QTextFrameFormat::BorderStyle_Solid);
+ QCOMPARE(cursor.currentTable()->format().borderBrush(), QBrush(Qt::darkGray));
+}
+
+void tst_QTextDocumentFragment::html_borderWidth()
+{
+ const char *html[2] = { "<table style=\"border-width:2;\"><tr><td>Foo</td></tr></table>",
+ "<table style=\"border-width:2px;\"><tr><td>Foo</td></tr></table>" };
+
+ for (int i = 0; i < 2; ++i) {
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QString::fromLatin1(html[i])));
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextBlock);
+ QVERIFY(cursor.currentTable());
+ QCOMPARE(cursor.currentTable()->format().border(), qreal(2));
+ }
+}
+
+void tst_QTextDocumentFragment::html_userState()
+{
+ const char html[] = "<p style=\"-qt-user-state:42;\">A</p><p style=\"-qt-user-state:0;\">B</p><p>C</p>";
+ cursor.insertFragment(QTextDocumentFragment::fromHtml(QString::fromLatin1(html)));
+ QTextBlock block = doc->begin();
+ QCOMPARE(block.userState(), 42);
+ QCOMPARE(block.next().userState(), 0);
+ QCOMPARE(block.next().next().userState(), -1);
+}
+
+void tst_QTextDocumentFragment::html_rootFrameProperties()
+{
+ const char html[] = "<table border=1 style=\"-qt-table-type:root; margin-top:10px;\"><tr><td>Foo</tr></td>";
+ doc->setHtml(html);
+
+ QCOMPARE(doc->rootFrame()->childFrames().size(), 0);
+
+ QTextFrameFormat fmt = doc->rootFrame()->frameFormat();
+ QCOMPARE(fmt.topMargin(), qreal(10));
+ QCOMPARE(fmt.bottomMargin(), qreal(0));
+ QCOMPARE(fmt.leftMargin(), qreal(0));
+ QCOMPARE(fmt.rightMargin(), qreal(0));
+ QCOMPARE(fmt.border(), qreal(1));
+
+ QString normalFrameHtml = QLatin1String(html);
+ normalFrameHtml.replace(QLatin1String("root"), QLatin1String("frame"));
+
+ doc->setHtml(normalFrameHtml);
+ QCOMPARE(doc->rootFrame()->childFrames().size(), 1);
+}
+
+void tst_QTextDocumentFragment::html_appendList()
+{
+ appendHtml("<p>foo</p>");
+ appendHtml("<ul><li>Line 1</li><li>Line 2</li></ul>");
+
+ QCOMPARE(doc->blockCount(), 3);
+ QVERIFY(doc->begin().next().textList() != 0);
+}
+
+void tst_QTextDocumentFragment::html_appendList2()
+{
+ appendHtml("1");
+ appendHtml("<ul><li><img src=\"/foo/bar\" /></li></ul>");
+
+ QCOMPARE(doc->blockCount(), 2);
+ QVERIFY(doc->begin().next().textList() != 0);
+}
+
+void tst_QTextDocumentFragment::html_alignmentPropertySet()
+{
+ const char html[] = "<p>Test</p>";
+ setHtml(QString::fromLatin1(html));
+ QVERIFY(!doc->begin().blockFormat().hasProperty(QTextFormat::BlockAlignment));
+}
+
+void tst_QTextDocumentFragment::html_qt3RichtextWhitespaceMode()
+{
+ setHtml(QString::fromLatin1("<html><head><meta name=\"qrichtext\" content=\"1\" /></head><p> line with whitespace</p><p> another line with whitespace</p></body></html>"));
+ QCOMPARE(doc->blockCount(), 2);
+
+ QTextBlock block = doc->begin();
+ QVERIFY(block.text().startsWith(" "));
+
+ block = block.next();
+ QVERIFY(block.text().startsWith(" "));
+}
+
+void tst_QTextDocumentFragment::html_brAfterHr()
+{
+ setHtml(QString::fromLatin1("Text A<br><hr><br>Text B<hr>"));
+
+ QCOMPARE(doc->blockCount(), 4);
+
+ QTextBlock block = doc->begin();
+ QCOMPARE(block.text(), QString("Text A") + QChar(QChar::LineSeparator));
+
+ block = block.next();
+ QVERIFY(block.text().isEmpty());
+
+ block = block.next();
+ QCOMPARE(block.text(), QChar(QChar::LineSeparator) + QString("Text B"));
+
+ block = block.next();
+ QVERIFY(block.text().isEmpty());
+}
+
+void tst_QTextDocumentFragment::html_unclosedHead()
+{
+ doc->setHtml(QString::fromLatin1("<html><head><title>Test</title><body>Blah</body></html>"));
+ QCOMPARE(doc->metaInformation(QTextDocument::DocumentTitle), QString::fromLatin1("Test"));
+ QCOMPARE(doc->toPlainText(), QString::fromLatin1("Blah"));
+}
+
+// duplicated from qtexthtmlparser.cpp
+#define MAX_ENTITY 258
+static const struct { const char *name; quint16 code; } entities[MAX_ENTITY]= {
+ { "AElig", 0x00c6 },
+ { "Aacute", 0x00c1 },
+ { "Acirc", 0x00c2 },
+ { "Agrave", 0x00c0 },
+ { "Alpha", 0x0391 },
+ { "AMP", 38 },
+ { "Aring", 0x00c5 },
+ { "Atilde", 0x00c3 },
+ { "Auml", 0x00c4 },
+ { "Beta", 0x0392 },
+ { "Ccedil", 0x00c7 },
+ { "Chi", 0x03a7 },
+ { "Dagger", 0x2021 },
+ { "Delta", 0x0394 },
+ { "ETH", 0x00d0 },
+ { "Eacute", 0x00c9 },
+ { "Ecirc", 0x00ca },
+ { "Egrave", 0x00c8 },
+ { "Epsilon", 0x0395 },
+ { "Eta", 0x0397 },
+ { "Euml", 0x00cb },
+ { "Gamma", 0x0393 },
+ { "GT", 62 },
+ { "Iacute", 0x00cd },
+ { "Icirc", 0x00ce },
+ { "Igrave", 0x00cc },
+ { "Iota", 0x0399 },
+ { "Iuml", 0x00cf },
+ { "Kappa", 0x039a },
+ { "Lambda", 0x039b },
+ { "LT", 60 },
+ { "Mu", 0x039c },
+ { "Ntilde", 0x00d1 },
+ { "Nu", 0x039d },
+ { "OElig", 0x0152 },
+ { "Oacute", 0x00d3 },
+ { "Ocirc", 0x00d4 },
+ { "Ograve", 0x00d2 },
+ { "Omega", 0x03a9 },
+ { "Omicron", 0x039f },
+ { "Oslash", 0x00d8 },
+ { "Otilde", 0x00d5 },
+ { "Ouml", 0x00d6 },
+ { "Phi", 0x03a6 },
+ { "Pi", 0x03a0 },
+ { "Prime", 0x2033 },
+ { "Psi", 0x03a8 },
+ { "QUOT", 34 },
+ { "Rho", 0x03a1 },
+ { "Scaron", 0x0160 },
+ { "Sigma", 0x03a3 },
+ { "THORN", 0x00de },
+ { "Tau", 0x03a4 },
+ { "Theta", 0x0398 },
+ { "Uacute", 0x00da },
+ { "Ucirc", 0x00db },
+ { "Ugrave", 0x00d9 },
+ { "Upsilon", 0x03a5 },
+ { "Uuml", 0x00dc },
+ { "Xi", 0x039e },
+ { "Yacute", 0x00dd },
+ { "Yuml", 0x0178 },
+ { "Zeta", 0x0396 },
+ { "aacute", 0x00e1 },
+ { "acirc", 0x00e2 },
+ { "acute", 0x00b4 },
+ { "aelig", 0x00e6 },
+ { "agrave", 0x00e0 },
+ { "alefsym", 0x2135 },
+ { "alpha", 0x03b1 },
+ { "amp", 38 },
+ { "and", 0x22a5 },
+ { "ang", 0x2220 },
+ { "apos", 0x0027 },
+ { "aring", 0x00e5 },
+ { "asymp", 0x2248 },
+ { "atilde", 0x00e3 },
+ { "auml", 0x00e4 },
+ { "bdquo", 0x201e },
+ { "beta", 0x03b2 },
+ { "brvbar", 0x00a6 },
+ { "bull", 0x2022 },
+ { "cap", 0x2229 },
+ { "ccedil", 0x00e7 },
+ { "cedil", 0x00b8 },
+ { "cent", 0x00a2 },
+ { "chi", 0x03c7 },
+ { "circ", 0x02c6 },
+ { "clubs", 0x2663 },
+ { "cong", 0x2245 },
+ { "copy", 0x00a9 },
+ { "crarr", 0x21b5 },
+ { "cup", 0x222a },
+ { "curren", 0x00a4 },
+ { "dArr", 0x21d3 },
+ { "dagger", 0x2020 },
+ { "darr", 0x2193 },
+ { "deg", 0x00b0 },
+ { "delta", 0x03b4 },
+ { "diams", 0x2666 },
+ { "divide", 0x00f7 },
+ { "eacute", 0x00e9 },
+ { "ecirc", 0x00ea },
+ { "egrave", 0x00e8 },
+ { "empty", 0x2205 },
+ { "emsp", 0x2003 },
+ { "ensp", 0x2002 },
+ { "epsilon", 0x03b5 },
+ { "equiv", 0x2261 },
+ { "eta", 0x03b7 },
+ { "eth", 0x00f0 },
+ { "euml", 0x00eb },
+ { "euro", 0x20ac },
+ { "exist", 0x2203 },
+ { "fnof", 0x0192 },
+ { "forall", 0x2200 },
+ { "frac12", 0x00bd },
+ { "frac14", 0x00bc },
+ { "frac34", 0x00be },
+ { "frasl", 0x2044 },
+ { "gamma", 0x03b3 },
+ { "ge", 0x2265 },
+ { "gt", 62 },
+ { "hArr", 0x21d4 },
+ { "harr", 0x2194 },
+ { "hearts", 0x2665 },
+ { "hellip", 0x2026 },
+ { "iacute", 0x00ed },
+ { "icirc", 0x00ee },
+ { "iexcl", 0x00a1 },
+ { "igrave", 0x00ec },
+ { "image", 0x2111 },
+ { "infin", 0x221e },
+ { "int", 0x222b },
+ { "iota", 0x03b9 },
+ { "iquest", 0x00bf },
+ { "isin", 0x2208 },
+ { "iuml", 0x00ef },
+ { "kappa", 0x03ba },
+ { "lArr", 0x21d0 },
+ { "lambda", 0x03bb },
+ { "lang", 0x2329 },
+ { "laquo", 0x00ab },
+ { "larr", 0x2190 },
+ { "lceil", 0x2308 },
+ { "ldquo", 0x201c },
+ { "le", 0x2264 },
+ { "lfloor", 0x230a },
+ { "lowast", 0x2217 },
+ { "loz", 0x25ca },
+ { "lrm", 0x200e },
+ { "lsaquo", 0x2039 },
+ { "lsquo", 0x2018 },
+ { "lt", 60 },
+ { "macr", 0x00af },
+ { "mdash", 0x2014 },
+ { "micro", 0x00b5 },
+ { "middot", 0x00b7 },
+ { "minus", 0x2212 },
+ { "mu", 0x03bc },
+ { "nabla", 0x2207 },
+ { "nbsp", 0x00a0 },
+ { "ndash", 0x2013 },
+ { "ne", 0x2260 },
+ { "ni", 0x220b },
+ { "not", 0x00ac },
+ { "notin", 0x2209 },
+ { "nsub", 0x2284 },
+ { "ntilde", 0x00f1 },
+ { "nu", 0x03bd },
+ { "oacute", 0x00f3 },
+ { "ocirc", 0x00f4 },
+ { "oelig", 0x0153 },
+ { "ograve", 0x00f2 },
+ { "oline", 0x203e },
+ { "omega", 0x03c9 },
+ { "omicron", 0x03bf },
+ { "oplus", 0x2295 },
+ { "or", 0x22a6 },
+ { "ordf", 0x00aa },
+ { "ordm", 0x00ba },
+ { "oslash", 0x00f8 },
+ { "otilde", 0x00f5 },
+ { "otimes", 0x2297 },
+ { "ouml", 0x00f6 },
+ { "para", 0x00b6 },
+ { "part", 0x2202 },
+ { "percnt", 0x0025 },
+ { "permil", 0x2030 },
+ { "perp", 0x22a5 },
+ { "phi", 0x03c6 },
+ { "pi", 0x03c0 },
+ { "piv", 0x03d6 },
+ { "plusmn", 0x00b1 },
+ { "pound", 0x00a3 },
+ { "prime", 0x2032 },
+ { "prod", 0x220f },
+ { "prop", 0x221d },
+ { "psi", 0x03c8 },
+ { "quot", 34 },
+ { "rArr", 0x21d2 },
+ { "radic", 0x221a },
+ { "rang", 0x232a },
+ { "raquo", 0x00bb },
+ { "rarr", 0x2192 },
+ { "rceil", 0x2309 },
+ { "rdquo", 0x201d },
+ { "real", 0x211c },
+ { "reg", 0x00ae },
+ { "rfloor", 0x230b },
+ { "rho", 0x03c1 },
+ { "rlm", 0x200f },
+ { "rsaquo", 0x203a },
+ { "rsquo", 0x2019 },
+ { "sbquo", 0x201a },
+ { "scaron", 0x0161 },
+ { "sdot", 0x22c5 },
+ { "sect", 0x00a7 },
+ { "shy", 0x00ad },
+ { "sigma", 0x03c3 },
+ { "sigmaf", 0x03c2 },
+ { "sim", 0x223c },
+ { "spades", 0x2660 },
+ { "sub", 0x2282 },
+ { "sube", 0x2286 },
+ { "sum", 0x2211 },
+ { "sup1", 0x00b9 },
+ { "sup2", 0x00b2 },
+ { "sup3", 0x00b3 },
+ { "sup", 0x2283 },
+ { "supe", 0x2287 },
+ { "szlig", 0x00df },
+ { "tau", 0x03c4 },
+ { "there4", 0x2234 },
+ { "theta", 0x03b8 },
+ { "thetasym", 0x03d1 },
+ { "thinsp", 0x2009 },
+ { "thorn", 0x00fe },
+ { "tilde", 0x02dc },
+ { "times", 0x00d7 },
+ { "trade", 0x2122 },
+ { "uArr", 0x21d1 },
+ { "uacute", 0x00fa },
+ { "uarr", 0x2191 },
+ { "ucirc", 0x00fb },
+ { "ugrave", 0x00f9 },
+ { "uml", 0x00a8 },
+ { "upsih", 0x03d2 },
+ { "upsilon", 0x03c5 },
+ { "uuml", 0x00fc },
+ { "weierp", 0x2118 },
+ { "xi", 0x03be },
+ { "yacute", 0x00fd },
+ { "yen", 0x00a5 },
+ { "yuml", 0x00ff },
+ { "zeta", 0x03b6 },
+ { "zwj", 0x200d },
+ { "zwnj", 0x200c }
+};
+
+void tst_QTextDocumentFragment::html_entities_data()
+{
+ QTest::addColumn<QString>("html");
+ QTest::addColumn<quint16>("code");
+
+ for (int i = 0; i < MAX_ENTITY; ++i) {
+ QTest::newRow(entities[i].name) << QString("<pre>&") + QString::fromLatin1(entities[i].name) + QString(";</pre>")
+ << entities[i].code;
+ }
+}
+
+void tst_QTextDocumentFragment::html_entities()
+{
+ QFETCH(QString, html);
+ QFETCH(quint16, code);
+
+ setHtml(html);
+ QCOMPARE(doc->blockCount(), 1);
+ QString txt = doc->begin().text();
+ QCOMPARE(txt.length(), 1);
+ QCOMPARE(txt.at(0).unicode(), code);
+}
+
+void tst_QTextDocumentFragment::html_ignore_script()
+{
+ doc->setHtml(QString::fromLatin1("<html><script>Test</script><body>Blah</body></html>"));
+ QCOMPARE(doc->toPlainText(), QString("Blah"));
+}
+
+void tst_QTextDocumentFragment::html_directionWithHtml()
+{
+ doc->setHtml(QString::fromLatin1("<html><body><p>Test<p dir=rtl>RTL<p dir=ltr>LTR"));
+ QCOMPARE(doc->blockCount(), 3);
+
+ QTextBlock block = doc->firstBlock();
+ QVERIFY(block.blockFormat().hasProperty(QTextFormat::LayoutDirection));
+ QVERIFY(block.blockFormat().layoutDirection() == Qt::LeftToRight); // HTML default
+
+ block = block.next();
+ QVERIFY(block.blockFormat().hasProperty(QTextFormat::LayoutDirection));
+ QVERIFY(block.blockFormat().layoutDirection() == Qt::RightToLeft);
+
+ block = block.next();
+ QVERIFY(block.blockFormat().hasProperty(QTextFormat::LayoutDirection));
+ QVERIFY(block.blockFormat().layoutDirection() == Qt::LeftToRight);
+}
+
+void tst_QTextDocumentFragment::html_directionWithRichText()
+{
+ doc->setHtml(QString::fromLatin1("<p>Test<p dir=rtl>RTL<p dir=ltr>LTR"));
+ QCOMPARE(doc->blockCount(), 3);
+
+ QTextBlock block = doc->firstBlock();
+ QVERIFY(!block.blockFormat().hasProperty(QTextFormat::LayoutDirection));
+
+ block = block.next();
+ QVERIFY(block.blockFormat().hasProperty(QTextFormat::LayoutDirection));
+ QVERIFY(block.blockFormat().layoutDirection() == Qt::RightToLeft);
+
+ block = block.next();
+ QVERIFY(block.blockFormat().hasProperty(QTextFormat::LayoutDirection));
+ QVERIFY(block.blockFormat().layoutDirection() == Qt::LeftToRight);
+}
+
+void tst_QTextDocumentFragment::html_metaInBody()
+{
+ setHtml("<body>Hello<meta>World</body>");
+ QCOMPARE(doc->toPlainText(), QString("HelloWorld"));
+}
+
+void tst_QTextDocumentFragment::html_importImageWithoutAspectRatio()
+{
+ doc->setHtml("<img src=\"foo\" width=\"100%\" height=\"43\">");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().isImageFormat());
+ QTextImageFormat fmt = cursor.charFormat().toImageFormat();
+ // qDebug() << fmt.width() << fmt.height();
+ QVERIFY (fmt.hasProperty(QTextFormat::ImageWidth));
+ QCOMPARE (fmt.height(), 43.);
+
+ doc->setHtml("<img src=\"foo\" height=\"43\">");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().isImageFormat());
+ fmt = cursor.charFormat().toImageFormat();
+ QVERIFY (! fmt.hasProperty(QTextFormat::ImageWidth));
+ QCOMPARE (fmt.height(), 43.);
+
+ doc->setHtml("<img src=\"foo\" width=\"200\">");
+ cursor.movePosition(QTextCursor::Start);
+ cursor.movePosition(QTextCursor::NextCharacter);
+ QVERIFY(cursor.charFormat().isImageFormat());
+ fmt = cursor.charFormat().toImageFormat();
+ QVERIFY (! fmt.hasProperty(QTextFormat::ImageHeight));
+ QCOMPARE (fmt.width(), 200.);
+}
+
+void tst_QTextDocumentFragment::html_fromFirefox()
+{
+ // if you have a html loaded in firefox like <html>Test\nText</html> then selecting all and copying will
+ // result in the following text on the clipboard (for text/html)
+ doc->setHtml(QString::fromLatin1("<!--StartFragment-->Test\nText\n\n<!--EndFragment-->"));
+ QCOMPARE(doc->toPlainText(), QString::fromLatin1("Test Text "));
+}
+
+QTEST_MAIN(tst_QTextDocumentFragment)
+#include "tst_qtextdocumentfragment.moc"