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

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QtTest/QtTest>

    44 

    45 

    46 #include <qtextedit.h>

    47 #include <qtextcursor.h>

    48 #include <qtextlist.h>

    49 #include <qdebug.h>

    50 #include <qapplication.h>

    51 #include <qclipboard.h>

    52 #include <qtextbrowser.h>

    53 #include <private/qtextcontrol_p.h>

    54 #include <qscrollbar.h>

    55 #include <qtextobject.h>

    56 #include <qtexttable.h>

    57 #include <qpainter.h>

    58 #include <qimagereader.h>

    59 #include <qimagewriter.h>

    60 #include <qcommonstyle.h>

    61 

    62 #include <qabstracttextdocumentlayout.h>

    63 #include <qtextdocumentfragment.h>

    64 

    65 //Used in copyAvailable

    66 typedef QPair<Qt::Key, Qt::KeyboardModifier> keyPairType;

    67 typedef QList<keyPairType> pairListType;

    68 Q_DECLARE_METATYPE(pairListType);

    69 Q_DECLARE_METATYPE(keyPairType);

    70 Q_DECLARE_METATYPE(QList<bool>);

    71 

    72 #ifdef Q_WS_MAC

    73 #include <Carbon/Carbon.h>

    74 #endif

    75 

    76 #if defined(Q_OS_SYMBIAN)

    77 # define SRCDIR ""

    78 #undef QT3_SUPPORT

    79 #endif

    80 

    81 

    82 bool nativeClipboardWorking()

    83 {

    84 #ifdef Q_WS_MAC

    85     PasteboardRef pasteboard;

    86     OSStatus status = PasteboardCreate(0, &pasteboard);

    87     if (status == noErr)

    88         CFRelease(pasteboard);

    89     return status == noErr;

    90 #endif

    91     return true;

    92 }

    93 

    94 

    95 QT_FORWARD_DECLARE_CLASS(QTextEdit)

    96 

    97 //TESTED_CLASS=

    98 //TESTED_FILES=

    99 

   100 class tst_QTextEdit : public QObject

   101 {

   102     Q_OBJECT

   103 public:

   104     tst_QTextEdit();

   105 

   106 public slots:

   107     void init();

   108     void cleanup();

   109 private slots:

   110     void getSetCheck();

   111     void inlineAttributesOnInsert();

   112     void inlineAttributesOnSelection();

   113     void inlineAttributeSymmetry();

   114     void inlineAttributeSymmetryWithSelection();

   115     void autoBulletList1();

   116     void autoBulletList2();

   117     void preserveCharFormatAfterNewline();

   118 #ifndef QT_NO_CLIPBOARD

   119     void clearMustNotChangeClipboard();

   120 #endif

   121     void clearMustNotResetRootFrameMarginToDefault();

   122     void clearShouldPreserveTheCurrentCharFormat();

   123     void clearShouldClearExtraSelections();

   124     void paragSeparatorOnPlaintextAppend();

   125     void layoutingLoop();

   126 #ifndef QT_NO_CLIPBOARD

   127     void selectAllSetsNotSelection();

   128 #endif

   129     void asciiTab();

   130     void setDocument();

   131     void setDocument_shared();

   132     void mergeCurrentCharFormat();

   133     void mergeCurrentBlockCharFormat();

   134     void emptyAppend();

   135     void appendOnEmptyDocumentShouldReuseInitialParagraph();

   136 #ifdef QT3_SUPPORT

   137     void textSemantics();

   138 #endif

   139     void cursorPositionChanged();

   140     void setTextCursor();

   141 #ifndef QT_NO_CLIPBOARD

   142     void undoAvailableAfterPaste();

   143 #endif

   144     void undoRedoAvailableRepetition();

   145     void appendShouldUseCurrentFormat();

   146     void appendShouldNotTouchTheSelection();

   147     void backspace();

   148     void shiftBackspace();

   149     void undoRedo();

   150     void preserveCharFormatInAppend();

   151 #ifndef QT_NO_CLIPBOARD

   152     void copyAndSelectAllInReadonly();

   153 #endif

   154     void ctrlAltInput();

   155     void noPropertiesOnDefaultTextEditCharFormat();

   156     void setPlainTextShouldUseCurrentCharFormat();

   157     void setPlainTextShouldEmitTextChangedOnce();

   158     void overwriteMode();

   159     void shiftDownInLineLastShouldSelectToEnd_data();

   160     void shiftDownInLineLastShouldSelectToEnd();

   161     void undoRedoShouldRepositionTextEditCursor();

   162     void lineWrapModes();

   163     void mouseCursorShape();

   164     void implicitClear();

   165     void undoRedoAfterSetContent();

   166     void numPadKeyNavigation();

   167     void moveCursor();

   168 #ifndef QT_NO_CLIPBOARD

   169     void mimeDataReimplementations();

   170 #endif

   171     void ctrlEnterShouldInsertLineSeparator_NOT();

   172     void shiftEnterShouldInsertLineSeparator();

   173     void selectWordsFromStringsContainingSeparators_data();

   174     void selectWordsFromStringsContainingSeparators();

   175 #ifndef QT_NO_CLIPBOARD

   176     void canPaste();

   177     void copyAvailable_data();

   178     void copyAvailable();

   179 #endif

   180     void ensureCursorVisibleOnInitialShow();

   181     void setHtmlInsideResizeEvent();

   182     void colorfulAppend();

   183     void ensureVisibleWithRtl();

   184     void preserveCharFormatAfterSetPlainText();

   185     void extraSelections();

   186     void adjustScrollbars();

   187     void currentCharFormatChanged();

   188     void textObscuredByScrollbars();

   189     void setTextPreservesUndoRedoEnabled();

   190     void wordWrapProperty();

   191     void lineWrapProperty();

   192     void selectionChanged();

   193     void copyPasteBackgroundImage();

   194     void setText();

   195     void fullWidthSelection_data();

   196     void fullWidthSelection();

   197     void fullWidthSelection2();

   198     void cursorRect();

   199     void setDocumentPreservesPalette();

   200     void pasteFromQt3RichText();

   201     void noWrapBackgrounds();

   202     void preserveCharFormatAfterUnchangingSetPosition();

   203 

   204 private:

   205     void createSelection();

   206     int blockCount() const;

   207     bool nativeClipboardWorking();

   208     void compareWidgetAndImage(QTextEdit &widget, const QString &imageFileName);

   209 

   210     QTextEdit *ed;

   211     qreal rootFrameMargin;

   212 };

   213 

   214 bool tst_QTextEdit::nativeClipboardWorking()

   215 {

   216 #ifdef Q_WS_MAC

   217     PasteboardRef pasteboard;

   218     OSStatus status = PasteboardCreate(0, &pasteboard);

   219     if (status == noErr)

   220         CFRelease(pasteboard);

   221     return status == noErr;

   222 #endif

   223     return true;

   224 }

   225 

   226 // Testing get/set functions

   227 void tst_QTextEdit::getSetCheck()

   228 {

   229     QTextEdit obj1;

   230     // QTextDocument * QTextEdit::document()

   231     // void QTextEdit::setDocument(QTextDocument *)

   232     QTextDocument *var1 = new QTextDocument;

   233     obj1.setDocument(var1);

   234     QCOMPARE(var1, obj1.document());

   235     obj1.setDocument((QTextDocument *)0);

   236     QVERIFY(var1 != obj1.document()); // QTextEdit creates a new document when setting 0

   237     QVERIFY((QTextDocument *)0 != obj1.document());

   238     delete var1;

   239 

   240     // AutoFormatting QTextEdit::autoFormatting()

   241     // void QTextEdit::setAutoFormatting(AutoFormatting)

   242     obj1.setAutoFormatting(QTextEdit::AutoFormatting(QTextEdit::AutoNone));

   243     QCOMPARE(QTextEdit::AutoFormatting(QTextEdit::AutoNone), obj1.autoFormatting());

   244     obj1.setAutoFormatting(QTextEdit::AutoFormatting(QTextEdit::AutoBulletList));

   245     QCOMPARE(QTextEdit::AutoFormatting(QTextEdit::AutoBulletList), obj1.autoFormatting());

   246     obj1.setAutoFormatting(QTextEdit::AutoFormatting(QTextEdit::AutoAll));

   247     QCOMPARE(QTextEdit::AutoFormatting(QTextEdit::AutoAll), obj1.autoFormatting());

   248 

   249     // bool QTextEdit::tabChangesFocus()

   250     // void QTextEdit::setTabChangesFocus(bool)

   251     obj1.setTabChangesFocus(false);

   252     QCOMPARE(false, obj1.tabChangesFocus());

   253     obj1.setTabChangesFocus(true);

   254     QCOMPARE(true, obj1.tabChangesFocus());

   255 

   256     // LineWrapMode QTextEdit::lineWrapMode()

   257     // void QTextEdit::setLineWrapMode(LineWrapMode)

   258     obj1.setLineWrapMode(QTextEdit::LineWrapMode(QTextEdit::NoWrap));

   259     QCOMPARE(QTextEdit::LineWrapMode(QTextEdit::NoWrap), obj1.lineWrapMode());

   260     obj1.setLineWrapMode(QTextEdit::LineWrapMode(QTextEdit::WidgetWidth));

   261     QCOMPARE(QTextEdit::LineWrapMode(QTextEdit::WidgetWidth), obj1.lineWrapMode());

   262     obj1.setLineWrapMode(QTextEdit::LineWrapMode(QTextEdit::FixedPixelWidth));

   263     QCOMPARE(QTextEdit::LineWrapMode(QTextEdit::FixedPixelWidth), obj1.lineWrapMode());

   264     obj1.setLineWrapMode(QTextEdit::LineWrapMode(QTextEdit::FixedColumnWidth));

   265     QCOMPARE(QTextEdit::LineWrapMode(QTextEdit::FixedColumnWidth), obj1.lineWrapMode());

   266 

   267     // int QTextEdit::lineWrapColumnOrWidth()

   268     // void QTextEdit::setLineWrapColumnOrWidth(int)

   269     obj1.setLineWrapColumnOrWidth(0);

   270     QCOMPARE(0, obj1.lineWrapColumnOrWidth());

   271     obj1.setLineWrapColumnOrWidth(INT_MIN);

   272     QCOMPARE(INT_MIN, obj1.lineWrapColumnOrWidth());

   273     obj1.setLineWrapColumnOrWidth(INT_MAX);

   274     QCOMPARE(INT_MAX, obj1.lineWrapColumnOrWidth());

   275 

   276     // bool QTextEdit::overwriteMode()

   277     // void QTextEdit::setOverwriteMode(bool)

   278     obj1.setOverwriteMode(false);

   279     QCOMPARE(false, obj1.overwriteMode());

   280     obj1.setOverwriteMode(true);

   281     QCOMPARE(true, obj1.overwriteMode());

   282 

   283     // int QTextEdit::tabStopWidth()

   284     // void QTextEdit::setTabStopWidth(int)

   285     obj1.setTabStopWidth(0);

   286     QCOMPARE(0, obj1.tabStopWidth());

   287     obj1.setTabStopWidth(INT_MIN);

   288     QCOMPARE(0, obj1.tabStopWidth()); // Makes no sense to set a negative tabstop value

   289 #if defined(QT_ARCH_WINDOWSCE)

   290     // due to rounding error in qRound when qreal==float

   291     // we cannot use INT_MAX for this check

   292     obj1.setTabStopWidth(SHRT_MAX*2);

   293     QCOMPARE(SHRT_MAX*2, obj1.tabStopWidth());

   294 #else

   295     obj1.setTabStopWidth(INT_MAX);

   296     QCOMPARE(INT_MAX, obj1.tabStopWidth());

   297 #endif

   298 

   299     // bool QTextEdit::acceptRichText()

   300     // void QTextEdit::setAcceptRichText(bool)

   301     obj1.setAcceptRichText(false);

   302     QCOMPARE(false, obj1.acceptRichText());

   303     obj1.setAcceptRichText(true);

   304     QCOMPARE(true, obj1.acceptRichText());

   305 

   306     // qreal QTextEdit::fontPointSize()

   307     // void QTextEdit::setFontPointSize(qreal)

   308     obj1.setFontPointSize(qreal(1.1));

   309     QCOMPARE(qreal(1.1), obj1.fontPointSize());

   310     // we currently Q_ASSERT_X in QFont::setPointSizeF for that

   311     //obj1.setFontPointSize(0.0);

   312     //QCOMPARE(1.1, obj1.fontPointSize()); // Should not accept 0.0 => keep old

   313 

   314     // int QTextEdit::fontWeight()

   315     // void QTextEdit::setFontWeight(int)

   316     obj1.setFontWeight(1);

   317     QCOMPARE(1, obj1.fontWeight()); // Range<1, 99>

   318     obj1.setFontWeight(99);

   319     QCOMPARE(99, obj1.fontWeight()); // Range<1, 99>

   320     /* Q_ASSERT_X in qfont.cpp

   321     obj1.setFontWeight(INT_MIN);

   322     QCOMPARE(1, obj1.fontWeight()); // Range<1, 99>

   323     obj1.setFontWeight(INT_MAX);

   324     QCOMPARE(99, obj1.fontWeight()); // Range<1, 99>

   325     */

   326 

   327     // bool QTextEdit::fontUnderline()

   328     // void QTextEdit::setFontUnderline(bool)

   329     obj1.setFontUnderline(false);

   330     QCOMPARE(false, obj1.fontUnderline());

   331     obj1.setFontUnderline(true);

   332     QCOMPARE(true, obj1.fontUnderline());

   333 

   334     // bool QTextEdit::fontItalic()

   335     // void QTextEdit::setFontItalic(bool)

   336     obj1.setFontItalic(false);

   337     QCOMPARE(false, obj1.fontItalic());

   338     obj1.setFontItalic(true);

   339     QCOMPARE(true, obj1.fontItalic());

   340 }

   341 

   342 class QtTestDocumentLayout : public QAbstractTextDocumentLayout

   343 {

   344     Q_OBJECT

   345 public:

   346     inline QtTestDocumentLayout(QTextEdit *edit, QTextDocument *doc, int &itCount)

   347         : QAbstractTextDocumentLayout(doc), useBiggerSize(false), ed(edit), iterationCounter(itCount) {}

   348 

   349     virtual void draw(QPainter *, const QAbstractTextDocumentLayout::PaintContext &)  {}

   350 

   351     virtual int hitTest(const QPointF &, Qt::HitTestAccuracy ) const { return 0; }

   352 

   353     virtual void documentChanged(int, int, int) {}

   354 

   355     virtual int pageCount() const { return 1; }

   356 

   357     virtual QSizeF documentSize() const { return usedSize; }

   358 

   359     virtual QRectF frameBoundingRect(QTextFrame *) const { return QRectF(); }

   360     virtual QRectF blockBoundingRect(const QTextBlock &) const { return QRectF(); }

   361 

   362     bool useBiggerSize;

   363     QSize usedSize;

   364 

   365     QTextEdit *ed;

   366 

   367     int &iterationCounter;

   368 };

   369 

   370 tst_QTextEdit::tst_QTextEdit()

   371 {}

   372 

   373 void tst_QTextEdit::init()

   374 {

   375 #ifdef Q_OS_WINCE //disable magic for WindowsCE

   376     qApp->setAutoMaximizeThreshold(-1);

   377 #endif

   378 

   379     ed = new QTextEdit(0);

   380     rootFrameMargin = ed->document()->documentMargin();

   381 }

   382 

   383 void tst_QTextEdit::cleanup()

   384 {

   385     delete ed;

   386     ed = 0;

   387 }

   388 

   389 void tst_QTextEdit::inlineAttributesOnInsert()

   390 {

   391     QVERIFY(ed->textCursor().charFormat().foreground().color() != Qt::blue);

   392 

   393     ed->setTextColor(Qt::blue);

   394     QTest::keyClick(ed, Qt::Key_A);

   395 

   396     QVERIFY(ed->textCursor().charFormat().foreground().color() == Qt::blue);

   397 }

   398 

   399 void tst_QTextEdit::inlineAttributesOnSelection()

   400 {

   401     createSelection();

   402 

   403     ed->setFontItalic(true);

   404 

   405     QVERIFY(ed->textCursor().charFormat().fontItalic());

   406 }

   407 

   408 void tst_QTextEdit::inlineAttributeSymmetry()

   409 {

   410     ed->setFontPointSize(42.0);

   411     QCOMPARE(double(ed->fontPointSize()), 42.0);

   412 

   413     ed->setFontFamily("Test");

   414     QCOMPARE(ed->fontFamily(), QString("Test"));

   415 

   416     ed->setFontWeight(QFont::Bold);

   417     QCOMPARE((int)ed->fontWeight(), (int)QFont::Bold);

   418 

   419     ed->setFontUnderline(true);

   420     QCOMPARE(ed->fontUnderline(), true);

   421 

   422     ed->setFontItalic(true);

   423     QCOMPARE(ed->fontItalic(), true);

   424 

   425     ed->setTextColor(Qt::blue);

   426     QCOMPARE(ed->textColor(), QColor(Qt::blue));

   427 

   428     ed->setTextBackgroundColor(Qt::red);

   429     QCOMPARE(ed->textBackgroundColor(), QColor(Qt::red));

   430 

   431     ed->setAlignment(Qt::AlignRight);

   432     QCOMPARE((int)ed->alignment(), (int)Qt::AlignRight);

   433 }

   434 

   435 void tst_QTextEdit::inlineAttributeSymmetryWithSelection()

   436 {

   437     createSelection();

   438 

   439     inlineAttributeSymmetry();

   440 }

   441 

   442 void tst_QTextEdit::autoBulletList1()

   443 {

   444     ed->setAutoFormatting(QTextEdit::AutoBulletList);

   445 

   446     QTest::keyClick(ed, Qt::Key_Return);

   447     QTest::keyClicks(ed, "*This should become a list");

   448 

   449     QVERIFY(ed->textCursor().currentList());

   450     QVERIFY(ed->textCursor().currentList()->format().style() == QTextListFormat::ListDisc);

   451 }

   452 

   453 void tst_QTextEdit::autoBulletList2()

   454 {

   455     ed->setAutoFormatting(QTextEdit::AutoNone);

   456     QTest::keyClick(ed, Qt::Key_Return);

   457     QTest::keyClicks(ed, "*This should NOT become a list");

   458 

   459     QVERIFY(!ed->textCursor().currentList());

   460 }

   461 

   462 void tst_QTextEdit::preserveCharFormatAfterNewline()

   463 {

   464     ed->setTextColor(Qt::blue);

   465     QTest::keyClicks(ed, "Hello");

   466 

   467     QTest::keyClick(ed, Qt::Key_Return);

   468 

   469     QCOMPARE(ed->textColor(), QColor(Qt::blue));

   470 }

   471 

   472 void tst_QTextEdit::createSelection()

   473 {

   474     QTest::keyClicks(ed, "Hello World");

   475     /* go to start */

   476 #ifndef Q_WS_MAC

   477     QTest::keyClick(ed, Qt::Key_Home, Qt::ControlModifier);

   478 #else

   479     QTest::keyClick(ed, Qt::Key_Home);

   480 #endif

   481     QCOMPARE(ed->textCursor().position(), 0);

   482     /* select until end of text */

   483 #ifndef Q_WS_MAC

   484     QTest::keyClick(ed, Qt::Key_End, Qt::ControlModifier | Qt::ShiftModifier);

   485 #else

   486     QTest::keyClick(ed, Qt::Key_End, Qt::ShiftModifier);

   487 #endif

   488     QCOMPARE(ed->textCursor().position(), 11);

   489 }

   490 

   491 #ifndef QT_NO_CLIPBOARD

   492 void tst_QTextEdit::clearMustNotChangeClipboard()

   493 {

   494     if (!nativeClipboardWorking())

   495         QSKIP("Clipboard not working with cron-started unit tests", SkipAll);

   496     ed->textCursor().insertText("Hello World");

   497     QString txt("This is different text");

   498     QApplication::clipboard()->setText(txt);

   499     ed->clear();

   500     QCOMPARE(QApplication::clipboard()->text(), txt);

   501 }

   502 #endif

   503 

   504 void tst_QTextEdit::clearMustNotResetRootFrameMarginToDefault()

   505 {

   506     QCOMPARE(ed->document()->rootFrame()->frameFormat().margin(), rootFrameMargin);

   507     ed->clear();

   508     QCOMPARE(ed->document()->rootFrame()->frameFormat().margin(), rootFrameMargin);

   509 }

   510 

   511 void tst_QTextEdit::clearShouldPreserveTheCurrentCharFormat()

   512 {

   513     ed->setFontUnderline(true);

   514     QVERIFY(ed->fontUnderline());

   515     ed->clear();

   516     QVERIFY(ed->fontUnderline());

   517 }

   518 

   519 void tst_QTextEdit::clearShouldClearExtraSelections()

   520 {

   521     QTextEdit::ExtraSelection sel;

   522     sel.cursor = ed->textCursor();

   523     sel.format.setProperty(QTextFormat::FullWidthSelection, true);

   524     ed->setExtraSelections(QList<QTextEdit::ExtraSelection>() << sel);

   525     QCOMPARE(ed->extraSelections().count(), 1);

   526     ed->clear();

   527     QCOMPARE(ed->extraSelections().count(), 0);

   528 }

   529 

   530 void tst_QTextEdit::paragSeparatorOnPlaintextAppend()

   531 {

   532     ed->append("Hello\nWorld");

   533     int cnt = 0;

   534     QTextBlock blk = ed->document()->begin();

   535     while (blk.isValid()) {

   536         ++cnt;

   537         blk = blk.next();

   538     }

   539     QCOMPARE(cnt, 2);

   540 }

   541 

   542 void tst_QTextEdit::layoutingLoop()

   543 {

   544     QPointer<QTextEdit> ed = new QTextEdit(0);

   545     // this is a testcase for an ugly layouting problem, causing an infinite loop.

   546     // QTextEdit's resizeEvent has a long comment about what and why it can happen.

   547 

   548     int callsToSetPageSize = 0;

   549 

   550     QTextDocument *doc = new QTextDocument;

   551     QtTestDocumentLayout *lout = new QtTestDocumentLayout(ed, doc, callsToSetPageSize);

   552     doc->setDocumentLayout(lout);

   553     ed->setDocument(doc);

   554 

   555     ed->show();

   556     ed->resize(100, 100);

   557 

   558     qApp->processEvents();

   559     delete doc;

   560     delete ed;

   561 

   562     // ###### should need less!

   563     QVERIFY(callsToSetPageSize < 10);

   564 }

   565 

   566 #ifndef QT_NO_CLIPBOARD

   567 void tst_QTextEdit::selectAllSetsNotSelection()

   568 {

   569     if (!QApplication::clipboard()->supportsSelection()) {

   570         QSKIP("Test only relevant for systems with selection", SkipAll);

   571         return;

   572     }

   573 

   574     QApplication::clipboard()->setText(QString("foobar"), QClipboard::Selection);

   575     QVERIFY(QApplication::clipboard()->text(QClipboard::Selection) == QString("foobar"));

   576 

   577     ed->insertPlainText("Hello World");

   578     ed->selectAll();

   579 

   580     QCOMPARE(QApplication::clipboard()->text(QClipboard::Selection), QString::fromAscii("foobar"));

   581 }

   582 #endif

   583 void tst_QTextEdit::asciiTab()

   584 {

   585     QTextEdit edit;

   586     edit.setPlainText("\t");

   587     edit.show();

   588     qApp->processEvents();

   589     QCOMPARE(edit.toPlainText().at(0), QChar('\t'));

   590 }

   591 

   592 

   593 void tst_QTextEdit::setDocument()

   594 {

   595     QTextDocument *document = new QTextDocument(ed);

   596     QCOMPARE(document->isModified(), false);

   597     QCOMPARE(document->isUndoAvailable(), false);

   598     QTextCursor(document).insertText("Test");

   599     QCOMPARE(document->isUndoAvailable(), true);

   600     QCOMPARE(document->isModified(), true);

   601     ed->setDocument(document);

   602     QCOMPARE(ed->toPlainText(), QString("Test"));

   603     QCOMPARE(document->isUndoAvailable(), true);

   604     QCOMPARE(document->isModified(), true);

   605 }

   606 

   607 void tst_QTextEdit::setDocument_shared()

   608 {

   609     QTextDocument *document = new QTextDocument(ed);

   610     QCOMPARE(document->isModified(), false);

   611     QCOMPARE(document->isUndoAvailable(), false);

   612     QTextCursor(document).insertText("Test");

   613     QCOMPARE(document->isUndoAvailable(), true);

   614     document->setModified(false);

   615     ed->setDocument(document);

   616     QCOMPARE(ed->toPlainText(), QString("Test"));

   617     QCOMPARE(document->isUndoAvailable(), true);

   618     QCOMPARE(document->isModified(), false);

   619     QTextCursor(document).insertText("Test2");

   620     QCOMPARE(document->isModified(), true);

   621     QTextEdit editor2;

   622     editor2.setDocument(document);

   623     QCOMPARE(document->isUndoAvailable(), true);

   624     QCOMPARE(document->isModified(), true);

   625 }

   626 

   627 void tst_QTextEdit::mergeCurrentCharFormat()

   628 {

   629     ed->setPlainText("Hello Test World");

   630     QTextCursor cursor = ed->textCursor();

   631     cursor.setPosition(7);

   632     ed->setTextCursor(cursor);

   633 

   634     QTextCharFormat mod;

   635     mod.setFontItalic(true);

   636     mod.setForeground(Qt::red);

   637     ed->mergeCurrentCharFormat(mod);

   638 

   639     cursor.movePosition(QTextCursor::Right);

   640     cursor.movePosition(QTextCursor::Right);

   641     // do NOT select the current word under the cursor, /JUST/

   642     // call mergeCharFormat on the cursor

   643     QVERIFY(!cursor.charFormat().fontItalic());

   644     QVERIFY(cursor.charFormat().foreground().color() != Qt::red);

   645 }

   646 

   647 void tst_QTextEdit::mergeCurrentBlockCharFormat()

   648 {

   649     ed->setPlainText("FirstLine\n\nThirdLine");

   650     QTextCursor cursor = ed->textCursor();

   651     cursor.movePosition(QTextCursor::Start);

   652     cursor.movePosition(QTextCursor::Down);

   653 

   654     // make sure we're in the empty second line

   655     QVERIFY(cursor.atBlockStart());

   656     QVERIFY(cursor.atBlockEnd());

   657 

   658     ed->setTextCursor(cursor);

   659 

   660     QTextCharFormat mod;

   661     mod.setForeground(Qt::red);

   662     ed->mergeCurrentCharFormat(mod);

   663 

   664     QVERIFY(cursor.blockCharFormat().foreground().color() != Qt::red);

   665     cursor.movePosition(QTextCursor::Up);

   666     QVERIFY(cursor.blockCharFormat().foreground().color() != Qt::red);

   667     cursor.movePosition(QTextCursor::Down);

   668     cursor.movePosition(QTextCursor::Down);

   669     QVERIFY(cursor.blockCharFormat().foreground().color() != Qt::red);

   670 }

   671 

   672 int tst_QTextEdit::blockCount() const

   673 {

   674     int blocks = 0;

   675     for (QTextBlock block = ed->document()->begin(); block.isValid(); block = block.next())

   676         ++blocks;

   677     return blocks;

   678 }

   679 

   680 // Supporter issue #56783

   681 void tst_QTextEdit::emptyAppend()

   682 {

   683     ed->append("Blah");

   684     QCOMPARE(blockCount(), 1);

   685     ed->append(QString::null);

   686     QCOMPARE(blockCount(), 2);

   687     ed->append(QString("   "));

   688     QCOMPARE(blockCount(), 3);

   689 }

   690 

   691 void tst_QTextEdit::appendOnEmptyDocumentShouldReuseInitialParagraph()

   692 {

   693     QCOMPARE(blockCount(), 1);

   694     ed->append("Blah");

   695     QCOMPARE(blockCount(), 1);

   696 }

   697 

   698 #ifdef QT3_SUPPORT

   699 void tst_QTextEdit::textSemantics()

   700 {

   701     ed->setTextFormat(Qt::AutoText);

   702 

   703     ed->setPlainText("Hello World");

   704     QVERIFY(!Qt::mightBeRichText(ed->text()));

   705 

   706     ed->setHtml("<b>Hey</b>");

   707     QVERIFY(Qt::mightBeRichText(ed->text()));

   708 }

   709 #endif

   710 

   711 class CursorPositionChangedRecorder : public QObject

   712 {

   713     Q_OBJECT

   714 public:

   715     inline CursorPositionChangedRecorder(QTextEdit *ed)

   716         : editor(ed)

   717     {

   718         connect(editor, SIGNAL(cursorPositionChanged()), this, SLOT(recordCursorPos()));

   719     }

   720 

   721     QList<int> cursorPositions;

   722 

   723 private slots:

   724     void recordCursorPos()

   725     {

   726         cursorPositions.append(editor->textCursor().position());

   727     }

   728 

   729 private:

   730     QTextEdit *editor;

   731 };

   732 

   733 void tst_QTextEdit::cursorPositionChanged()

   734 {

   735     QSignalSpy spy(ed, SIGNAL(cursorPositionChanged()));

   736     ed->show();

   737 

   738     spy.clear();

   739     QTest::keyClick(ed, Qt::Key_A);

   740     QCOMPARE(spy.count(), 1);

   741 

   742     QTextCursor cursor = ed->textCursor();

   743     cursor.movePosition(QTextCursor::Start);

   744     ed->setTextCursor(cursor);

   745     cursor.movePosition(QTextCursor::End);

   746     spy.clear();

   747     cursor.insertText("Test");

   748     QCOMPARE(spy.count(), 0);

   749 

   750     cursor.movePosition(QTextCursor::End);

   751     ed->setTextCursor(cursor);

   752     cursor.movePosition(QTextCursor::Start);

   753     spy.clear();

   754     cursor.insertText("Test");

   755     QCOMPARE(spy.count(), 1);

   756 

   757     spy.clear();

   758     QTest::keyClick(ed, Qt::Key_Left);

   759     QCOMPARE(spy.count(), 1);

   760 

   761     cursor.movePosition(QTextCursor::Start);

   762     ed->setTextCursor(cursor);

   763     spy.clear();

   764     QVERIFY(!ed->textCursor().hasSelection());

   765     QTest::mouseDClick(ed->viewport(), Qt::LeftButton, 0, ed->cursorRect().center());

   766     QVERIFY(ed->textCursor().hasSelection());

   767 

   768     QCOMPARE(spy.count(), 1);

   769 

   770     CursorPositionChangedRecorder spy2(ed);

   771     QVERIFY(ed->textCursor().position() > 0);

   772     ed->setPlainText("Hello World");

   773     QCOMPARE(spy2.cursorPositions.count(), 1);

   774     QCOMPARE(spy2.cursorPositions.at(0), 0);

   775     QCOMPARE(ed->textCursor().position(), 0);

   776 }

   777 

   778 void tst_QTextEdit::setTextCursor()

   779 {

   780     QSignalSpy spy(ed, SIGNAL(cursorPositionChanged()));

   781 

   782     ed->setPlainText("Test");

   783     QTextCursor cursor = ed->textCursor();

   784     cursor.movePosition(QTextCursor::Start);

   785     cursor.movePosition(QTextCursor::NextCharacter);

   786 

   787     spy.clear();

   788 

   789     ed->setTextCursor(cursor);

   790     QCOMPARE(spy.count(), 1);

   791 }

   792 

   793 #ifndef QT_NO_CLIPBOARD

   794 void tst_QTextEdit::undoAvailableAfterPaste()

   795 {

   796     if (!nativeClipboardWorking())

   797         QSKIP("Clipboard not working with cron-started unit tests", SkipAll);

   798 

   799     QSignalSpy spy(ed->document(), SIGNAL(undoAvailable(bool)));

   800 

   801     const QString txt("Test");

   802     QApplication::clipboard()->setText(txt);

   803     ed->paste();

   804     QVERIFY(spy.count() >= 1);

   805     QCOMPARE(ed->toPlainText(), txt);

   806 }

   807 #endif

   808 

   809 class UndoRedoRecorder : public QObject

   810 {

   811     Q_OBJECT

   812 public:

   813     UndoRedoRecorder(QTextDocument *doc)

   814         : undoRepetitions(false)

   815         , redoRepetitions(false)

   816         , undoCount(0)

   817         , redoCount(0)

   818     {

   819         connect(doc, SIGNAL(undoAvailable(bool)), this, SLOT(undoAvailable(bool)));

   820         connect(doc, SIGNAL(redoAvailable(bool)), this, SLOT(redoAvailable(bool)));

   821     }

   822 

   823     bool undoRepetitions;

   824     bool redoRepetitions;

   825 

   826 private slots:

   827     void undoAvailable(bool enabled) {

   828         if (undoCount > 0 && enabled == lastUndoEnabled)

   829             undoRepetitions = true;

   830 

   831         ++undoCount;

   832         lastUndoEnabled = enabled;

   833     }

   834 

   835     void redoAvailable(bool enabled) {

   836         if (redoCount > 0 && enabled == lastRedoEnabled)

   837             redoRepetitions = true;

   838 

   839         ++redoCount;

   840         lastRedoEnabled = enabled;

   841     }

   842 

   843 private:

   844     bool lastUndoEnabled;

   845     bool lastRedoEnabled;

   846 

   847     int undoCount;

   848     int redoCount;

   849 };

   850 

   851 void tst_QTextEdit::undoRedoAvailableRepetition()

   852 {

   853     UndoRedoRecorder spy(ed->document());

   854 

   855     ed->textCursor().insertText("ABC\n\nDEF\n\nGHI\n");

   856     ed->textCursor().insertText("foo\n");

   857     ed->textCursor().insertText("bar\n");

   858     ed->undo(); ed->undo(); ed->undo();

   859     ed->redo(); ed->redo(); ed->redo();

   860 

   861     QVERIFY(!spy.undoRepetitions);

   862     QVERIFY(!spy.redoRepetitions);

   863 }

   864 

   865 void tst_QTextEdit::appendShouldUseCurrentFormat()

   866 {

   867     ed->textCursor().insertText("A");

   868     QTextCharFormat fmt;

   869     fmt.setForeground(Qt::blue);

   870     fmt.setFontItalic(true);

   871     ed->setCurrentCharFormat(fmt);

   872     ed->append("Hello");

   873 

   874     QTextCursor cursor(ed->document());

   875 

   876     QVERIFY(cursor.movePosition(QTextCursor::NextCharacter));

   877     QVERIFY(cursor.charFormat().foreground().color() != Qt::blue);

   878     QVERIFY(!cursor.charFormat().fontItalic());

   879 

   880     QVERIFY(cursor.movePosition(QTextCursor::NextBlock));

   881 

   882     {

   883         QTextCursor tmp = cursor;

   884         tmp.movePosition(QTextCursor::End, QTextCursor::KeepAnchor);

   885         QCOMPARE(tmp.selectedText(), QString::fromLatin1("Hello"));

   886     }

   887 

   888     QVERIFY(cursor.movePosition(QTextCursor::NextCharacter));

   889     QVERIFY(cursor.charFormat().foreground().color() == Qt::blue);

   890     QVERIFY(cursor.charFormat().fontItalic());

   891 }

   892 

   893 void tst_QTextEdit::appendShouldNotTouchTheSelection()

   894 {

   895     QTextCursor cursor(ed->document());

   896     QTextCharFormat fmt;

   897     fmt.setForeground(Qt::blue);

   898     cursor.insertText("H", fmt);

   899     fmt.setForeground(Qt::red);

   900     cursor.insertText("ey", fmt);

   901 

   902     cursor.insertText("some random text inbetween");

   903 

   904     cursor.movePosition(QTextCursor::Start);

   905     cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);

   906     QCOMPARE(cursor.charFormat().foreground().color(), QColor(Qt::blue));

   907     cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);

   908     QCOMPARE(cursor.charFormat().foreground().color(), QColor(Qt::red));

   909     cursor.movePosition(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);

   910     QCOMPARE(cursor.charFormat().foreground().color(), QColor(Qt::red));

   911     QCOMPARE(cursor.selectedText(), QString("Hey"));

   912 

   913     ed->setTextCursor(cursor);

   914     QVERIFY(ed->textCursor().hasSelection());

   915 

   916     ed->append("<b>Some Bold Text</b>");

   917     cursor.movePosition(QTextCursor::Start);

   918     cursor.movePosition(QTextCursor::NextCharacter);

   919     QCOMPARE(cursor.charFormat().foreground().color(), QColor(Qt::blue));

   920 }

   921 

   922 void tst_QTextEdit::backspace()

   923 {

   924     QTextCursor cursor = ed->textCursor();

   925 

   926     QTextListFormat listFmt;

   927     listFmt.setStyle(QTextListFormat::ListDisc);

   928     listFmt.setIndent(1);

   929     cursor.insertList(listFmt);

   930     cursor.insertText("A");

   931 

   932     ed->setTextCursor(cursor);

   933 

   934     // delete 'A'

   935     QTest::keyClick(ed, Qt::Key_Backspace);

   936     QVERIFY(ed->textCursor().currentList());

   937     // delete list

   938     QTest::keyClick(ed, Qt::Key_Backspace);

   939     QVERIFY(!ed->textCursor().currentList());

   940     QCOMPARE(ed->textCursor().blockFormat().indent(), 1);

   941     // outdent paragraph

   942     QTest::keyClick(ed, Qt::Key_Backspace);

   943     QCOMPARE(ed->textCursor().blockFormat().indent(), 0);

   944 }

   945 

   946 void tst_QTextEdit::shiftBackspace()

   947 {

   948     QTextCursor cursor = ed->textCursor();

   949 

   950     QTextListFormat listFmt;

   951     listFmt.setStyle(QTextListFormat::ListDisc);

   952     listFmt.setIndent(1);

   953     cursor.insertList(listFmt);

   954     cursor.insertText("A");

   955 

   956     ed->setTextCursor(cursor);

   957 

   958     // delete 'A'

   959     QTest::keyClick(ed, Qt::Key_Backspace, Qt::ShiftModifier);

   960     QVERIFY(ed->textCursor().currentList());

   961     // delete list

   962     QTest::keyClick(ed, Qt::Key_Backspace, Qt::ShiftModifier);

   963     QVERIFY(!ed->textCursor().currentList());

   964     QCOMPARE(ed->textCursor().blockFormat().indent(), 1);

   965     // outdent paragraph

   966     QTest::keyClick(ed, Qt::Key_Backspace, Qt::ShiftModifier);

   967     QCOMPARE(ed->textCursor().blockFormat().indent(), 0);

   968 }

   969 

   970 void tst_QTextEdit::undoRedo()

   971 {

   972     ed->clear();

   973     QTest::keyClicks(ed, "abc d");

   974     QCOMPARE(ed->toPlainText(), QString("abc d"));

   975     ed->undo();

   976     QCOMPARE(ed->toPlainText(), QString());

   977     ed->redo();

   978     QCOMPARE(ed->toPlainText(), QString("abc d"));

   979 #ifdef Q_WS_WIN

   980     // shortcut for undo

   981     QTest::keyClick(ed, Qt::Key_Backspace, Qt::AltModifier);

   982     QCOMPARE(ed->toPlainText(), QString());

   983     // shortcut for redo

   984     QTest::keyClick(ed, Qt::Key_Backspace, Qt::ShiftModifier|Qt::AltModifier);

   985     QCOMPARE(ed->toPlainText(), QString("abc d"));

   986 #endif

   987 }

   988 

   989 // Task #70465

   990 void tst_QTextEdit::preserveCharFormatInAppend()

   991 {

   992     ed->append("First para");

   993     ed->append("<b>Second para</b>");

   994     ed->append("third para");

   995 

   996     QTextCursor cursor(ed->textCursor());

   997 

   998     cursor.movePosition(QTextCursor::Start);

   999     cursor.movePosition(QTextCursor::NextCharacter);

  1000     QCOMPARE(cursor.charFormat().fontWeight(), (int)QFont::Normal);

  1001     QCOMPARE(cursor.block().text(), QString("First para"));

  1002 

  1003     cursor.movePosition(QTextCursor::NextBlock);

  1004     cursor.movePosition(QTextCursor::NextCharacter);

  1005     QCOMPARE(cursor.charFormat().fontWeight(), (int)QFont::Bold);

  1006     QCOMPARE(cursor.block().text(), QString("Second para"));

  1007 

  1008     cursor.movePosition(QTextCursor::NextBlock);

  1009     cursor.movePosition(QTextCursor::NextCharacter);

  1010     QCOMPARE(cursor.charFormat().fontWeight(), (int)QFont::Normal);

  1011     QCOMPARE(cursor.block().text(), QString("third para"));

  1012 }

  1013 

  1014 #ifndef QT_NO_CLIPBOARD

  1015 void tst_QTextEdit::copyAndSelectAllInReadonly()

  1016 {

  1017     if (!nativeClipboardWorking())

  1018         QSKIP("Clipboard not working with cron-started unit tests", SkipAll);

  1019 

  1020     ed->setReadOnly(true);

  1021     ed->setPlainText("Hello World");

  1022 

  1023     QTextCursor cursor = ed->textCursor();

  1024     cursor.clearSelection();

  1025     ed->setTextCursor(cursor);

  1026     QVERIFY(!ed->textCursor().hasSelection());

  1027 

  1028     QCOMPARE(ed->toPlainText(), QString("Hello World"));

  1029 

  1030     // shouldn't do anything

  1031     QTest::keyClick(ed, Qt::Key_A);

  1032 

  1033     QCOMPARE(ed->toPlainText(), QString("Hello World"));

  1034 

  1035     QTest::keyClick(ed, Qt::Key_A, Qt::ControlModifier);

  1036 

  1037     QVERIFY(ed->textCursor().hasSelection());

  1038 

  1039     QApplication::clipboard()->setText(QString());

  1040     QVERIFY(QApplication::clipboard()->text().isEmpty());

  1041 

  1042     QTest::keyClick(ed, Qt::Key_C, Qt::ControlModifier);

  1043     QCOMPARE(QApplication::clipboard()->text(), QString("Hello World"));

  1044 }

  1045 #endif

  1046 

  1047 void tst_QTextEdit::ctrlAltInput()

  1048 {

  1049     QTest::keyClick(ed, Qt::Key_At, Qt::ControlModifier | Qt::AltModifier);

  1050     QCOMPARE(ed->toPlainText(), QString("@"));

  1051 }

  1052 

  1053 void tst_QTextEdit::noPropertiesOnDefaultTextEditCharFormat()

  1054 {

  1055     // there should be no properties set on the default/initial char format

  1056     // on a text edit. Font properties instead should be taken from the

  1057     // widget's font (in sync with defaultFont property in document) and the

  1058     // foreground color should be taken from the palette.

  1059     QCOMPARE(ed->currentCharFormat().properties().count(), 0);

  1060 }

  1061 

  1062 void tst_QTextEdit::setPlainTextShouldUseCurrentCharFormat()

  1063 {

  1064     ed->setFontUnderline(true);

  1065     ed->setPlainText("Hello World");

  1066     QTextCursor cursor(ed->document());

  1067     cursor.movePosition(QTextCursor::NextCharacter);

  1068     QCOMPARE(cursor.charFormat().fontUnderline(), true);

  1069 

  1070     ed->setHtml("<p style=\"color:blue\">Foo</p>");

  1071     ed->setPlainText("Hello World");

  1072     cursor = QTextCursor(ed->document());

  1073     cursor.movePosition(QTextCursor::NextCharacter);

  1074     QCOMPARE(cursor.charFormat().fontUnderline(), true);

  1075 }

  1076 

  1077 void tst_QTextEdit::setPlainTextShouldEmitTextChangedOnce()

  1078 {

  1079     QSignalSpy spy(ed, SIGNAL(textChanged()));

  1080     ed->setPlainText("Yankee Doodle");

  1081     QCOMPARE(spy.count(), 1);

  1082     ed->setPlainText("");

  1083     QCOMPARE(spy.count(), 2);

  1084 }

  1085 

  1086 void tst_QTextEdit::overwriteMode()

  1087 {

  1088     QVERIFY(!ed->overwriteMode());

  1089     QTest::keyClicks(ed, "Some first text");

  1090 

  1091     QCOMPARE(ed->toPlainText(), QString("Some first text"));

  1092 

  1093     ed->setOverwriteMode(true);

  1094 

  1095     QTextCursor cursor = ed->textCursor();

  1096     cursor.setPosition(5);

  1097     ed->setTextCursor(cursor);

  1098 

  1099     QTest::keyClicks(ed, "shiny");

  1100     QCOMPARE(ed->toPlainText(), QString("Some shiny text"));

  1101 

  1102     cursor.movePosition(QTextCursor::End);

  1103     ed->setTextCursor(cursor);

  1104 

  1105     QTest::keyClick(ed, Qt::Key_Enter);

  1106 

  1107     ed->setOverwriteMode(false);

  1108     QTest::keyClicks(ed, "Second paragraph");

  1109 

  1110     QCOMPARE(blockCount(), 2);

  1111 

  1112     cursor.movePosition(QTextCursor::Start);

  1113     cursor.movePosition(QTextCursor::EndOfBlock);

  1114 

  1115     QCOMPARE(cursor.position(), 15);

  1116     ed->setTextCursor(cursor);

  1117 

  1118     ed->setOverwriteMode(true);

  1119 

  1120     QTest::keyClicks(ed, " blah");

  1121 

  1122     QCOMPARE(blockCount(), 2);

  1123 

  1124     QTextBlock block = ed->document()->begin();

  1125     QCOMPARE(block.text(), QString("Some shiny text blah"));

  1126     block = block.next();

  1127     QCOMPARE(block.text(), QString("Second paragraph"));

  1128 }

  1129 

  1130 void tst_QTextEdit::shiftDownInLineLastShouldSelectToEnd_data()

  1131 {

  1132     // shift cursor-down in the last line should select to the end of the document

  1133 

  1134     QTest::addColumn<QString>("input");