Long live Qt 4.5!

1 files changed, 1475 insertions, 0 deletions

diff --git a/tests/auto/qplaintextedit/tst_qplaintextedit.cpp b/tests/auto/qplaintextedit/tst_qplaintextedit.cpp
new file mode 100644
index 0000000..a0250fa
--- /dev/null
+++ b/tests/auto/qplaintextedit/tst_qplaintextedit.cpp
@@ -0,0 +1,1475 @@
+/****************************************************************************
+**
+** 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 <qtextedit.h>
+#include <qtextcursor.h>
+#include <qtextlist.h>
+#include <qdebug.h>
+#include <qapplication.h>
+#include <qclipboard.h>
+#include <qtextbrowser.h>
+#include <private/qtextcontrol_p.h>
+#include <qscrollbar.h>
+#include <qtextobject.h>
+
+#include <qabstracttextdocumentlayout.h>
+#include <qtextdocumentfragment.h>
+
+#include "qplaintextedit.h"
+
+//Used in copyAvailable
+typedef QPair<Qt::Key, Qt::KeyboardModifier> keyPairType;
+typedef QList<keyPairType> pairListType;
+Q_DECLARE_METATYPE(pairListType);
+Q_DECLARE_METATYPE(keyPairType);
+Q_DECLARE_METATYPE(QList<bool>);
+
+#ifdef Q_WS_MAC
+#include <Carbon/Carbon.h>
+#endif
+
+QT_FORWARD_DECLARE_CLASS(QPlainTextEdit)
+
+//TESTED_CLASS=
+//TESTED_FILES=gui/widgets/qtextedit.h gui/widgets/qtextedit.cpp
+
+class tst_QPlainTextEdit : public QObject
+{
+    Q_OBJECT
+public:
+    tst_QPlainTextEdit();
+
+public slots:
+    void initTestCase();
+    void init();
+    void cleanup();
+private slots:
+    void getSetCheck();
+    void clearMustNotChangeClipboard();
+    void clearMustNotResetRootFrameMarginToDefault();
+    void paragSeparatorOnPlaintextAppend();
+    void selectAllSetsNotSelection();
+    void asciiTab();
+    void setDocument();
+    void emptyAppend();
+    void appendOnEmptyDocumentShouldReuseInitialParagraph();
+    void cursorPositionChanged();
+    void setTextCursor();
+    void undoAvailableAfterPaste();
+    void undoRedoAvailableRepetition();
+    void appendShouldNotTouchTheSelection();
+    void backspace();
+    void shiftBackspace();
+    void undoRedo();
+    void preserveCharFormatInAppend();
+    void copyAndSelectAllInReadonly();
+    void ctrlAltInput();
+    void noPropertiesOnDefaultTextEditCharFormat();
+    void setPlainTextShouldEmitTextChangedOnce();
+    void overwriteMode();
+    void shiftDownInLineLastShouldSelectToEnd_data();
+    void shiftDownInLineLastShouldSelectToEnd();
+    void undoRedoShouldRepositionTextEditCursor();
+    void lineWrapModes();
+    void mouseCursorShape();
+    void implicitClear();
+    void undoRedoAfterSetContent();
+    void numPadKeyNavigation();
+    void moveCursor();
+    void mimeDataReimplementations();
+    void shiftEnterShouldInsertLineSeparator();
+    void selectWordsFromStringsContainingSeparators_data();
+    void selectWordsFromStringsContainingSeparators();
+    void canPaste();
+    void copyAvailable_data();
+    void copyAvailable();
+    void ensureCursorVisibleOnInitialShow();
+    void setTextInsideResizeEvent();
+    void colorfulAppend();
+    void ensureVisibleWithRtl();
+    void preserveCharFormatAfterSetPlainText();
+    void extraSelections();
+    void adjustScrollbars();
+    void textObscuredByScrollbars();
+    void setTextPreservesUndoRedoEnabled();
+    void wordWrapProperty();
+    void lineWrapProperty();
+    void selectionChanged();
+    void blockCountChanged();
+
+private:
+    void createSelection();
+    int blockCount() const;
+    int lineCount() const;
+    bool nativeClipboardWorking();
+
+    QPlainTextEdit *ed;
+    qreal rootFrameMargin;
+};
+
+bool tst_QPlainTextEdit::nativeClipboardWorking()
+{
+#ifdef Q_WS_MAC
+    PasteboardRef pasteboard;
+    OSStatus status = PasteboardCreate(0, &pasteboard);
+    if (status == noErr)
+        CFRelease(pasteboard);
+    return status == noErr;
+#endif
+    return true;
+}
+
+// Testing get/set functions
+void tst_QPlainTextEdit::getSetCheck()
+{
+    QPlainTextEdit obj1;
+    // QTextDocument * QPlainTextEdit::document()
+    // void QPlainTextEdit::setDocument(QTextDocument *)
+    QTextDocument *var1 = new QTextDocument;
+    var1->setDocumentLayout(new QPlainTextDocumentLayout(var1));
+    obj1.setDocument(var1);
+    QCOMPARE(var1, obj1.document());
+    obj1.setDocument((QTextDocument *)0);
+    QVERIFY(var1 != obj1.document()); // QPlainTextEdit creates a new document when setting 0
+    QVERIFY((QTextDocument *)0 != obj1.document());
+    delete var1;
+
+
+    // bool QPlainTextEdit::tabChangesFocus()
+    // void QPlainTextEdit::setTabChangesFocus(bool)
+    obj1.setTabChangesFocus(false);
+    QCOMPARE(false, obj1.tabChangesFocus());
+    obj1.setTabChangesFocus(true);
+    QCOMPARE(true, obj1.tabChangesFocus());
+
+    // LineWrapMode QPlainTextEdit::lineWrapMode()
+    // void QPlainTextEdit::setLineWrapMode(LineWrapMode)
+    obj1.setLineWrapMode(QPlainTextEdit::LineWrapMode(QPlainTextEdit::NoWrap));
+    QCOMPARE(QPlainTextEdit::LineWrapMode(QPlainTextEdit::NoWrap), obj1.lineWrapMode());
+    obj1.setLineWrapMode(QPlainTextEdit::LineWrapMode(QPlainTextEdit::WidgetWidth));
+    QCOMPARE(QPlainTextEdit::LineWrapMode(QPlainTextEdit::WidgetWidth), obj1.lineWrapMode());
+//     obj1.setLineWrapMode(QPlainTextEdit::LineWrapMode(QPlainTextEdit::FixedPixelWidth));
+//     QCOMPARE(QPlainTextEdit::LineWrapMode(QPlainTextEdit::FixedPixelWidth), obj1.lineWrapMode());
+//     obj1.setLineWrapMode(QPlainTextEdit::LineWrapMode(QPlainTextEdit::FixedColumnWidth));
+//     QCOMPARE(QPlainTextEdit::LineWrapMode(QPlainTextEdit::FixedColumnWidth), obj1.lineWrapMode());
+
+
+    // bool QPlainTextEdit::overwriteMode()
+    // void QPlainTextEdit::setOverwriteMode(bool)
+    obj1.setOverwriteMode(false);
+    QCOMPARE(false, obj1.overwriteMode());
+    obj1.setOverwriteMode(true);
+    QCOMPARE(true, obj1.overwriteMode());
+
+    // int QPlainTextEdit::tabStopWidth()
+    // void QPlainTextEdit::setTabStopWidth(int)
+    obj1.setTabStopWidth(0);
+    QCOMPARE(0, obj1.tabStopWidth());
+    obj1.setTabStopWidth(INT_MIN);
+    QCOMPARE(0, obj1.tabStopWidth()); // Makes no sense to set a negative tabstop value
+#if defined(QT_ARCH_WINDOWSCE)
+    // due to rounding error in qRound when qreal==float
+    // we cannot use INT_MAX for this check
+    obj1.setTabStopWidth(SHRT_MAX*2);
+    QCOMPARE(SHRT_MAX*2, obj1.tabStopWidth());
+#else
+    obj1.setTabStopWidth(INT_MAX);
+    QCOMPARE(INT_MAX, obj1.tabStopWidth());
+#endif
+
+}
+
+class QtTestDocumentLayout : public QAbstractTextDocumentLayout
+{
+    Q_OBJECT
+public:
+    inline QtTestDocumentLayout(QPlainTextEdit *edit, QTextDocument *doc, int &itCount)
+        : QAbstractTextDocumentLayout(doc), useBiggerSize(false), ed(edit), iterationCounter(itCount) {}
+
+    virtual void draw(QPainter *, const QAbstractTextDocumentLayout::PaintContext &)  {}
+
+    virtual int hitTest(const QPointF &, Qt::HitTestAccuracy ) const { return 0; }
+
+    virtual void documentChanged(int, int, int) {}
+
+    virtual int pageCount() const { return 1; }
+
+    virtual QSizeF documentSize() const { return usedSize; }
+
+    virtual QRectF frameBoundingRect(QTextFrame *) const { return QRectF(); }
+    virtual QRectF blockBoundingRect(const QTextBlock &) const { return QRectF(); }
+
+    bool useBiggerSize;
+    QSize usedSize;
+
+    QPlainTextEdit *ed;
+
+    int &iterationCounter;
+};
+
+tst_QPlainTextEdit::tst_QPlainTextEdit()
+{}
+
+void tst_QPlainTextEdit::initTestCase()
+{
+#ifdef Q_OS_WINCE //disable magic for WindowsCE
+    qApp->setAutoMaximizeThreshold(-1);
+#endif
+}
+
+void tst_QPlainTextEdit::init()
+{
+    ed = new QPlainTextEdit(0);
+    rootFrameMargin = ed->document()->documentMargin();
+}
+
+void tst_QPlainTextEdit::cleanup()
+{
+    delete ed;
+    ed = 0;
+}
+
+
+void tst_QPlainTextEdit::createSelection()
+{
+    QTest::keyClicks(ed, "Hello World");
+    /* go to start */
+#ifndef Q_WS_MAC
+    QTest::keyClick(ed, Qt::Key_Home, Qt::ControlModifier);
+#else
+    QTest::keyClick(ed, Qt::Key_Home);
+#endif
+    QCOMPARE(ed->textCursor().position(), 0);
+    /* select until end of text */
+#ifndef Q_WS_MAC
+    QTest::keyClick(ed, Qt::Key_End, Qt::ControlModifier | Qt::ShiftModifier);
+#else
+    QTest::keyClick(ed, Qt::Key_End, Qt::ShiftModifier);
+#endif
+    QCOMPARE(ed->textCursor().position(), 11);
+}
+
+void tst_QPlainTextEdit::clearMustNotChangeClipboard()
+{
+    if (!nativeClipboardWorking())
+        QSKIP("Clipboard not working with cron-started unit tests", SkipAll);
+    ed->textCursor().insertText("Hello World");
+    QString txt("This is different text");
+    QApplication::clipboard()->setText(txt);
+    ed->clear();
+    QCOMPARE(QApplication::clipboard()->text(), txt);
+}
+
+void tst_QPlainTextEdit::clearMustNotResetRootFrameMarginToDefault()
+{
+    QCOMPARE(ed->document()->rootFrame()->frameFormat().margin(), rootFrameMargin);
+    ed->clear();
+    QCOMPARE(ed->document()->rootFrame()->frameFormat().margin(), rootFrameMargin);
+}
+
+
+void tst_QPlainTextEdit::paragSeparatorOnPlaintextAppend()
+{
+    ed->appendPlainText("Hello\nWorld");
+    int cnt = 0;
+    QTextBlock blk = ed->document()->begin();
+    while (blk.isValid()) {
+        ++cnt;
+        blk = blk.next();
+    }
+    QCOMPARE(cnt, 2);
+}
+
+void tst_QPlainTextEdit::selectAllSetsNotSelection()
+{
+    if (!QApplication::clipboard()->supportsSelection()) {
+        QSKIP("Test only relevant for systems with selection", SkipAll);
+        return;
+    }
+
+    QApplication::clipboard()->setText(QString("foobar"), QClipboard::Selection);
+    QVERIFY(QApplication::clipboard()->text(QClipboard::Selection) == QString("foobar"));
+
+    ed->insertPlainText("Hello World");
+    ed->selectAll();
+
+    QCOMPARE(QApplication::clipboard()->text(QClipboard::Selection), QString::fromAscii("foobar"));
+}
+
+void tst_QPlainTextEdit::asciiTab()
+{
+    QPlainTextEdit edit;
+    edit.setPlainText("\t");
+    edit.show();
+    qApp->processEvents();
+    QCOMPARE(edit.toPlainText().at(0), QChar('\t'));
+}
+
+void tst_QPlainTextEdit::setDocument()
+{
+    QTextDocument *document = new QTextDocument(ed);
+    document->setDocumentLayout(new QPlainTextDocumentLayout(document));
+    QTextCursor(document).insertText("Test");
+    ed->setDocument(document);
+    QCOMPARE(ed->toPlainText(), QString("Test"));
+}
+
+
+int tst_QPlainTextEdit::blockCount() const
+{
+    int blocks = 0;
+    for (QTextBlock block = ed->document()->begin(); block.isValid(); block = block.next())
+        ++blocks;
+    return blocks;
+}
+
+int tst_QPlainTextEdit::lineCount() const
+{
+    int lines = 0;
+    for (QTextBlock block = ed->document()->begin(); block.isValid(); block = block.next()) {
+        ed->document()->documentLayout()->blockBoundingRect(block);
+        lines += block.layout()->lineCount();
+    }
+    return lines;
+}
+
+// Supporter issue #56783
+void tst_QPlainTextEdit::emptyAppend()
+{
+    ed->appendPlainText("Blah");
+    QCOMPARE(blockCount(), 1);
+    ed->appendPlainText(QString::null);
+    QCOMPARE(blockCount(), 2);
+    ed->appendPlainText(QString("   "));
+    QCOMPARE(blockCount(), 3);
+}
+
+void tst_QPlainTextEdit::appendOnEmptyDocumentShouldReuseInitialParagraph()
+{
+    QCOMPARE(blockCount(), 1);
+    ed->appendPlainText("Blah");
+    QCOMPARE(blockCount(), 1);
+}
+
+
+class CursorPositionChangedRecorder : public QObject
+{
+    Q_OBJECT
+public:
+    inline CursorPositionChangedRecorder(QPlainTextEdit *ed)
+        : editor(ed)
+    {
+        connect(editor, SIGNAL(cursorPositionChanged()), this, SLOT(recordCursorPos()));
+    }
+
+    QList<int> cursorPositions;
+
+private slots:
+    void recordCursorPos()
+    {
+        cursorPositions.append(editor->textCursor().position());
+    }
+
+private:
+    QPlainTextEdit *editor;
+};
+
+void tst_QPlainTextEdit::cursorPositionChanged()
+{
+    QSignalSpy spy(ed, SIGNAL(cursorPositionChanged()));
+
+    spy.clear();
+    QTest::keyClick(ed, Qt::Key_A);
+    QCOMPARE(spy.count(), 1);
+
+    QTextCursor cursor = ed->textCursor();
+    cursor.movePosition(QTextCursor::Start);
+    ed->setTextCursor(cursor);
+    cursor.movePosition(QTextCursor::End);
+    spy.clear();
+    cursor.insertText("Test");
+    QCOMPARE(spy.count(), 0);
+
+    cursor.movePosition(QTextCursor::End);
+    ed->setTextCursor(cursor);
+    cursor.movePosition(QTextCursor::Start);
+    spy.clear();
+    cursor.insertText("Test");
+    QCOMPARE(spy.count(), 1);
+
+    spy.clear();
+    QTest::keyClick(ed, Qt::Key_Left);
+    QCOMPARE(spy.count(), 1);
+
+    CursorPositionChangedRecorder spy2(ed);
+    QVERIFY(ed->textCursor().position() > 0);
+    ed->setPlainText("Hello World");
+    QCOMPARE(spy2.cursorPositions.count(), 1);
+    QCOMPARE(spy2.cursorPositions.at(0), 0);
+    QCOMPARE(ed->textCursor().position(), 0);
+}
+
+void tst_QPlainTextEdit::setTextCursor()
+{
+    QSignalSpy spy(ed, SIGNAL(cursorPositionChanged()));
+
+    ed->setPlainText("Test");
+    QTextCursor cursor = ed->textCursor();
+    cursor.movePosition(QTextCursor::Start);
+    cursor.movePosition(QTextCursor::NextCharacter);
+
+    spy.clear();
+
+    ed->setTextCursor(cursor);
+    QCOMPARE(spy.count(), 1);
+}
+
+void tst_QPlainTextEdit::undoAvailableAfterPaste()
+{
+    if (!nativeClipboardWorking())
+        QSKIP("Clipboard not working with cron-started unit tests", SkipAll);
+
+    QSignalSpy spy(ed->document(), SIGNAL(undoAvailable(bool)));
+
+    const QString txt("Test");
+    QApplication::clipboard()->setText(txt);
+    ed->paste();
+    QVERIFY(spy.count() >= 1);
+    QCOMPARE(ed->toPlainText(), txt);
+}
+
+class UndoRedoRecorder : public QObject
+{
+    Q_OBJECT
+public:
+    UndoRedoRecorder(QTextDocument *doc)
+        : undoRepetitions(false)
+        , redoRepetitions(false)
+        , undoCount(0)
+        , redoCount(0)
+    {
+        connect(doc, SIGNAL(undoAvailable(bool)), this, SLOT(undoAvailable(bool)));
+        connect(doc, SIGNAL(redoAvailable(bool)), this, SLOT(redoAvailable(bool)));
+    }
+
+    bool undoRepetitions;
+    bool redoRepetitions;
+
+private slots:
+    void undoAvailable(bool enabled) {
+        if (undoCount > 0 && enabled == lastUndoEnabled)
+            undoRepetitions = true;
+
+        ++undoCount;
+        lastUndoEnabled = enabled;
+    }
+
+    void redoAvailable(bool enabled) {
+        if (redoCount > 0 && enabled == lastRedoEnabled)
+            redoRepetitions = true;
+
+        ++redoCount;
+        lastRedoEnabled = enabled;
+    }
+
+private:
+    bool lastUndoEnabled;
+    bool lastRedoEnabled;
+
+    int undoCount;
+    int redoCount;
+};
+
+void tst_QPlainTextEdit::undoRedoAvailableRepetition()
+{
+    UndoRedoRecorder spy(ed->document());
+
+    ed->textCursor().insertText("ABC\n\nDEF\n\nGHI\n");
+    ed->textCursor().insertText("foo\n");
+    ed->textCursor().insertText("bar\n");
+    ed->undo(); ed->undo(); ed->undo();
+    ed->redo(); ed->redo(); ed->redo();
+
+    QVERIFY(!spy.undoRepetitions);
+    QVERIFY(!spy.redoRepetitions);
+}
+
+void tst_QPlainTextEdit::appendShouldNotTouchTheSelection()
+{
+    QTextCursor cursor(ed->document());
+    QTextCharFormat fmt;
+    fmt.setForeground(Qt::blue);
+    cursor.insertText("H", fmt);
+    fmt.setForeground(Qt::red);
+    cursor.insertText("ey", fmt);
+
+    cursor.insertText("some random text inbetween");
+
+    cursor.movePosition(QTextCursor::Start);
+    cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);
+    QCOMPARE(cursor.charFormat().foreground().color(), QColor(Qt::blue));
+    cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);
+    QCOMPARE(cursor.charFormat().foreground().color(), QColor(Qt::red));
+    cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);
+    QCOMPARE(cursor.charFormat().foreground().color(), QColor(Qt::red));
+    QCOMPARE(cursor.selectedText(), QString("Hey"));
+
+    ed->setTextCursor(cursor);
+    QVERIFY(ed->textCursor().hasSelection());
+
+    ed->appendHtml("<b>Some Bold Text</b>");
+    cursor.movePosition(QTextCursor::Start);
+    cursor.movePosition(QTextCursor::NextCharacter);
+    QCOMPARE(cursor.charFormat().foreground().color(), QColor(Qt::blue));
+}
+
+void tst_QPlainTextEdit::backspace()
+{
+    QTextCursor cursor = ed->textCursor();
+
+    QTextListFormat listFmt;
+    listFmt.setStyle(QTextListFormat::ListDisc);
+    listFmt.setIndent(1);
+    cursor.insertList(listFmt);
+    cursor.insertText("A");
+
+    ed->setTextCursor(cursor);
+
+    // delete 'A'
+    QTest::keyClick(ed, Qt::Key_Backspace);
+    QVERIFY(ed->textCursor().currentList());
+    // delete list
+    QTest::keyClick(ed, Qt::Key_Backspace);
+    QVERIFY(!ed->textCursor().currentList());
+    QCOMPARE(ed->textCursor().blockFormat().indent(), 1);
+    // outdent paragraph
+    QTest::keyClick(ed, Qt::Key_Backspace);
+    QCOMPARE(ed->textCursor().blockFormat().indent(), 0);
+}
+
+void tst_QPlainTextEdit::shiftBackspace()
+{
+    QTextCursor cursor = ed->textCursor();
+
+    QTextListFormat listFmt;
+    listFmt.setStyle(QTextListFormat::ListDisc);
+    listFmt.setIndent(1);
+    cursor.insertList(listFmt);
+    cursor.insertText("A");
+
+    ed->setTextCursor(cursor);
+
+    // delete 'A'
+    QTest::keyClick(ed, Qt::Key_Backspace, Qt::ShiftModifier);
+    QVERIFY(ed->textCursor().currentList());
+    // delete list
+    QTest::keyClick(ed, Qt::Key_Backspace, Qt::ShiftModifier);
+    QVERIFY(!ed->textCursor().currentList());
+    QCOMPARE(ed->textCursor().blockFormat().indent(), 1);
+    // outdent paragraph
+    QTest::keyClick(ed, Qt::Key_Backspace, Qt::ShiftModifier);
+    QCOMPARE(ed->textCursor().blockFormat().indent(), 0);
+}
+
+void tst_QPlainTextEdit::undoRedo()
+{
+    ed->clear();
+    QTest::keyClicks(ed, "abc d");
+    QCOMPARE(ed->toPlainText(), QString("abc d"));
+    ed->undo();
+    QCOMPARE(ed->toPlainText(), QString());
+    ed->redo();
+    QCOMPARE(ed->toPlainText(), QString("abc d"));
+#ifdef Q_WS_WIN
+    // shortcut for undo
+    QTest::keyClick(ed, Qt::Key_Backspace, Qt::AltModifier);
+    QCOMPARE(ed->toPlainText(), QString());
+    // shortcut for redo
+    QTest::keyClick(ed, Qt::Key_Backspace, Qt::ShiftModifier|Qt::AltModifier);
+    QCOMPARE(ed->toPlainText(), QString("abc d"));
+#endif
+}
+
+// Task #70465
+void tst_QPlainTextEdit::preserveCharFormatInAppend()
+{
+    ed->appendHtml("First para");
+    ed->appendHtml("<b>Second para</b>");
+    ed->appendHtml("third para");
+
+    QTextCursor cursor(ed->textCursor());
+
+    cursor.movePosition(QTextCursor::Start);
+    cursor.movePosition(QTextCursor::NextCharacter);
+    QCOMPARE(cursor.charFormat().fontWeight(), (int)QFont::Normal);
+    QCOMPARE(cursor.block().text(), QString("First para"));
+
+    cursor.movePosition(QTextCursor::NextBlock);
+    cursor.movePosition(QTextCursor::NextCharacter);
+    QCOMPARE(cursor.charFormat().fontWeight(), (int)QFont::Bold);
+    QCOMPARE(cursor.block().text(), QString("Second para"));
+
+    cursor.movePosition(QTextCursor::NextBlock);
+    cursor.movePosition(QTextCursor::NextCharacter);
+    QCOMPARE(cursor.charFormat().fontWeight(), (int)QFont::Normal);
+    QCOMPARE(cursor.block().text(), QString("third para"));
+}
+
+void tst_QPlainTextEdit::copyAndSelectAllInReadonly()
+{
+    if (!nativeClipboardWorking())
+        QSKIP("Clipboard not working with cron-started unit tests", SkipAll);
+
+    ed->setReadOnly(true);
+    ed->setPlainText("Hello World");
+
+    QTextCursor cursor = ed->textCursor();
+    cursor.clearSelection();
+    ed->setTextCursor(cursor);
+    QVERIFY(!ed->textCursor().hasSelection());
+
+    QCOMPARE(ed->toPlainText(), QString("Hello World"));
+
+    // shouldn't do anything
+    QTest::keyClick(ed, Qt::Key_A);
+
+    QCOMPARE(ed->toPlainText(), QString("Hello World"));
+
+    QTest::keyClick(ed, Qt::Key_A, Qt::ControlModifier);
+
+    QVERIFY(ed->textCursor().hasSelection());
+
+    QApplication::clipboard()->setText(QString());
+    QVERIFY(QApplication::clipboard()->text().isEmpty());
+
+    QTest::keyClick(ed, Qt::Key_C, Qt::ControlModifier);
+    QCOMPARE(QApplication::clipboard()->text(), QString("Hello World"));
+}
+
+void tst_QPlainTextEdit::ctrlAltInput()
+{
+    QTest::keyClick(ed, Qt::Key_At, Qt::ControlModifier | Qt::AltModifier);
+    QCOMPARE(ed->toPlainText(), QString("@"));
+}
+
+void tst_QPlainTextEdit::noPropertiesOnDefaultTextEditCharFormat()
+{
+    // there should be no properties set on the default/initial char format
+    // on a text edit. Font properties instead should be taken from the
+    // widget's font (in sync with defaultFont property in document) and the
+    // foreground color should be taken from the palette.
+    QCOMPARE(ed->textCursor().charFormat().properties().count(), 0);
+}
+
+void tst_QPlainTextEdit::setPlainTextShouldEmitTextChangedOnce()
+{
+    QSignalSpy spy(ed, SIGNAL(textChanged()));
+    ed->setPlainText("Yankee Doodle");
+    QCOMPARE(spy.count(), 1);
+    ed->setPlainText("");
+    QCOMPARE(spy.count(), 2);
+}
+
+void tst_QPlainTextEdit::overwriteMode()
+{
+    QVERIFY(!ed->overwriteMode());
+    QTest::keyClicks(ed, "Some first text");
+
+    QCOMPARE(ed->toPlainText(), QString("Some first text"));
+
+    ed->setOverwriteMode(true);
+
+    QTextCursor cursor = ed->textCursor();
+    cursor.setPosition(5);
+    ed->setTextCursor(cursor);
+
+    QTest::keyClicks(ed, "shiny");
+    QCOMPARE(ed->toPlainText(), QString("Some shiny text"));
+
+    cursor.movePosition(QTextCursor::End);
+    ed->setTextCursor(cursor);
+
+    QTest::keyClick(ed, Qt::Key_Enter);
+
+    ed->setOverwriteMode(false);
+    QTest::keyClicks(ed, "Second paragraph");
+
+    QCOMPARE(blockCount(), 2);
+
+    cursor.movePosition(QTextCursor::Start);
+    cursor.movePosition(QTextCursor::EndOfBlock);
+
+    QCOMPARE(cursor.position(), 15);
+    ed->setTextCursor(cursor);
+
+    ed->setOverwriteMode(true);
+
+    QTest::keyClicks(ed, " blah");
+
+    QCOMPARE(blockCount(), 2);
+
+    QTextBlock block = ed->document()->begin();
+    QCOMPARE(block.text(), QString("Some shiny text blah"));
+    block = block.next();
+    QCOMPARE(block.text(), QString("Second paragraph"));
+}
+
+void tst_QPlainTextEdit::shiftDownInLineLastShouldSelectToEnd_data()
+{
+    // shift cursor-down in the last line should select to the end of the document
+
+    QTest::addColumn<QString>("input");
+    QTest::addColumn<int>("totalLineCount");
+
+    QTest::newRow("1") << QString("Foo\nBar") << 2;
+    QTest::newRow("2") << QString("Foo\nBar") + QChar(QChar::LineSeparator) + QString("Baz") << 3;
+}
+
+void tst_QPlainTextEdit::shiftDownInLineLastShouldSelectToEnd()
+{
+    QFETCH(QString, input);
+    QFETCH(int, totalLineCount);
+
+    ed->setPlainText(input);
+    ed->show();
+
+    // ensure we're layouted
+    for (QTextBlock block = ed->document()->begin(); block.isValid(); block = block.next())
+        ed->document()->documentLayout()->blockBoundingRect(block);
+
+    QCOMPARE(blockCount(), 2);
+
+    int lineCount = 0;
+    for (QTextBlock block = ed->document()->begin(); block.isValid(); block = block.next())
+        lineCount += block.layout()->lineCount();
+    QCOMPARE(lineCount, totalLineCount);
+
+    QTextCursor cursor = ed->textCursor();
+    cursor.movePosition(QTextCursor::Start);
+    ed->setTextCursor(cursor);
+
+    for (int i = 0; i < lineCount; ++i) {
+        QTest::keyClick(ed, Qt::Key_Down, Qt::ShiftModifier);
+    }
+
+    input.replace(QLatin1Char('\n'), QChar(QChar::ParagraphSeparator));
+    QCOMPARE(ed->textCursor().selectedText(), input);
+    QVERIFY(ed->textCursor().atEnd());
+
+    // also test that without shift modifier the cursor does not move to the end
+    // for Key_Down in the last line
+    cursor.movePosition(QTextCursor::Start);
+    ed->setTextCursor(cursor);
+    for (int i = 0; i < lineCount; ++i) {
+        QTest::keyClick(ed, Qt::Key_Down);
+    }
+    QVERIFY(!ed->textCursor().atEnd());
+}
+
+void tst_QPlainTextEdit::undoRedoShouldRepositionTextEditCursor()
+{
+    ed->setPlainText("five\nlines\nin\nthis\ntextedit");
+    QTextCursor cursor = ed->textCursor();
+    cursor.movePosition(QTextCursor::Start);
+
+    ed->setUndoRedoEnabled(false);
+    ed->setUndoRedoEnabled(true);
+
+    QVERIFY(!ed->document()->isUndoAvailable());
+    QVERIFY(!ed->document()->isRedoAvailable());
+
+    cursor.insertText("Blah");
+
+    QVERIFY(ed->document()->isUndoAvailable());
+    QVERIFY(!ed->document()->isRedoAvailable());
+
+    cursor.movePosition(QTextCursor::End);
+    ed->setTextCursor(cursor);
+
+    QVERIFY(QMetaObject::invokeMethod(ed, "undo"));
+
+    QVERIFY(!ed->document()->isUndoAvailable());
+    QVERIFY(ed->document()->isRedoAvailable());
+
+    QCOMPARE(ed->textCursor().position(), 0);
+
+    cursor.movePosition(QTextCursor::End);
+    ed->setTextCursor(cursor);
+
+    QVERIFY(QMetaObject::invokeMethod(ed, "redo"));
+
+    QVERIFY(ed->document()->isUndoAvailable());
+    QVERIFY(!ed->document()->isRedoAvailable());
+
+    QCOMPARE(ed->textCursor().position(), 4);
+}
+
+void tst_QPlainTextEdit::lineWrapModes()
+{
+    QWidget *window = new QWidget;
+    ed->setParent(window);
+    window->show();
+    ed->show();
+    ed->setPlainText("a b c d e f g h i j k l m n o p q r s t u v w x y z");
+    ed->setLineWrapMode(QPlainTextEdit::NoWrap);
+    QCOMPARE(lineCount(), 1);
+    ed->setLineWrapMode(QPlainTextEdit::WidgetWidth);
+    ed->resize(1, 1000);
+    QCOMPARE(lineCount(), 26);
+    ed->setParent(0);
+    delete window;
+}
+
+void tst_QPlainTextEdit::mouseCursorShape()
+{
+#ifndef QT_NO_CURSOR
+    // always show an IBeamCursor, see change 170146
+    QVERIFY(!ed->isReadOnly());
+    QVERIFY(ed->viewport()->cursor().shape() == Qt::IBeamCursor);
+
+    ed->setReadOnly(true);
+    QVERIFY(ed->viewport()->cursor().shape() == Qt::IBeamCursor);
+
+    ed->setPlainText("Foo");
+    QVERIFY(ed->viewport()->cursor().shape() == Qt::IBeamCursor);
+#endif
+}
+
+void tst_QPlainTextEdit::implicitClear()
+{
+    // test that QPlainTextEdit::setHtml, etc. avoid calling clear() but instead call
+    // QTextDocument::setHtml/etc. instead, which also clear the contents and
+    // cached resource but preserve manually added resources. setHtml on a textedit
+    // should behave the same as on a document with respect to that.
+    // see also clearResources() autotest in qtextdocument
+
+    // regular resource for QTextDocument
+    QUrl testUrl(":/foobar");
+    QVariant testResource("hello world");
+
+    ed->document()->addResource(QTextDocument::ImageResource, testUrl, testResource);
+    QVERIFY(ed->document()->resource(QTextDocument::ImageResource, testUrl) == testResource);
+
+    ed->setPlainText("Blah");
+    QVERIFY(ed->document()->resource(QTextDocument::ImageResource, testUrl) == testResource);
+
+    ed->setPlainText("<b>Blah</b>");
+    QVERIFY(ed->document()->resource(QTextDocument::ImageResource, testUrl) == testResource);
+
+    ed->clear();
+    QVERIFY(!ed->document()->resource(QTextDocument::ImageResource, testUrl).isValid());
+    QVERIFY(ed->toPlainText().isEmpty());
+}
+
+void tst_QPlainTextEdit::copyAvailable_data()
+{
+    QTest::addColumn<pairListType>("keystrokes");
+    QTest::addColumn<QList<bool> >("copyAvailable");
+    QTest::addColumn<QString>("function");
+
+    pairListType keystrokes;
+    QList<bool> copyAvailable;
+
+    keystrokes << qMakePair(Qt::Key_B, Qt::NoModifier) <<  qMakePair(Qt::Key_B, Qt::NoModifier)
+               << qMakePair(Qt::Key_Left, Qt::ShiftModifier);
+    copyAvailable << true ;
+    QTest::newRow(QString("Case1 B,B, <- + shift | signals: true").toLatin1())
+        << keystrokes << copyAvailable << QString();
+
+    keystrokes.clear();
+    copyAvailable.clear();
+
+    keystrokes << qMakePair(Qt::Key_T, Qt::NoModifier) << qMakePair(Qt::Key_A, Qt::NoModifier)
+               <<  qMakePair(Qt::Key_A, Qt::NoModifier) << qMakePair(Qt::Key_Left, Qt::ShiftModifier);
+    copyAvailable << true << false;
+    QTest::newRow(QString("Case2 T,A,A, <- + shift, cut() | signals: true, false").toLatin1())
+        << keystrokes << copyAvailable << QString("cut");
+
+    keystrokes.clear();
+    copyAvailable.clear();
+
+    keystrokes << qMakePair(Qt::Key_T, Qt::NoModifier) << qMakePair(Qt::Key_A, Qt::NoModifier)
+               <<  qMakePair(Qt::Key_A, Qt::NoModifier) << qMakePair(Qt::Key_Left, Qt::ShiftModifier)
+               << qMakePair(Qt::Key_Left, Qt::ShiftModifier)  << qMakePair(Qt::Key_Left, Qt::ShiftModifier);
+    copyAvailable << true;
+    QTest::newRow(QString("Case3 T,A,A, <- + shift, <- + shift, <- + shift, copy() | signals: true").toLatin1())
+        << keystrokes << copyAvailable << QString("copy");
+
+    keystrokes.clear();
+    copyAvailable.clear();
+
+    keystrokes << qMakePair(Qt::Key_T, Qt::NoModifier) << qMakePair(Qt::Key_A, Qt::NoModifier)
+               <<  qMakePair(Qt::Key_A, Qt::NoModifier) << qMakePair(Qt::Key_Left, Qt::ShiftModifier)
+               << qMakePair(Qt::Key_Left, Qt::ShiftModifier)  << qMakePair(Qt::Key_Left, Qt::ShiftModifier)
+               << qMakePair(Qt::Key_X, Qt::ControlModifier);
+    copyAvailable << true << false;
+    QTest::newRow(QString("Case4 T,A,A, <- + shift, <- + shift, <- + shift, ctrl + x, paste() | signals: true, false").toLatin1())
+        << keystrokes << copyAvailable << QString("paste");
+
+    keystrokes.clear();
+    copyAvailable.clear();
+
+    keystrokes << qMakePair(Qt::Key_B, Qt::NoModifier) <<  qMakePair(Qt::Key_B, Qt::NoModifier)
+               << qMakePair(Qt::Key_Left, Qt::ShiftModifier) << qMakePair(Qt::Key_Left, Qt::NoModifier);
+    copyAvailable << true << false;
+    QTest::newRow(QString("Case5 B,B, <- + shift, <- | signals: true, false").toLatin1())
+        << keystrokes << copyAvailable << QString();
+
+    keystrokes.clear();
+    copyAvailable.clear();
+
+    keystrokes << qMakePair(Qt::Key_B, Qt::NoModifier) <<  qMakePair(Qt::Key_A, Qt::NoModifier)
+               << qMakePair(Qt::Key_Left, Qt::ShiftModifier) << qMakePair(Qt::Key_Left, Qt::NoModifier)
+               << qMakePair(Qt::Key_Right, Qt::ShiftModifier);
+    copyAvailable << true << false << true << false;
+    QTest::newRow(QString("Case6 B,A, <- + shift, ->, <- + shift | signals: true, false, true, false").toLatin1())
+        << keystrokes << copyAvailable << QString("cut");
+
+    keystrokes.clear();
+    copyAvailable.clear();
+
+    keystrokes << qMakePair(Qt::Key_T, Qt::NoModifier) << qMakePair(Qt::Key_A, Qt::NoModifier)
+               <<  qMakePair(Qt::Key_A, Qt::NoModifier) << qMakePair(Qt::Key_Left, Qt::ShiftModifier)
+               << qMakePair(Qt::Key_Left, Qt::ShiftModifier)  << qMakePair(Qt::Key_Left, Qt::ShiftModifier)
+               << qMakePair(Qt::Key_X, Qt::ControlModifier);
+    copyAvailable << true << false << true;
+    QTest::newRow(QString("Case7 T,A,A, <- + shift, <- + shift, <- + shift, ctrl + x, undo() | signals: true, false, true").toLatin1())
+        << keystrokes << copyAvailable << QString("undo");
+}
+
+//Tests the copyAvailable slot for several cases
+void tst_QPlainTextEdit::copyAvailable()
+{
+    QFETCH(pairListType,keystrokes);
+    QFETCH(QList<bool>, copyAvailable);
+    QFETCH(QString, function);
+
+#ifdef Q_WS_MAC
+    QSKIP("copyAvailable has never passed on Mac, task to fix is 132482", SkipAll);
+#endif
+    ed->clear();
+    QApplication::clipboard()->clear();
+    QVERIFY(!ed->canPaste());
+    QSignalSpy spyCopyAvailabe(ed, SIGNAL(copyAvailable(bool)));
+
+    //Execute Keystrokes
+    foreach(keyPairType keyPair, keystrokes) {
+        QTest::keyClick(ed, keyPair.first, keyPair.second );
+    }
+
+    //Execute ed->"function"
+    if (function == "cut")
+        ed->cut();
+    else if (function == "copy")
+        ed->copy();
+    else if (function == "paste")
+        ed->paste();
+    else if (function == "undo")
+        ed->paste();
+    else if (function == "redo")
+        ed->paste();
+
+    //Compare spied signals
+    QEXPECT_FAIL("Case7 T,A,A, <- + shift, <- + shift, <- + shift, ctrl + x, undo() | signals: true, false, true",
+        "Wrong undo selection behaviour. Should be fixed in some future release. (See task: 132482)", Abort);
+    QCOMPARE(spyCopyAvailabe.count(), copyAvailable.count());
+    for (int i=0;i<spyCopyAvailabe.count(); i++) {
+        QVariant variantSpyCopyAvailable = spyCopyAvailabe.at(i).at(0);
+        QVERIFY2(variantSpyCopyAvailable.toBool() == copyAvailable.at(i), QString("Spied singnal: %1").arg(i).toLatin1());
+    }
+}
+
+void tst_QPlainTextEdit::undoRedoAfterSetContent()
+{
+    QVERIFY(!ed->document()->isUndoAvailable());
+    QVERIFY(!ed->document()->isRedoAvailable());
+    ed->setPlainText("Foobar");
+    QVERIFY(!ed->document()->isUndoAvailable());
+    QVERIFY(!ed->document()->isRedoAvailable());
+    ed->setPlainText("<p>bleh</p>");
+    QVERIFY(!ed->document()->isUndoAvailable());
+    QVERIFY(!ed->document()->isRedoAvailable());
+}
+
+void tst_QPlainTextEdit::numPadKeyNavigation()
+{
+    ed->setPlainText("Hello World");
+    QCOMPARE(ed->textCursor().position(), 0);
+    QTest::keyClick(ed, Qt::Key_Right, Qt::KeypadModifier);
+    QCOMPARE(ed->textCursor().position(), 1);
+}
+
+void tst_QPlainTextEdit::moveCursor()
+{
+    ed->setPlainText("Test");
+
+    QSignalSpy cursorMovedSpy(ed, SIGNAL(cursorPositionChanged()));
+
+    QCOMPARE(ed->textCursor().position(), 0);
+    ed->moveCursor(QTextCursor::NextCharacter);
+    QCOMPARE(ed->textCursor().position(), 1);
+    QCOMPARE(cursorMovedSpy.count(), 1);
+    ed->moveCursor(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);
+    QCOMPARE(ed->textCursor().position(), 2);
+    QCOMPARE(cursorMovedSpy.count(), 2);
+    QCOMPARE(ed->textCursor().selectedText(), QString("e"));
+}
+
+class MyTextEdit : public QPlainTextEdit
+{
+public:
+    inline MyTextEdit()
+        : createMimeDataCallCount(0),
+          canInsertCallCount(0),
+          insertCallCount(0)
+    {}
+
+    mutable int createMimeDataCallCount;
+    mutable int canInsertCallCount;
+    mutable int insertCallCount;
+
+    virtual QMimeData *createMimeDataFromSelection() const {
+        createMimeDataCallCount++;
+        return QPlainTextEdit::createMimeDataFromSelection();
+    }
+    virtual bool canInsertFromMimeData(const QMimeData *source) const {
+        canInsertCallCount++;
+        return QPlainTextEdit::canInsertFromMimeData(source);
+    }
+    virtual void insertFromMimeData(const QMimeData *source) {
+        insertCallCount++;
+        QPlainTextEdit::insertFromMimeData(source);
+    }
+
+};
+
+void tst_QPlainTextEdit::mimeDataReimplementations()
+{
+    MyTextEdit ed;
+    ed.setPlainText("Hello World");
+
+    QCOMPARE(ed.createMimeDataCallCount, 0);
+    QCOMPARE(ed.canInsertCallCount, 0);
+    QCOMPARE(ed.insertCallCount, 0);
+
+    ed.selectAll();
+
+    QCOMPARE(ed.createMimeDataCallCount, 0);
+    QCOMPARE(ed.canInsertCallCount, 0);
+    QCOMPARE(ed.insertCallCount, 0);
+
+    ed.copy();
+
+    QCOMPARE(ed.createMimeDataCallCount, 1);
+    QCOMPARE(ed.canInsertCallCount, 0);
+    QCOMPARE(ed.insertCallCount, 0);
+
+    QTextControl *control = qFindChild<QTextControl *>(&ed);
+    QVERIFY(control);
+
+    control->canInsertFromMimeData(QApplication::clipboard()->mimeData());
+
+    QCOMPARE(ed.createMimeDataCallCount, 1);
+    QCOMPARE(ed.canInsertCallCount, 1);
+    QCOMPARE(ed.insertCallCount, 0);
+
+    ed.paste();
+
+    QCOMPARE(ed.createMimeDataCallCount, 1);
+    QCOMPARE(ed.canInsertCallCount, 1);
+    QCOMPARE(ed.insertCallCount, 1);
+}
+
+void tst_QPlainTextEdit::shiftEnterShouldInsertLineSeparator()
+{
+    QTest::keyClick(ed, Qt::Key_A);
+    QTest::keyClick(ed, Qt::Key_Enter, Qt::ShiftModifier);
+    QTest::keyClick(ed, Qt::Key_B);
+    QString expected;
+    expected += 'a';
+    expected += QChar::LineSeparator;
+    expected += 'b';
+    QCOMPARE(ed->textCursor().block().text(), expected);
+}
+
+void tst_QPlainTextEdit::selectWordsFromStringsContainingSeparators_data()
+{
+    QTest::addColumn<QString>("testString");
+    QTest::addColumn<QString>("selectedWord");
+
+    QStringList wordSeparators;
+    wordSeparators << "." << "," << "?" << "!" << ":" << ";" << "-" << "<" << ">" << "["
+                   << "]" << "(" << ")" << "{" << "}" << "=" << "\t"<< QString(QChar::Nbsp);
+
+    foreach (QString s, wordSeparators)
+        QTest::newRow(QString("separator: " + s).toLocal8Bit()) << QString("foo") + s + QString("bar") << QString("foo");
+}
+
+void tst_QPlainTextEdit::selectWordsFromStringsContainingSeparators()
+{
+    QFETCH(QString, testString);
+    QFETCH(QString, selectedWord);
+    ed->setPlainText(testString);
+    QTextCursor cursor = ed->textCursor();
+    cursor.movePosition(QTextCursor::StartOfLine);
+    cursor.select(QTextCursor::WordUnderCursor);
+    QVERIFY(cursor.hasSelection());
+    QCOMPARE(cursor.selection().toPlainText(), selectedWord);
+    cursor.clearSelection();
+}
+
+void tst_QPlainTextEdit::canPaste()
+{
+    if (!nativeClipboardWorking())
+        QSKIP("Clipboard not working with cron-started unit tests", SkipAll);
+
+    QApplication::clipboard()->setText(QString());
+    QVERIFY(!ed->canPaste());
+    QApplication::clipboard()->setText("Test");
+    QVERIFY(ed->canPaste());
+    ed->setTextInteractionFlags(Qt::NoTextInteraction);
+    QVERIFY(!ed->canPaste());
+}
+
+void tst_QPlainTextEdit::ensureCursorVisibleOnInitialShow()
+{
+    QString manyPagesOfPlainText;
+    for (int i = 0; i < 800; ++i)
+        manyPagesOfPlainText += QLatin1String("Blah blah blah blah blah blah\n");
+
+    ed->setPlainText(manyPagesOfPlainText);
+    QCOMPARE(ed->textCursor().position(), 0);
+
+    ed->moveCursor(QTextCursor::End);
+    ed->show();
+    QVERIFY(ed->verticalScrollBar()->value() > 10);
+
+    ed->moveCursor(QTextCursor::Start);
+    QVERIFY(ed->verticalScrollBar()->value() < 10);
+    ed->hide();
+    ed->verticalScrollBar()->setValue(ed->verticalScrollBar()->maximum());
+    ed->show();
+    QCOMPARE(ed->verticalScrollBar()->value(), ed->verticalScrollBar()->maximum());
+}
+
+class TestEdit : public QPlainTextEdit
+{
+public:
+    TestEdit() : resizeEventCalled(false) {}
+
+    bool resizeEventCalled;
+
+protected:
+    virtual void resizeEvent(QResizeEvent *e)
+    {
+        QPlainTextEdit::resizeEvent(e);
+        setPlainText("<img src=qtextbrowser-resizeevent.png width=" + QString::number(size().width()) + "><br>Size is " + QString::number(size().width()) + " x " + QString::number(size().height()));
+        resizeEventCalled = true;
+    }
+};
+
+void tst_QPlainTextEdit::setTextInsideResizeEvent()
+{
+    TestEdit edit;
+    edit.show();
+    edit.resize(800, 600);
+    QVERIFY(edit.resizeEventCalled);
+}
+
+void tst_QPlainTextEdit::colorfulAppend()
+{
+    QTextCharFormat fmt;
+
+    fmt.setForeground(QBrush(Qt::red));
+    ed->mergeCurrentCharFormat(fmt);
+    ed->appendPlainText("Red");
+    fmt.setForeground(QBrush(Qt::blue));
+    ed->mergeCurrentCharFormat(fmt);
+    ed->appendPlainText("Blue");
+    fmt.setForeground(QBrush(Qt::green));
+    ed->mergeCurrentCharFormat(fmt);
+    ed->appendPlainText("Green");
+
+    QCOMPARE(ed->document()->blockCount(), 3);
+    QTextBlock block = ed->document()->begin();
+    QCOMPARE(block.begin().fragment().text(), QString("Red"));
+    QVERIFY(block.begin().fragment().charFormat().foreground().color() == Qt::red);
+    block = block.next();
+    QCOMPARE(block.begin().fragment().text(), QString("Blue"));
+    QVERIFY(block.begin().fragment().charFormat().foreground().color() == Qt::blue);
+    block = block.next();
+    QCOMPARE(block.begin().fragment().text(), QString("Green"));
+    QVERIFY(block.begin().fragment().charFormat().foreground().color() == Qt::green);
+}
+
+void tst_QPlainTextEdit::ensureVisibleWithRtl()
+{
+    ed->setLayoutDirection(Qt::RightToLeft);
+    ed->setLineWrapMode(QPlainTextEdit::NoWrap);
+    QString txt(500, QChar(QLatin1Char('a')));
+    QCOMPARE(txt.length(), 500);
+    ed->setPlainText(txt);
+    ed->resize(100, 100);
+    ed->show();
+
+    qApp->processEvents();
+
+    QVERIFY(ed->horizontalScrollBar()->maximum() > 0);
+
+    ed->moveCursor(QTextCursor::Start);
+    QCOMPARE(ed->horizontalScrollBar()->value(), ed->horizontalScrollBar()->maximum());
+    ed->moveCursor(QTextCursor::End);
+    QCOMPARE(ed->horizontalScrollBar()->value(), 0);
+    ed->moveCursor(QTextCursor::Start);
+    QCOMPARE(ed->horizontalScrollBar()->value(), ed->horizontalScrollBar()->maximum());
+    ed->moveCursor(QTextCursor::End);
+    QCOMPARE(ed->horizontalScrollBar()->value(), 0);
+}
+
+void tst_QPlainTextEdit::preserveCharFormatAfterSetPlainText()
+{
+    QTextCharFormat fmt;
+    fmt.setForeground(QBrush(Qt::blue));
+    ed->mergeCurrentCharFormat(fmt);
+    ed->setPlainText("This is blue");
+    ed->appendPlainText("This should still be blue");
+    QTextBlock block = ed->document()->begin();
+    block = block.next();
+    QCOMPARE(block.text(), QString("This should still be blue"));
+    QVERIFY(block.begin().fragment().charFormat().foreground().color() == QColor(Qt::blue));
+}
+
+void tst_QPlainTextEdit::extraSelections()
+{
+    ed->setPlainText("Hello World");
+
+    QTextCursor c = ed->textCursor();
+    c.movePosition(QTextCursor::Start);
+    c.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
+    const int endPos = c.position();
+
+    QTextEdit::ExtraSelection sel;
+    sel.cursor = c;
+    ed->setExtraSelections(QList<QTextEdit::ExtraSelection>() << sel);
+
+    c.movePosition(QTextCursor::Start);
+    c.movePosition(QTextCursor::NextWord);
+    const int wordPos = c.position();
+    c.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);
+    sel.cursor = c;
+    ed->setExtraSelections(QList<QTextEdit::ExtraSelection>() << sel);
+
+    QList<QTextEdit::ExtraSelection> selections = ed->extraSelections();
+    QCOMPARE(selections.count(), 1);
+    QCOMPARE(selections.at(0).cursor.position(), endPos);
+    QCOMPARE(selections.at(0).cursor.anchor(), wordPos);
+}
+
+void tst_QPlainTextEdit::adjustScrollbars()
+{
+// For some reason ff is defined to be << on Mac Panther / gcc 3.3
+#undef ff
+    QFont ff(ed->font());
+    ff.setFamily("Tahoma");
+    ff.setPointSize(11);
+    ed->setFont(ff);
+    ed->setMinimumSize(140, 100);
+    ed->setMaximumSize(140, 100);
+    ed->show();
+    QLatin1String txt("\nabc def ghi jkl mno pqr stu vwx");
+    ed->setPlainText(txt + txt + txt + txt);
+
+    QVERIFY(ed->verticalScrollBar()->maximum() > 0);
+
+    ed->moveCursor(QTextCursor::End);
+    int oldMaximum = ed->verticalScrollBar()->maximum();
+    QTextCursor cursor = ed->textCursor();
+    cursor.insertText(QLatin1String("\n"));
+    cursor.deletePreviousChar();
+    QCOMPARE(ed->verticalScrollBar()->maximum(), oldMaximum);
+}
+
+class SignalReceiver : public QObject
+{
+    Q_OBJECT
+public:
+    SignalReceiver() : received(0) {}
+
+    int receivedSignals() const { return received; }
+    QTextCharFormat charFormat() const { return format; }
+
+public slots:
+    void charFormatChanged(const QTextCharFormat &tcf) { ++received; format = tcf; }
+
+private:
+    QTextCharFormat format;
+    int received;
+};
+
+void tst_QPlainTextEdit::textObscuredByScrollbars()
+{
+    ed->textCursor().insertText(
+            "ab cab cab c abca kjsdf lka sjd lfk jsal df j kasdf abc ab abc "
+            "a b c d e f g h i j k l m n o p q r s t u v w x y z "
+            "abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc "
+            "ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab"
+            "abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc "
+            "ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab"
+            "abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc "
+            "ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab"
+            "abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc "
+            "ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab"
+            "abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc abc "
+            "ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab ab"
+    );
+    ed->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    ed->show();
+
+    QSize documentSize = ed->document()->documentLayout()->documentSize().toSize();
+    QSize viewportSize = ed->viewport()->size();
+
+    QVERIFY(documentSize.width() <= viewportSize.width());
+}
+
+void tst_QPlainTextEdit::setTextPreservesUndoRedoEnabled()
+{
+    QVERIFY(ed->isUndoRedoEnabled());
+
+    ed->setPlainText("Test");
+
+    QVERIFY(ed->isUndoRedoEnabled());
+
+    ed->setUndoRedoEnabled(false);
+    QVERIFY(!ed->isUndoRedoEnabled());
+    ed->setPlainText("Test2");
+    QVERIFY(!ed->isUndoRedoEnabled());
+
+    ed->setPlainText("<p>hello");
+    QVERIFY(!ed->isUndoRedoEnabled());
+}
+
+void tst_QPlainTextEdit::wordWrapProperty()
+{
+    {
+        QPlainTextEdit edit;
+        QTextDocument *doc = new QTextDocument(&edit);
+        doc->setDocumentLayout(new QPlainTextDocumentLayout(doc));
+        edit.setDocument(doc);
+        edit.setWordWrapMode(QTextOption::NoWrap);
+        QVERIFY(doc->defaultTextOption().wrapMode() == QTextOption::NoWrap);
+    }
+    {
+        QPlainTextEdit edit;
+        QTextDocument *doc = new QTextDocument(&edit);
+        doc->setDocumentLayout(new QPlainTextDocumentLayout(doc));
+        edit.setWordWrapMode(QTextOption::NoWrap);
+        edit.setDocument(doc);
+        QVERIFY(doc->defaultTextOption().wrapMode() == QTextOption::NoWrap);
+    }
+}
+
+void tst_QPlainTextEdit::lineWrapProperty()
+{
+    QVERIFY(ed->wordWrapMode() == QTextOption::WrapAtWordBoundaryOrAnywhere);
+    QVERIFY(ed->lineWrapMode() == QPlainTextEdit::WidgetWidth);
+    ed->setLineWrapMode(QPlainTextEdit::NoWrap);
+    QVERIFY(ed->lineWrapMode() == QPlainTextEdit::NoWrap);
+    QVERIFY(ed->wordWrapMode() == QTextOption::WrapAtWordBoundaryOrAnywhere);
+    QVERIFY(ed->document()->defaultTextOption().wrapMode() == QTextOption::NoWrap);
+}
+
+void tst_QPlainTextEdit::selectionChanged()
+{
+    ed->setPlainText("Hello World");
+
+    ed->moveCursor(QTextCursor::Start);
+
+    QSignalSpy selectionChangedSpy(ed, SIGNAL(selectionChanged()));
+
+    QTest::keyClick(ed, Qt::Key_Right);
+    QCOMPARE(ed->textCursor().position(), 1);
+    QCOMPARE(selectionChangedSpy.count(), 0);
+
+    QTest::keyClick(ed, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(ed->textCursor().position(), 2);
+    QCOMPARE(selectionChangedSpy.count(), 1);
+
+    QTest::keyClick(ed, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(ed->textCursor().position(), 3);
+    QCOMPARE(selectionChangedSpy.count(), 2);
+
+    QTest::keyClick(ed, Qt::Key_Right, Qt::ShiftModifier);
+    QCOMPARE(ed->textCursor().position(), 4);
+    QCOMPARE(selectionChangedSpy.count(), 3);
+
+    QTest::keyClick(ed, Qt::Key_Right);
+    QCOMPARE(ed->textCursor().position(), 5);
+    QCOMPARE(selectionChangedSpy.count(), 4);
+
+    QTest::keyClick(ed, Qt::Key_Right);
+    QCOMPARE(ed->textCursor().position(), 6);
+    QCOMPARE(selectionChangedSpy.count(), 4);
+}
+
+void tst_QPlainTextEdit::blockCountChanged()
+{
+    QSignalSpy blockCountCpangedSpy(ed, SIGNAL(blockCountChanged(int)));
+    ed->setPlainText("Hello");
+    QCOMPARE(blockCountCpangedSpy.count(), 0);
+    ed->setPlainText("Hello World");
+    QCOMPARE(blockCountCpangedSpy.count(), 0);
+    ed->setPlainText("Hello \n World \n this \n has \n more \n blocks \n than \n just \n one");
+    QCOMPARE(blockCountCpangedSpy.count(), 1);
+    ed->setPlainText("One");
+    QCOMPARE(blockCountCpangedSpy.count(), 2);
+    ed->setPlainText("One \n Two");
+    QCOMPARE(blockCountCpangedSpy.count(), 3);
+    ed->setPlainText("Three \n Four");
+    QCOMPARE(blockCountCpangedSpy.count(), 3);
+}
+
+
+QTEST_MAIN(tst_QPlainTextEdit)
+#include "tst_qplaintextedit.moc"