diff options
Diffstat (limited to 'tests/auto/qtextdocumentfragment')
3 files changed, 4031 insertions, 0 deletions
diff --git a/tests/auto/qtextdocumentfragment/.gitignore b/tests/auto/qtextdocumentfragment/.gitignore new file mode 100644 index 0000000..5c56983 --- /dev/null +++ b/tests/auto/qtextdocumentfragment/.gitignore @@ -0,0 +1 @@ +tst_qtextdocumentfragment diff --git a/tests/auto/qtextdocumentfragment/qtextdocumentfragment.pro b/tests/auto/qtextdocumentfragment/qtextdocumentfragment.pro new file mode 100644 index 0000000..5df1937 --- /dev/null +++ b/tests/auto/qtextdocumentfragment/qtextdocumentfragment.pro @@ -0,0 +1,5 @@ +load(qttest_p4) +SOURCES += tst_qtextdocumentfragment.cpp + + + diff --git a/tests/auto/qtextdocumentfragment/tst_qtextdocumentfragment.cpp b/tests/auto/qtextdocumentfragment/tst_qtextdocumentfragment.cpp new file mode 100644 index 0000000..bace7b4 --- /dev/null +++ b/tests/auto/qtextdocumentfragment/tst_qtextdocumentfragment.cpp @@ -0,0 +1,4025 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** Contact: Qt Software Information (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 either Technology Preview License Agreement or the +** Beta Release License Agreement. +** +** 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.0, included in the file LGPL_EXCEPTION.txt in this +** package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you are unsure which license is appropriate for your use, please +** contact the sales department at qt-sales@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>"); +#if QT_VERSION <= 0x040100 + QEXPECT_FAIL("", "Fixed in >= 4.1.1", Continue); +#endif + 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() +{ +#if QT_VERSION <= 0x040100 + QEXPECT_FAIL("", "Fixed in >= 4.1.1", Abort); +#endif + { + 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); +#if QT_VERSION <= 0x040100 + QEXPECT_FAIL("", "Fixed in >= 4.1.1", Abort); +#endif + QCOMPARE(table->rows(), 2); + +#if QT_VERISON >= 0x040200 + QVERIFY(table->format().headerRowCount(), 1); +#endif + + 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() +{ +#if QT_VERSION > 0x040100 + 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")); +#endif +} + +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); + + // 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" |