Respect TextEdit.textFormat in TextDocument load(); detect format

Don't load rich text if TextEdit.textFormat is PlainText. Thus it
should be possible to have two independent TextEdit instances with
independent document instances, viewing the same source file: the
raw syntax and the rich/WYSIWYG formatting visible at the same time.

Also, after the QQuickTextDocument's QTextDocument has already loaded
the declared source, don't let QQuickTextEdit::componentComplete()
replace it with empty text from the (unbound) TextEdit.text property.
That was happening only if textFormat was RichText or MarkdownText.

In case the user transitions TextEdit.textFormat from AutoText to any
other, the text property now holds the format that was loaded from
TextDocument.source; QQuickTextDocumentPrivate remembers the format
rather than the mime type (because QMimeType is an optional feature in
Qt); and TextEdit functions such as getFormattedText(), insert() and
append() behave as if the textFormat property had been appropriate for
the loaded file type in the first place.  We cannot algorithmically
detect markdown text by looking at the text itself; but now,
QQuickTextDocumentPrivate::load() can populate markdown or html text
into the document by detecting the file's mime type, even if the
textFormat is AutoText. After that, if the user changes the textFormat
to PlainText, we assume that they want to see the raw markdown or HTML.

Amends b46d6a75ac16089de1a29c773e7594a82ffea13e : it already seemed odd
at the time that it was OK for QQuickTextDocumentPrivate::load() to load
any text format, without first changing TextEdit.textFormat to match
what's expected. The default is PlainText, so it didn't make sense to
read e.g. a markdown file and have the result look like WYSIWYG rich
text. Now you have to change textFormat to MarkdownText or AutoText
beforehand if you want to see WYSIWYG; and
tst_qquicktextdocument::sourceAndSave() needs to do that too.

On the other hand, if you switch textFormat to PlainText, we convert the
QTextDocument to plain text, using Qt-generated markup/markdown syntax.
Maybe the user would prefer to have the original syntax as read from
the file; but so far it has always been this way: we just parse it,
we don't store it. We are quite incapable of incrementally modifying
the original syntax anyway: we can only regenerate it wholesale.
So it makes sense that the text property holds Qt-generated syntax
after the parsing is done.

Pick-to: 6.7
Fixes: QTBUG-120772
Change-Id: I7db533c714e14bb4eb36745996c732e5162fb9cf
Reviewed-by: Oliver Eftevaag <oliver.eftevaag@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>

4 files changed, 285 insertions, 14 deletions

diff --git a/tests/auto/quick/qquicktextdocument/data/sideBySideIndependent.qml b/tests/auto/quick/qquicktextdocument/data/sideBySideIndependent.qml
new file mode 100644
index 0000000000..8275e7f5bd
--- /dev/null
+++ b/tests/auto/quick/qquicktextdocument/data/sideBySideIndependent.qml
@@ -0,0 +1,21 @@
+import QtQuick
+
+Row {
+    width: 480; height: 200
+    TextEdit {
+        objectName: "plain"
+        width: parent.width / 2 - 1
+        textFormat: TextEdit.PlainText
+        textDocument.source: "hello.md"
+    }
+    Rectangle {
+        width: 2; height: parent.height
+        color: "lightsteelblue"
+    }
+    TextEdit {
+        objectName: "markdown"
+        width: parent.width / 2 - 1
+        textFormat: TextEdit.MarkdownText
+        textDocument.source: "hello.md"
+    }
+}
diff --git a/tests/auto/quick/qquicktextdocument/data/sideBySideIndependentReverse.qml b/tests/auto/quick/qquicktextdocument/data/sideBySideIndependentReverse.qml
new file mode 100644
index 0000000000..cbd92accec
--- /dev/null
+++ b/tests/auto/quick/qquicktextdocument/data/sideBySideIndependentReverse.qml
@@ -0,0 +1,21 @@
+import QtQuick
+
+Row {
+    width: 480; height: 200
+    TextEdit {
+        objectName: "plain"
+        width: parent.width / 2 - 1
+        textDocument.source: "hello.md"
+        textFormat: TextEdit.PlainText
+    }
+    Rectangle {
+        width: 2; height: parent.height
+        color: "lightsteelblue"
+    }
+    TextEdit {
+        objectName: "markdown"
+        width: parent.width / 2 - 1
+        textDocument.source: "hello.md"
+        textFormat: TextEdit.MarkdownText
+    }
+}
diff --git a/tests/auto/quick/qquicktextdocument/tst_qquicktextdocument.cpp b/tests/auto/quick/qquicktextdocument/tst_qquicktextdocument.cpp
index f477780980..f88741737e 100644
--- a/tests/auto/quick/qquicktextdocument/tst_qquicktextdocument.cpp
+++ b/tests/auto/quick/qquicktextdocument/tst_qquicktextdocument.cpp
@@ -3,8 +3,9 @@
 
 #include <qtest.h>
 #include <QtTest/QtTest>
-#include <QtQuick/QQuickTextDocument>
 #include <QtQuick/QQuickItem>
+#include <QtQuick/QQuickTextDocument>
+#include <QtQuick/QQuickView>
 #include <QtQuick/private/qquicktextdocument_p.h>
 #include <QtQuick/private/qquicktextedit_p.h>
 #include <QtQuick/private/qquicktextedit_p_p.h>
@@ -16,6 +17,7 @@
 #include <QtQml/QQmlEngine>
 #include <QtQml/QQmlFile>
 #include <QtQuickTestUtils/private/qmlutils_p.h>
+#include <QtQuickTestUtils/private/viewtestutils_p.h>
 #ifdef Q_OS_UNIX
 #include <unistd.h>
 #endif
@@ -30,6 +32,10 @@ class tst_qquicktextdocument : public QQmlDataTest
 public:
     tst_qquicktextdocument();
 
+private:
+    QPair<int, int> fragmentsAndItalics(const QTextDocument *doc);
+    bool isMainFontFixed();
+
 private slots:
     void textDocumentWriter();
     void customDocument();
@@ -37,6 +43,10 @@ private slots:
     void sourceAndSave();
     void loadErrorNoSuchFile();
     void loadErrorPermissionDenied();
+    void overrideTextFormat_data();
+    void overrideTextFormat();
+    void independentDocumentsSameSource_data();
+    void independentDocumentsSameSource();
 };
 
 QString text = QStringLiteral("foo bar");
@@ -79,6 +89,34 @@ tst_qquicktextdocument::tst_qquicktextdocument()
 {
 }
 
+/*! \internal
+    Returns {fragmentCount, italicFragmentIndex}. If no italic fragment is found,
+    italicFragmentIndex is -1.
+*/
+QPair<int, int> tst_qquicktextdocument::fragmentsAndItalics(const QTextDocument *doc)
+{
+    int fragmentCount = 0;
+    int italicFragment = -1;
+    for (QTextBlock::iterator it = doc->firstBlock().begin(); !(it.atEnd()); ++it) {
+        QTextFragment currentFragment = it.fragment();
+        if (currentFragment.charFormat().fontItalic())
+            italicFragment = fragmentCount;
+        ++fragmentCount;
+        qCDebug(lcTests) << (currentFragment.charFormat().fontItalic() ? "italic" : "roman") << currentFragment.text();
+    }
+    return {fragmentCount, italicFragment};
+}
+
+bool tst_qquicktextdocument::isMainFontFixed()
+{
+    bool ret = QFontInfo(QGuiApplication::font()).fixedPitch();
+    if (ret) {
+        qCWarning(lcTests) << "QFontDatabase::GeneralFont is monospaced: markdown writing is likely to use too many backticks"
+                           << QFontDatabase::systemFont(QFontDatabase::GeneralFont);
+    }
+    return ret;
+}
+
 void tst_qquicktextdocument::textDocumentWriter()
 {
     QQmlEngine e;
@@ -161,31 +199,33 @@ void tst_qquicktextdocument::customDocument()
 
 void tst_qquicktextdocument::sourceAndSave_data()
 {
+    QTest::addColumn<QQuickTextEdit::TextFormat>("textFormat");
     QTest::addColumn<QString>("source");
     QTest::addColumn<std::optional<QStringConverter::Encoding>>("expectedEncoding");
-    QTest::addColumn<QString>("expectedMimeType");
+    QTest::addColumn<QQuickTextEdit::TextFormat>("expectedTextFormat");
     QTest::addColumn<int>("minCharCount");
     QTest::addColumn<QString>("expectedPlainText");
 
     const std::optional<QStringConverter::Encoding> nullEnc;
 
-    QTest::newRow("plain") << "hello.txt"
-        << nullEnc << "text/plain" << 15 << u"Γειά σου Κόσμε!"_s;
-    QTest::newRow("markdown") << "hello.md"
-        << nullEnc << "text/markdown" << 15 << u"Γειά σου Κόσμε!"_s;
-    QTest::newRow("html") << "hello.html"
+    QTest::newRow("plain") << QQuickTextEdit::PlainText << "hello.txt"
+        << nullEnc << QQuickTextEdit::PlainText << 15 << u"Γειά σου Κόσμε!"_s;
+    QTest::newRow("markdown") << QQuickTextEdit::MarkdownText << "hello.md"
+        << nullEnc << QQuickTextEdit::MarkdownText << 15 << u"Γειά σου Κόσμε!"_s;
+    QTest::newRow("html") << QQuickTextEdit::RichText << "hello.html"
         << std::optional<QStringConverter::Encoding>(QStringConverter::Utf8)
-        << "text/html" << 15 << u"Γειά σου Κόσμε!"_s;
-    QTest::newRow("html-utf16be") << "hello-utf16be.html"
+        << QQuickTextEdit::RichText << 15 << u"Γειά σου Κόσμε!"_s;
+    QTest::newRow("html-utf16be") << QQuickTextEdit::AutoText << "hello-utf16be.html"
         << std::optional<QStringConverter::Encoding>(QStringConverter::Utf16BE)
-        << "text/html" << 15 << u"Γειά σου Κόσμε!"_s;
+        << QQuickTextEdit::RichText << 15 << u"Γειά σου Κόσμε!"_s;
 }
 
 void tst_qquicktextdocument::sourceAndSave()
 {
+    QFETCH(QQuickTextEdit::TextFormat, textFormat);
     QFETCH(QString, source);
     QFETCH(std::optional<QStringConverter::Encoding>, expectedEncoding);
-    QFETCH(QString, expectedMimeType);
+    QFETCH(QQuickTextEdit::TextFormat, expectedTextFormat);
     QFETCH(int, minCharCount);
     QFETCH(QString, expectedPlainText);
 
@@ -219,14 +259,14 @@ void tst_qquicktextdocument::sourceAndSave()
 
     QCOMPARE(statusChangedSpy.size(), 0);
     QCOMPARE(qqdoc->status(), QQuickTextDocument::Status::Null);
+    textEdit->setTextFormat(textFormat);
     qqdoc->setProperty("source", QUrl::fromLocalFile(tmpPath));
     QCOMPARE(sourceChangedSpy.size(), 1);
     QCOMPARE(textEdit->property("sourceChangeCount").toInt(), 1);
     QCOMPARE(statusChangedSpy.size(), 2); // Loading, then Loaded
     QCOMPARE(qqdoc->status(), QQuickTextDocument::Status::Loaded);
     const auto *qqdp = QQuickTextDocumentPrivate::get(qqdoc);
-    QVERIFY(qqdp->mimeType.inherits(expectedMimeType));
-    const bool expectHtml = (expectedMimeType == "text/html");
+    QCOMPARE(qqdp->detectedFormat, expectedTextFormat);
     QCOMPARE_GE(doc->characterCount(), minCharCount);
     QCOMPARE(doc->toPlainText().trimmed(), expectedPlainText);
     QCOMPARE(qqdp->encoding, expectedEncoding);
@@ -246,7 +286,7 @@ void tst_qquicktextdocument::sourceAndSave()
     QFile tf(tmpPath);
     QVERIFY(tf.open(QIODeviceBase::ReadOnly));
     auto readBack = tf.readAll();
-    if (expectHtml) {
+    if (expectedTextFormat == Qt::RichText) {
         QStringDecoder dec(*expectedEncoding);
         const QString decStr = dec(readBack);
         QVERIFY(decStr.contains("hello!</p>"));
@@ -323,6 +363,194 @@ void tst_qquicktextdocument::loadErrorPermissionDenied()
     QCOMPARE(qqdoc->status(), QQuickTextDocument::Status::ReadError);
 }
 
+void tst_qquicktextdocument::overrideTextFormat_data()
+{
+    QTest::addColumn<QUrl>("qmlfile");
+    QTest::addColumn<QQuickTextEdit::TextFormat>("initialFormat");
+    QTest::addColumn<QUrl>("source");
+    QTest::addColumn<int>("expectedInitialFragmentCount");
+    QTest::addColumn<int>("expectedInitialItalicFragment");
+    // first part of TextEdit.text after loading
+    QTest::addColumn<QString>("expectedTextPrefix");
+
+    QTest::addColumn<QQuickTextEdit::TextFormat>("replacementFormat");
+    QTest::addColumn<int>("expectedFragmentCount");
+    QTest::addColumn<int>("expectedItalicFragment");
+    // first part of TextEdit.text after switching to replacementFormat
+    QTest::addColumn<QString>("expectedReplacementPrefix");
+
+    QTest::addColumn<QQuickTextEdit::TextFormat>("finalFormat");
+    QTest::addColumn<int>("expectedFinalFragmentCount");
+    QTest::addColumn<int>("expectedFinalItalicFragment");
+    // first part of TextEdit.text after switching to finalFormat
+    QTest::addColumn<QString>("expectedFinalPrefix");
+
+    QTest::newRow("load md, switch to plain, back to md")
+            << testFileUrl("text.qml") << QQuickTextEdit::MarkdownText << testFileUrl("hello.md")
+            << 3 << 1 << u"Γειά σου *Κόσμε*!"_s
+            << QQuickTextEdit::PlainText << 1 << -1 << u"Γειά σου *Κόσμε*!"_s
+            << QQuickTextEdit::MarkdownText << 3 << 1 << u"Γειά σου *Κόσμε*!"_s;
+    QTest::newRow("load md, switch to plain, then auto")
+            << testFileUrl("text.qml") << QQuickTextEdit::MarkdownText << testFileUrl("hello.md")
+            << 3 << 1 << u"Γειά σου *Κόσμε*!"_s
+            << QQuickTextEdit::PlainText << 1 << -1 << u"Γειά σου *Κόσμε*!"_s
+            << QQuickTextEdit::AutoText << 3 << 1 << u"Γειά σου Κόσμε!"_s;
+    QTest::newRow("load md, switch to html, then plain")
+            << testFileUrl("text.qml") << QQuickTextEdit::MarkdownText << testFileUrl("hello.md")
+            << 3 << 1 << u"Γειά σου *Κόσμε*!"_s
+            << QQuickTextEdit::RichText << 1 << -1 << u"<!DOCTYPE HTML"_s // throws away formatting, unfortunately
+            << QQuickTextEdit::PlainText << 1 << -1 << u"<!DOCTYPE HTML"_s;
+    QTest::newRow("load md as plain text, switch to md, back to plain")
+            << testFileUrl("text.qml") << QQuickTextEdit::PlainText << testFileUrl("hello.md")
+            << 1 << -1 << u"Γειά σου *Κόσμε*!"_s
+            << QQuickTextEdit::MarkdownText << 3 << 1 << u"Γειά σου *Κόσμε*!"_s
+            << QQuickTextEdit::PlainText << 1 << -1 << u"Γειά σου *Κόσμε*!"_s;
+    QTest::newRow("load md as autotext, switch to plain, back to auto")
+            << testFileUrl("text.qml") << QQuickTextEdit::AutoText << testFileUrl("hello.md")
+            << 3 << 1 << u"Γειά σου *Κόσμε*!"_s
+            << QQuickTextEdit::PlainText << 1 << -1 << u"Γειά σου *Κόσμε*!"_s
+            << QQuickTextEdit::AutoText << 3 << 1 << u"Γειά σου Κόσμε!"_s;
+    QTest::newRow("load md as autotext, switch to md, then plain")
+            << testFileUrl("text.qml") << QQuickTextEdit::AutoText << testFileUrl("hello.md")
+            << 3 << 1 << u"Γειά σου *Κόσμε*!"_s
+            << QQuickTextEdit::MarkdownText << 3 << 1 << u"Γειά σου *Κόσμε*!"_s
+            << QQuickTextEdit::PlainText << 1 << -1 << u"Γειά σου *Κόσμε*!"_s;
+    QTest::newRow("load md as autotext, switch to html, then plain")
+            << testFileUrl("text.qml") << QQuickTextEdit::AutoText << testFileUrl("hello.md")
+            << 3 << 1 << u"Γειά σου *Κόσμε*!"_s
+            << QQuickTextEdit::RichText << 3 << 1 << u"<!DOCTYPE HTML"_s
+            << QQuickTextEdit::PlainText << 1 << -1 << u"<!DOCTYPE HTML"_s;
+
+    QTest::newRow("load html, switch to plain, back to rich")
+            << testFileUrl("text.qml") << QQuickTextEdit::RichText << testFileUrl("hello.html")
+            << 3 << 1 << u"<!DOCTYPE HTML"_s
+            << QQuickTextEdit::PlainText << 1 << -1 << u"<!DOCTYPE HTML"_s
+            << QQuickTextEdit::RichText << 3 << 1 << u"<!DOCTYPE HTML"_s;
+    QTest::newRow("load html as plain text, switch to html, back to plain")
+            << testFileUrl("text.qml") << QQuickTextEdit::PlainText << testFileUrl("hello.html")
+            << 1 << -1 << u"Γειά σου <i>Κόσμε</i>!"_s
+            << QQuickTextEdit::RichText << 3 << 1 << u"<!DOCTYPE HTML"_s
+            << QQuickTextEdit::PlainText << 1 << -1 << u"<!DOCTYPE HTML"_s;
+    QTest::newRow("load html as autotext, switch to plain, back to auto")
+            << testFileUrl("text.qml") << QQuickTextEdit::AutoText << testFileUrl("hello.html")
+            << 3 << 1 << u"<!DOCTYPE HTML"_s
+            << QQuickTextEdit::PlainText << 1 << -1 << u"<!DOCTYPE HTML"_s
+            << QQuickTextEdit::AutoText << 3 << 1 << u"<!DOCTYPE HTML"_s;
+    QTest::newRow("load html as autotext, switch to html, then plain")
+            << testFileUrl("text.qml") << QQuickTextEdit::AutoText << testFileUrl("hello.html")
+            << 3 << 1 << u"<!DOCTYPE HTML"_s
+            << QQuickTextEdit::RichText << 3 << 1 << u"<!DOCTYPE HTML"_s
+            << QQuickTextEdit::PlainText << 1 << -1 << u"<!DOCTYPE HTML"_s;
+    QTest::newRow("load html as autotext, switch to markdown, then plain")
+            << testFileUrl("text.qml") << QQuickTextEdit::AutoText << testFileUrl("hello.html")
+            << 3 << 1 << u"<!DOCTYPE HTML"_s
+            << QQuickTextEdit::MarkdownText << 3 << 1 << u"Γειά σου *Κόσμε*!"_s
+            << QQuickTextEdit::PlainText << 1 << -1 << u"Γειά σου *Κόσμε*!"_s;
+}
+
+void tst_qquicktextdocument::overrideTextFormat() // QTBUG-120772
+{
+    if (isMainFontFixed())
+        QSKIP("fixed-pitch main font (QTBUG-103484)");
+
+    QFETCH(QUrl, qmlfile);
+    QFETCH(QQuickTextEdit::TextFormat, initialFormat);
+    QFETCH(QUrl, source);
+    QFETCH(int, expectedInitialFragmentCount);
+    QFETCH(int, expectedInitialItalicFragment);
+    QFETCH(QString, expectedTextPrefix);
+
+    QFETCH(QQuickTextEdit::TextFormat, replacementFormat);
+    QFETCH(int, expectedFragmentCount);
+    QFETCH(int, expectedItalicFragment);
+    QFETCH(QString, expectedReplacementPrefix);
+
+    QFETCH(QQuickTextEdit::TextFormat, finalFormat);
+    QFETCH(int, expectedFinalFragmentCount);
+    QFETCH(int, expectedFinalItalicFragment);
+    QFETCH(QString, expectedFinalPrefix);
+
+    QQuickView window;
+    QVERIFY(QQuickTest::showView(window, qmlfile));
+    QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit *>(window.rootObject());
+    QVERIFY(textEdit);
+    QQuickTextDocument *qqdoc = textEdit->property("textDocument").value<QQuickTextDocument*>();
+    QVERIFY(qqdoc);
+    QTextDocument *doc = qqdoc->textDocument();
+    QVERIFY(doc);
+
+    textEdit->setTextFormat(initialFormat);
+    QCOMPARE(qqdoc->isModified(), false);
+    QCOMPARE(textEdit->property("sourceChangeCount").toInt(), 0);
+    QSignalSpy sourceChangedSpy(qqdoc, &QQuickTextDocument::sourceChanged);
+    QSignalSpy textChangedSpy(textEdit, &QQuickTextEdit::textChanged);
+
+    qqdoc->setProperty("source", source);
+    QCOMPARE(sourceChangedSpy.size(), 1);
+    QCOMPARE(textEdit->property("sourceChangeCount").toInt(), 1);
+    QCOMPARE_GE(textChangedSpy.size(), 1);
+    auto fragCountAndItalic = fragmentsAndItalics(doc);
+    QCOMPARE(fragCountAndItalic.first, expectedInitialFragmentCount);
+    QCOMPARE(fragCountAndItalic.second, expectedInitialItalicFragment);
+    QString textPropValue = textEdit->text();
+    qCDebug(lcTests) << "expect text()" << textPropValue.first(qMin(20, textPropValue.size() - 1))
+                     << "to start with" << expectedTextPrefix;
+    QVERIFY(textPropValue.startsWith(expectedTextPrefix));
+
+    textEdit->setTextFormat(replacementFormat);
+    QCOMPARE(qqdoc->isModified(), false);
+    QCOMPARE(sourceChangedSpy.size(), 1);
+    QCOMPARE_GE(textChangedSpy.size(), 2); // loading and then the format change
+    fragCountAndItalic = fragmentsAndItalics(doc);
+    QCOMPARE(fragCountAndItalic.first, expectedFragmentCount);
+    QCOMPARE(fragCountAndItalic.second, expectedItalicFragment);
+    textPropValue = textEdit->text();
+    qCDebug(lcTests) << "expect text()" << textPropValue.first(qMin(20, textPropValue.size() - 1))
+                     << "to start with" << expectedReplacementPrefix;
+    QVERIFY(textPropValue.startsWith(expectedReplacementPrefix));
+
+    textEdit->setTextFormat(finalFormat);
+    QCOMPARE(qqdoc->isModified(), false);
+    QCOMPARE(sourceChangedSpy.size(), 1);
+    QCOMPARE_GE(textChangedSpy.size(), 3);
+    fragCountAndItalic = fragmentsAndItalics(doc);
+    QCOMPARE(fragCountAndItalic.first, expectedFinalFragmentCount);
+    QCOMPARE(fragCountAndItalic.second, expectedFinalItalicFragment);
+    textPropValue = textEdit->text();
+    qCDebug(lcTests) << "expect text()" << textPropValue.first(qMin(20, textPropValue.size() - 1))
+                     << "to start with" << expectedFinalPrefix;
+    QVERIFY(textPropValue.startsWith(expectedFinalPrefix));
+}
+
+void tst_qquicktextdocument::independentDocumentsSameSource_data()
+{
+    QTest::addColumn<QUrl>("qmlfile");
+
+    QTest::newRow("textFormat above source") << testFileUrl("sideBySideIndependent.qml");
+    QTest::newRow("source above textFormat") << testFileUrl("sideBySideIndependentReverse.qml");
+}
+
+// ensure that two TextEdits' textFormat properties take effect, regardless of qml init order
+void tst_qquicktextdocument::independentDocumentsSameSource() // QTBUG-120772
+{
+    QFETCH(QUrl, qmlfile);
+
+    QQuickView window;
+    QVERIFY(QQuickTest::showView(window, qmlfile));
+    QQuickTextEdit *textEditPlain = window.rootObject()->findChild<QQuickTextEdit *>("plain");
+    QVERIFY(textEditPlain);
+    QQuickTextEdit *textEditMarkdown = window.rootObject()->findChild<QQuickTextEdit *>("markdown");
+    QVERIFY(textEditMarkdown);
+
+    auto fragCountAndItalic = fragmentsAndItalics(textEditPlain->textDocument()->textDocument());
+    QCOMPARE(fragCountAndItalic.first, 1);
+    QCOMPARE(fragCountAndItalic.second, -1);
+
+    fragCountAndItalic = fragmentsAndItalics(textEditMarkdown->textDocument()->textDocument());
+    QCOMPARE(fragCountAndItalic.first, 3);
+    QCOMPARE(fragCountAndItalic.second, 1);
+}
+
 QTEST_MAIN(tst_qquicktextdocument)
 
 #include "tst_qquicktextdocument.moc"
diff --git a/tests/auto/quick/qquicktextedit/tst_qquicktextedit.cpp b/tests/auto/quick/qquicktextedit/tst_qquicktextedit.cpp
index c39bb3ea21..6dcff765c1 100644
--- a/tests/auto/quick/qquicktextedit/tst_qquicktextedit.cpp
+++ b/tests/auto/quick/qquicktextedit/tst_qquicktextedit.cpp
@@ -6125,6 +6125,7 @@ void tst_qquicktextedit::remoteImagesInDocumentSource()
 
     QTest::ignoreMessage(QtWarningMsg, QRegularExpression(".*Protocol \"gopher\" is unknown"));
     QTest::ignoreMessage(QtWarningMsg, QRegularExpression(".*Connection closed")); // httpfail/warning.png
+    textEdit->setTextFormat(QQuickTextEdit::MarkdownText);
     textEdit->textDocument()->setSource(QUrl::fromLocalFile(tmpPath));
 
     // the document gets loaded first, then the resources