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 

    57 #include <qabstracttextdocumentlayout.h>

    58 #include <qtextdocumentfragment.h>

    59 

    60 #include "qplaintextedit.h"

    61 

    62 //Used in copyAvailable

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

    64 typedef QList<keyPairType> pairListType;

    65 Q_DECLARE_METATYPE(pairListType);

    66 Q_DECLARE_METATYPE(keyPairType);

    67 Q_DECLARE_METATYPE(QList<bool>);

    68 

    69 #ifdef Q_WS_MAC

    70 #include <Carbon/Carbon.h>

    71 #endif

    72 

    73 QT_FORWARD_DECLARE_CLASS(QPlainTextEdit)

    74 

    75 //TESTED_CLASS=

    76 //TESTED_FILES=gui/widgets/qtextedit.h gui/widgets/qtextedit.cpp

    77 

    78 class tst_QPlainTextEdit : public QObject

    79 {

    80     Q_OBJECT

    81 public:

    82     tst_QPlainTextEdit();

    83 

    84 public slots:

    85     void initTestCase();

    86     void init();

    87     void cleanup();

    88 private slots:

    89     void getSetCheck();

    90 #ifndef QT_NO_CLIPBOARD

    91     void clearMustNotChangeClipboard();

    92 #endif

    93     void clearMustNotResetRootFrameMarginToDefault();

    94     void paragSeparatorOnPlaintextAppend();

    95 #ifndef QT_NO_CLIPBOARD

    96     void selectAllSetsNotSelection();

    97 #endif

    98     void asciiTab();

    99     void setDocument();

   100     void emptyAppend();

   101     void appendOnEmptyDocumentShouldReuseInitialParagraph();

   102     void cursorPositionChanged();

   103     void setTextCursor();

   104 #ifndef QT_NO_CLIPBOARD

   105     void undoAvailableAfterPaste();

   106 #endif

   107     void undoRedoAvailableRepetition();

   108     void appendShouldNotTouchTheSelection();

   109     void backspace();

   110     void shiftBackspace();

   111     void undoRedo();

   112     void preserveCharFormatInAppend();

   113 #ifndef QT_NO_CLIPBOARD

   114     void copyAndSelectAllInReadonly();

   115 #endif

   116     void ctrlAltInput();

   117     void noPropertiesOnDefaultTextEditCharFormat();

   118     void setPlainTextShouldEmitTextChangedOnce();

   119     void overwriteMode();

   120     void shiftDownInLineLastShouldSelectToEnd_data();

   121     void shiftDownInLineLastShouldSelectToEnd();

   122     void undoRedoShouldRepositionTextEditCursor();

   123     void lineWrapModes();

   124     void mouseCursorShape();

   125     void implicitClear();

   126     void undoRedoAfterSetContent();

   127     void numPadKeyNavigation();

   128     void moveCursor();

   129 #ifndef QT_NO_CLIPBOARD

   130     void mimeDataReimplementations();

   131 #endif

   132     void shiftEnterShouldInsertLineSeparator();

   133     void selectWordsFromStringsContainingSeparators_data();

   134     void selectWordsFromStringsContainingSeparators();

   135 #ifndef QT_NO_CLIPBOARD

   136     void canPaste();

   137     void copyAvailable_data();

   138     void copyAvailable();

   139 #endif

   140     void ensureCursorVisibleOnInitialShow();

   141     void setTextInsideResizeEvent();

   142     void colorfulAppend();

   143     void ensureVisibleWithRtl();

   144     void preserveCharFormatAfterSetPlainText();

   145     void extraSelections();

   146     void adjustScrollbars();

   147     void textObscuredByScrollbars();

   148     void setTextPreservesUndoRedoEnabled();

   149     void wordWrapProperty();

   150     void lineWrapProperty();

   151     void selectionChanged();

   152     void blockCountChanged();

   153 

   154 private:

   155     void createSelection();

   156     int blockCount() const;

   157     int lineCount() const;

   158     bool nativeClipboardWorking();

   159 

   160     QPlainTextEdit *ed;

   161     qreal rootFrameMargin;

   162 };

   163 

   164 bool tst_QPlainTextEdit::nativeClipboardWorking()

   165 {

   166 #ifdef Q_WS_MAC

   167     PasteboardRef pasteboard;

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

   169     if (status == noErr)

   170         CFRelease(pasteboard);

   171     return status == noErr;

   172 #endif

   173     return true;

   174 }

   175 

   176 // Testing get/set functions

   177 void tst_QPlainTextEdit::getSetCheck()

   178 {

   179     QPlainTextEdit obj1;

   180     // QTextDocument * QPlainTextEdit::document()

   181     // void QPlainTextEdit::setDocument(QTextDocument *)

   182     QTextDocument *var1 = new QTextDocument;

   183     var1->setDocumentLayout(new QPlainTextDocumentLayout(var1));

   184     obj1.setDocument(var1);

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

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

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

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

   189     delete var1;

   190 

   191 

   192     // bool QPlainTextEdit::tabChangesFocus()

   193     // void QPlainTextEdit::setTabChangesFocus(bool)

   194     obj1.setTabChangesFocus(false);

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

   196     obj1.setTabChangesFocus(true);

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

   198 

   199     // LineWrapMode QPlainTextEdit::lineWrapMode()

   200     // void QPlainTextEdit::setLineWrapMode(LineWrapMode)

   201     obj1.setLineWrapMode(QPlainTextEdit::LineWrapMode(QPlainTextEdit::NoWrap));

   202     QCOMPARE(QPlainTextEdit::LineWrapMode(QPlainTextEdit::NoWrap), obj1.lineWrapMode());

   203     obj1.setLineWrapMode(QPlainTextEdit::LineWrapMode(QPlainTextEdit::WidgetWidth));

   204     QCOMPARE(QPlainTextEdit::LineWrapMode(QPlainTextEdit::WidgetWidth), obj1.lineWrapMode());

   205 //     obj1.setLineWrapMode(QPlainTextEdit::LineWrapMode(QPlainTextEdit::FixedPixelWidth));

   206 //     QCOMPARE(QPlainTextEdit::LineWrapMode(QPlainTextEdit::FixedPixelWidth), obj1.lineWrapMode());

   207 //     obj1.setLineWrapMode(QPlainTextEdit::LineWrapMode(QPlainTextEdit::FixedColumnWidth));

   208 //     QCOMPARE(QPlainTextEdit::LineWrapMode(QPlainTextEdit::FixedColumnWidth), obj1.lineWrapMode());

   209 

   210 

   211     // bool QPlainTextEdit::overwriteMode()

   212     // void QPlainTextEdit::setOverwriteMode(bool)

   213     obj1.setOverwriteMode(false);

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

   215     obj1.setOverwriteMode(true);

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

   217 

   218     // int QPlainTextEdit::tabStopWidth()

   219     // void QPlainTextEdit::setTabStopWidth(int)

   220     obj1.setTabStopWidth(0);

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

   222     obj1.setTabStopWidth(INT_MIN);

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

   224 #if defined(QT_ARCH_WINDOWSCE) || defined (QT_ARCH_SYMBIAN)

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

   226     // we cannot use INT_MAX for this check

   227     obj1.setTabStopWidth(SHRT_MAX*2);

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

   229 #else

   230     obj1.setTabStopWidth(INT_MAX);

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

   232 #endif

   233 

   234 }

   235 

   236 class QtTestDocumentLayout : public QAbstractTextDocumentLayout

   237 {

   238     Q_OBJECT

   239 public:

   240     inline QtTestDocumentLayout(QPlainTextEdit *edit, QTextDocument *doc, int &itCount)

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

   242 

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

   244 

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

   246 

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

   248 

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

   250 

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

   252 

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

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

   255 

   256     bool useBiggerSize;

   257     QSize usedSize;

   258 

   259     QPlainTextEdit *ed;

   260 

   261     int &iterationCounter;

   262 };

   263 

   264 tst_QPlainTextEdit::tst_QPlainTextEdit()

   265 {}

   266 

   267 void tst_QPlainTextEdit::initTestCase()

   268 {

   269 #ifdef Q_OS_WINCE //disable magic for WindowsCE

   270     qApp->setAutoMaximizeThreshold(-1);

   271 #endif

   272 }

   273 

   274 void tst_QPlainTextEdit::init()

   275 {

   276     ed = new QPlainTextEdit(0);

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

   278 }

   279 

   280 void tst_QPlainTextEdit::cleanup()

   281 {

   282     delete ed;

   283     ed = 0;

   284 }

   285 

   286 

   287 void tst_QPlainTextEdit::createSelection()

   288 {

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

   290     /* go to start */

   291 #ifndef Q_WS_MAC

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

   293 #else

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

   295 #endif

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

   297     /* select until end of text */

   298 #ifndef Q_WS_MAC

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

   300 #else

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

   302 #endif

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

   304 }

   305 #ifndef QT_NO_CLIPBOARD

   306 void tst_QPlainTextEdit::clearMustNotChangeClipboard()

   307 {

   308     if (!nativeClipboardWorking())

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

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

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

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

   313     ed->clear();

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

   315 }

   316 #endif

   317 

   318 void tst_QPlainTextEdit::clearMustNotResetRootFrameMarginToDefault()

   319 {

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

   321     ed->clear();

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

   323 }

   324 

   325 

   326 void tst_QPlainTextEdit::paragSeparatorOnPlaintextAppend()

   327 {

   328     ed->appendPlainText("Hello\nWorld");

   329     int cnt = 0;

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

   331     while (blk.isValid()) {

   332         ++cnt;

   333         blk = blk.next();

   334     }

   335     QCOMPARE(cnt, 2);

   336 }

   337 

   338 #ifndef QT_NO_CLIPBOARD

   339 void tst_QPlainTextEdit::selectAllSetsNotSelection()

   340 {

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

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

   343         return;

   344     }

   345 

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

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

   348 

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

   350     ed->selectAll();

   351 

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

   353 }

   354 #endif

   355 

   356 void tst_QPlainTextEdit::asciiTab()

   357 {

   358     QPlainTextEdit edit;

   359     edit.setPlainText("\t");

   360     edit.show();

   361     qApp->processEvents();

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

   363 }

   364 

   365 void tst_QPlainTextEdit::setDocument()

   366 {

   367     QTextDocument *document = new QTextDocument(ed);

   368     document->setDocumentLayout(new QPlainTextDocumentLayout(document));

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

   370     ed->setDocument(document);

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

   372 }

   373 

   374 

   375 int tst_QPlainTextEdit::blockCount() const

   376 {

   377     int blocks = 0;

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

   379         ++blocks;

   380     return blocks;

   381 }

   382 

   383 int tst_QPlainTextEdit::lineCount() const

   384 {

   385     int lines = 0;

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

   387         ed->document()->documentLayout()->blockBoundingRect(block);

   388         lines += block.layout()->lineCount();

   389     }

   390     return lines;

   391 }

   392 

   393 // Supporter issue #56783

   394 void tst_QPlainTextEdit::emptyAppend()

   395 {

   396     ed->appendPlainText("Blah");

   397     QCOMPARE(blockCount(), 1);

   398     ed->appendPlainText(QString::null);

   399     QCOMPARE(blockCount(), 2);

   400     ed->appendPlainText(QString("   "));

   401     QCOMPARE(blockCount(), 3);

   402 }

   403 

   404 void tst_QPlainTextEdit::appendOnEmptyDocumentShouldReuseInitialParagraph()

   405 {

   406     QCOMPARE(blockCount(), 1);

   407     ed->appendPlainText("Blah");

   408     QCOMPARE(blockCount(), 1);

   409 }

   410 

   411 

   412 class CursorPositionChangedRecorder : public QObject

   413 {

   414     Q_OBJECT

   415 public:

   416     inline CursorPositionChangedRecorder(QPlainTextEdit *ed)

   417         : editor(ed)

   418     {

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

   420     }

   421 

   422     QList<int> cursorPositions;

   423 

   424 private slots:

   425     void recordCursorPos()

   426     {

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

   428     }

   429 

   430 private:

   431     QPlainTextEdit *editor;

   432 };

   433 

   434 void tst_QPlainTextEdit::cursorPositionChanged()

   435 {

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

   437 

   438     spy.clear();

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

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

   441 

   442     QTextCursor cursor = ed->textCursor();

   443     cursor.movePosition(QTextCursor::Start);

   444     ed->setTextCursor(cursor);

   445     cursor.movePosition(QTextCursor::End);

   446     spy.clear();

   447     cursor.insertText("Test");

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

   449 

   450     cursor.movePosition(QTextCursor::End);

   451     ed->setTextCursor(cursor);

   452     cursor.movePosition(QTextCursor::Start);

   453     spy.clear();

   454     cursor.insertText("Test");

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

   456 

   457     spy.clear();

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

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

   460 

   461     CursorPositionChangedRecorder spy2(ed);

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

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

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

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

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

   467 }

   468 

   469 void tst_QPlainTextEdit::setTextCursor()

   470 {

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

   472 

   473     ed->setPlainText("Test");

   474     QTextCursor cursor = ed->textCursor();

   475     cursor.movePosition(QTextCursor::Start);

   476     cursor.movePosition(QTextCursor::NextCharacter);

   477 

   478     spy.clear();

   479 

   480     ed->setTextCursor(cursor);

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

   482 }

   483 

   484 #ifndef QT_NO_CLIPBOARD

   485 void tst_QPlainTextEdit::undoAvailableAfterPaste()

   486 {

   487     if (!nativeClipboardWorking())

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

   489 

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

   491 

   492     const QString txt("Test");

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

   494     ed->paste();

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

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

   497 }

   498 #endif

   499 

   500 class UndoRedoRecorder : public QObject

   501 {

   502     Q_OBJECT

   503 public:

   504     UndoRedoRecorder(QTextDocument *doc)

   505         : undoRepetitions(false)

   506         , redoRepetitions(false)

   507         , undoCount(0)

   508         , redoCount(0)

   509     {

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

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

   512     }

   513 

   514     bool undoRepetitions;

   515     bool redoRepetitions;

   516 

   517 private slots:

   518     void undoAvailable(bool enabled) {

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

   520             undoRepetitions = true;

   521 

   522         ++undoCount;

   523         lastUndoEnabled = enabled;

   524     }

   525 

   526     void redoAvailable(bool enabled) {

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

   528             redoRepetitions = true;

   529 

   530         ++redoCount;

   531         lastRedoEnabled = enabled;

   532     }

   533 

   534 private:

   535     bool lastUndoEnabled;

   536     bool lastRedoEnabled;

   537 

   538     int undoCount;

   539     int redoCount;

   540 };

   541 

   542 void tst_QPlainTextEdit::undoRedoAvailableRepetition()

   543 {

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

   545 

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

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

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

   549     ed->undo(); ed->undo(); ed->undo();

   550     ed->redo(); ed->redo(); ed->redo();

   551 

   552     QVERIFY(!spy.undoRepetitions);

   553     QVERIFY(!spy.redoRepetitions);

   554 }

   555 

   556 void tst_QPlainTextEdit::appendShouldNotTouchTheSelection()

   557 {

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

   559     QTextCharFormat fmt;

   560     fmt.setForeground(Qt::blue);

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

   562     fmt.setForeground(Qt::red);

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

   564 

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

   566 

   567     cursor.movePosition(QTextCursor::Start);

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

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

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

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

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

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

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

   575 

   576     ed->setTextCursor(cursor);

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

   578 

   579     ed->appendHtml("<b>Some Bold Text</b>");

   580     cursor.movePosition(QTextCursor::Start);

   581     cursor.movePosition(QTextCursor::NextCharacter);

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

   583 }

   584 

   585 void tst_QPlainTextEdit::backspace()

   586 {

   587     QTextCursor cursor = ed->textCursor();

   588 

   589     QTextListFormat listFmt;

   590     listFmt.setStyle(QTextListFormat::ListDisc);

   591     listFmt.setIndent(1);

   592     cursor.insertList(listFmt);

   593     cursor.insertText("A");

   594 

   595     ed->setTextCursor(cursor);

   596 

   597     // delete 'A'

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

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

   600     // delete list

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

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

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

   604     // outdent paragraph

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

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

   607 }

   608 

   609 void tst_QPlainTextEdit::shiftBackspace()

   610 {

   611     QTextCursor cursor = ed->textCursor();

   612 

   613     QTextListFormat listFmt;

   614     listFmt.setStyle(QTextListFormat::ListDisc);

   615     listFmt.setIndent(1);

   616     cursor.insertList(listFmt);

   617     cursor.insertText("A");

   618 

   619     ed->setTextCursor(cursor);

   620 

   621     // delete 'A'

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

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

   624     // delete list

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

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

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

   628     // outdent paragraph

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

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

   631 }

   632 

   633 void tst_QPlainTextEdit::undoRedo()

   634 {

   635     ed->clear();

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

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

   638     ed->undo();

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

   640     ed->redo();

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

   642 #ifdef Q_WS_WIN

   643     // shortcut for undo

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

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

   646     // shortcut for redo

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

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

   649 #endif

   650 }

   651 

   652 // Task #70465

   653 void tst_QPlainTextEdit::preserveCharFormatInAppend()

   654 {

   655     ed->appendHtml("First para");

   656     ed->appendHtml("<b>Second para</b>");

   657     ed->appendHtml("third para");

   658 

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

   660 

   661     cursor.movePosition(QTextCursor::Start);

   662     cursor.movePosition(QTextCursor::NextCharacter);

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

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

   665 

   666     cursor.movePosition(QTextCursor::NextBlock);

   667     cursor.movePosition(QTextCursor::NextCharacter);

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

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

   670 

   671     cursor.movePosition(QTextCursor::NextBlock);

   672     cursor.movePosition(QTextCursor::NextCharacter);

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

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

   675 }

   676 

   677 #ifndef QT_NO_CLIPBOARD

   678 void tst_QPlainTextEdit::copyAndSelectAllInReadonly()

   679 {

   680     if (!nativeClipboardWorking())

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

   682 

   683     ed->setReadOnly(true);

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

   685 

   686     QTextCursor cursor = ed->textCursor();

   687     cursor.clearSelection();

   688     ed->setTextCursor(cursor);

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

   690 

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

   692 

   693     // shouldn't do anything

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

   695 

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

   697 

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

   699 

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

   701 

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

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

   704 

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

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

   707 }

   708 #endif

   709 

   710 void tst_QPlainTextEdit::ctrlAltInput()

   711 {

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

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

   714 }

   715 

   716 void tst_QPlainTextEdit::noPropertiesOnDefaultTextEditCharFormat()

   717 {

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

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

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

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

   722     QCOMPARE(ed->textCursor().charFormat().properties().count(), 0);

   723 }

   724 

   725 void tst_QPlainTextEdit::setPlainTextShouldEmitTextChangedOnce()

   726 {

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

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

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

   730     ed->setPlainText("");

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

   732 }

   733 

   734 void tst_QPlainTextEdit::overwriteMode()

   735 {

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

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

   738 

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

   740 

   741     ed->setOverwriteMode(true);

   742 

   743     QTextCursor cursor = ed->textCursor();

   744     cursor.setPosition(5);

   745     ed->setTextCursor(cursor);

   746 

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

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

   749 

   750     cursor.movePosition(QTextCursor::End);

   751     ed->setTextCursor(cursor);

   752 

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

   754 

   755     ed->setOverwriteMode(false);

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

   757 

   758     QCOMPARE(blockCount(), 2);

   759 

   760     cursor.movePosition(QTextCursor::Start);

   761     cursor.movePosition(QTextCursor::EndOfBlock);

   762 

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

   764     ed->setTextCursor(cursor);

   765 

   766     ed->setOverwriteMode(true);

   767 

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

   769 

   770     QCOMPARE(blockCount(), 2);

   771 

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

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

   774     block = block.next();

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

   776 }

   777 

   778 void tst_QPlainTextEdit::shiftDownInLineLastShouldSelectToEnd_data()

   779 {

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

   781 

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

   783     QTest::addColumn<int>("totalLineCount");

   784 

   785     QTest::newRow("1") << QString("Foo\nBar") << 2;

   786     QTest::newRow("2") << QString("Foo\nBar") + QChar(QChar::LineSeparator) + QString("Baz") << 3;

   787 }

   788 

   789 void tst_QPlainTextEdit::shiftDownInLineLastShouldSelectToEnd()

   790 {

   791     QFETCH(QString, input);

   792     QFETCH(int, totalLineCount);

   793 

   794     ed->setPlainText(input);

   795     ed->show();

   796 

   797     // ensure we're layouted

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

   799         ed->document()->documentLayout()->blockBoundingRect(block);

   800 

   801     QCOMPARE(blockCount(), 2);

   802 

   803     int lineCount = 0;

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

   805         lineCount += block.layout()->lineCount();

   806     QCOMPARE(lineCount, totalLineCount);

   807 

   808     QTextCursor cursor = ed->textCursor();

   809     cursor.movePosition(QTextCursor::Start);

   810     ed->setTextCursor(cursor);

   811 

   812     for (int i = 0; i < lineCount; ++i) {

   813         QTest::keyClick(ed, Qt::Key_Down, Qt::ShiftModifier);

   814     }

   815 

   816     input.replace(QLatin1Char('\n'), QChar(QChar::ParagraphSeparator));

   817     QCOMPARE(ed->textCursor().selectedText(), input);

   818     QVERIFY(ed->textCursor().atEnd());

   819 

   820     // also test that without shift modifier the cursor does not move to the end

   821     // for Key_Down in the last line

   822     cursor.movePosition(QTextCursor::Start);

   823     ed->setTextCursor(cursor);

   824     for (int i = 0; i < lineCount; ++i) {

   825         QTest::keyClick(ed, Qt::Key_Down);

   826     }

   827     QVERIFY(!ed->textCursor().atEnd());

   828 }

   829 

   830 void tst_QPlainTextEdit::undoRedoShouldRepositionTextEditCursor()

   831 {

   832     ed->setPlainText("five\nlines\nin\nthis\ntextedit");

   833     QTextCursor cursor = ed->textCursor();

   834     cursor.movePosition(QTextCursor::Start);

   835 

   836     ed->setUndoRedoEnabled(false);

   837     ed->setUndoRedoEnabled(true);

   838 

   839     QVERIFY(!ed->document()->isUndoAvailable());

   840     QVERIFY(!ed->document()->isRedoAvailable());

   841 

   842     cursor.insertText("Blah");

   843 

   844     QVERIFY(ed->document()->isUndoAvailable());

   845     QVERIFY(!ed->document()->isRedoAvailable());

   846 

   847     cursor.movePosition(QTextCursor::End);

   848     ed->setTextCursor(cursor);

   849 

   850     QVERIFY(QMetaObject::invokeMethod(ed, "undo"));

   851 

   852     QVERIFY(!ed->document()->isUndoAvailable());

   853     QVERIFY(ed->document()->isRedoAvailable());

   854 

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

   856 

   857     cursor.movePosition(QTextCursor::End);

   858     ed->setTextCursor(cursor);

   859 

   860     QVERIFY(QMetaObject::invokeMethod(ed, "redo"));

   861 

   862     QVERIFY(ed->document()->isUndoAvailable());

   863     QVERIFY(!ed->document()->isRedoAvailable());

   864 

   865     QCOMPARE(ed->textCursor().position(), 4);

   866 }

   867 

   868 void tst_QPlainTextEdit::lineWrapModes()

   869 {

   870     QWidget *window = new QWidget;

   871     ed->setParent(window);

   872     window->show();

   873     ed->show();

   874     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");

   875     ed->setLineWrapMode(QPlainTextEdit::NoWrap);

   876     QCOMPARE(lineCount(), 1);

   877     ed->setLineWrapMode(QPlainTextEdit::WidgetWidth);

   878 

   879     // QPlainTextEdit does lazy line layout on resize, only for the visible blocks.

   880     // We thus need to make it wide enough to show something visible.

   881     int minimumWidth = 2 * ed->document()->documentMargin();

   882     minimumWidth += ed->fontMetrics().width(QLatin1Char('a'));

   883     ed->resize(minimumWidth, 1000);

   884     QCOMPARE(lineCount(), 26);

   885     ed->setParent(0);

   886     delete window;

   887 }

   888 

   889 void tst_QPlainTextEdit::mouseCursorShape()

   890 {

   891 #ifndef QT_NO_CURSOR

   892     // always show an IBeamCursor, see change 170146

   893     QVERIFY(!ed->isReadOnly());

   894     QVERIFY(ed->viewport()->cursor().shape() == Qt::IBeamCursor);

   895 

   896     ed->setReadOnly(true);

   897     QVERIFY(ed->viewport()->cursor().shape() == Qt::IBeamCursor);

   898 

   899     ed->setPlainText("Foo");

   900     QVERIFY(ed->viewport()->cursor().shape() == Qt::IBeamCursor);

   901 #endif

   902 }

   903 

   904 void tst_QPlainTextEdit::implicitClear()

   905 {

   906     // test that QPlainTextEdit::setHtml, etc. avoid calling clear() but instead call

   907     // QTextDocument::setHtml/etc. instead, which also clear the contents and

   908     // cached resource but preserve manually added resources. setHtml on a textedit

   909     // should behave the same as on a document with respect to that.

   910     // see also clearResources() autotest in qtextdocument

   911 

   912     // regular resource for QTextDocument

   913     QUrl testUrl(":/foobar");

   914     QVariant testResource("hello world");

   915 

   916     ed->document()->addResource(QTextDocument::ImageResource, testUrl, testResource);

   917     QVERIFY(ed->document()->resource(QTextDocument::ImageResource, testUrl) == testResource);

   918 

   919     ed->setPlainText("Blah");

   920     QVERIFY(ed->document()->resource(QTextDocument::ImageResource, testUrl) == testResource);

   921 

   922     ed->setPlainText("<b>Blah</b>");

   923     QVERIFY(ed->document()->resource(QTextDocument::ImageResource, testUrl) == testResource);

   924 

   925     ed->clear();

   926     QVERIFY(!ed->document()->resource(QTextDocument::ImageResource, testUrl).isValid());

   927     QVERIFY(ed->toPlainText().isEmpty());

   928 }

   929 

   930 #ifndef QT_NO_CLIPBOARD

   931 void tst_QPlainTextEdit::copyAvailable_data()

   932 {

   933     QTest::addColumn<pairListType>("keystrokes");

   934     QTest::addColumn<QList<bool> >("copyAvailable");

   935     QTest::addColumn<QString>("function");

   936 

   937     pairListType keystrokes;

   938     QList<bool> copyAvailable;

   939 

   940     keystrokes << qMakePair(Qt::Key_B, Qt::NoModifier) <<  qMakePair(Qt::Key_B, Qt::NoModifier)

   941                << qMakePair(Qt::Key_Left, Qt::ShiftModifier);

   942     copyAvailable << true ;

   943     QTest::newRow(QString("Case1 B,B, <- + shift | signals: true").toLatin1())

   944         << keystrokes << copyAvailable << QString();

   945 

   946     keystrokes.clear();

   947     copyAvailable.clear();

   948 

   949     keystrokes << qMakePair(Qt::Key_T, Qt::NoModifier) << qMakePair(Qt::Key_A, Qt::NoModifier)

   950                <<  qMakePair(Qt::Key_A, Qt::NoModifier) << qMakePair(Qt::Key_Left, Qt::ShiftModifier);

   951     copyAvailable << true << false;

   952     QTest::newRow(QString("Case2 T,A,A, <- + shift, cut() | signals: true, false").toLatin1())

   953         << keystrokes << copyAvailable << QString("cut");

   954 

   955     keystrokes.clear();

   956     copyAvailable.clear();

   957 

   958     keystrokes << qMakePair(Qt::Key_T, Qt::NoModifier) << qMakePair(Qt::Key_A, Qt::NoModifier)

   959                <<  qMakePair(Qt::Key_A, Qt::NoModifier) << qMakePair(Qt::Key_Left, Qt::ShiftModifier)

   960                << qMakePair(Qt::Key_Left, Qt::ShiftModifier)  << qMakePair(Qt::Key_Left, Qt::ShiftModifier);

   961     copyAvailable << true;

   962     QTest::newRow(QString("Case3 T,A,A, <- + shift, <- + shift, <- + shift, copy() | signals: true").toLatin1())

   963         << keystrokes << copyAvailable << QString("copy");

   964 

   965     keystrokes.clear();

   966     copyAvailable.clear();

   967 

   968     keystrokes << qMakePair(Qt::Key_T, Qt::NoModifier) << qMakePair(Qt::Key_A, Qt::NoModifier)

   969                <<  qMakePair(Qt::Key_A, Qt::NoModifier) << qMakePair(Qt::Key_Left, Qt::ShiftModifier)

   970                << qMakePair(Qt::Key_Left, Qt::ShiftModifier)  << qMakePair(Qt::Key_Left, Qt::ShiftModifier)

   971                << qMakePair(Qt::Key_X, Qt::ControlModifier);

   972     copyAvailable << true << false;

   973     QTest::newRow(QString("Case4 T,A,A, <- + shift, <- + shift, <- + shift, ctrl + x, paste() | signals: true, false").toLatin1())

   974         << keystrokes << copyAvailable << QString("paste");

   975 

   976     keystrokes.clear();

   977     copyAvailable.clear();

   978 

   979     keystrokes << qMakePair(Qt::Key_B, Qt::NoModifier) <<  qMakePair(Qt::Key_B, Qt::NoModifier)

   980                << qMakePair(Qt::Key_Left, Qt::ShiftModifier) << qMakePair(Qt::Key_Left, Qt::NoModifier);

   981     copyAvailable << true << false;

   982     QTest::newRow(QString("Case5 B,B, <- + shift, <- | signals: true, false").toLatin1())

   983         << keystrokes << copyAvailable << QString();

   984 

   985     keystrokes.clear();

   986     copyAvailable.clear();

   987 

   988     keystrokes << qMakePair(Qt::Key_B, Qt::NoModifier) <<  qMakePair(Qt::Key_A, Qt::NoModifier)

   989                << qMakePair(Qt::Key_Left, Qt::ShiftModifier) << qMakePair(Qt::Key_Left, Qt::NoModifier)

   990                << qMakePair(Qt::Key_Right, Qt::ShiftModifier);

   991     copyAvailable << true << false << true << false;

   992     QTest::newRow(QString("Case6 B,A, <- + shift, ->, <- + shift | signals: true, false, true, false").toLatin1())

   993         << keystrokes << copyAvailable << QString("cut");

   994 

   995     keystrokes.clear();

   996     copyAvailable.clear();

   997 

   998     keystrokes << qMakePair(Qt::Key_T, Qt::NoModifier) << qMakePair(Qt::Key_A, Qt::NoModifier)

   999                <<  qMakePair(Qt::Key_A, Qt::NoModifier) << qMakePair(Qt::Key_Left, Qt::ShiftModifier)

  1000                << qMakePair(Qt::Key_Left, Qt::ShiftModifier)  << qMakePair(Qt::Key_Left, Qt::ShiftModifier)

  1001                << qMakePair(Qt::Key_X, Qt::ControlModifier);

  1002     copyAvailable << true << false << true;

  1003     QTest::newRow(QString("Case7 T,A,A, <- + shift, <- + shift, <- + shift, ctrl + x, undo() | signals: true, false, true").toLatin1())

  1004         << keystrokes << copyAvailable << QString("undo");

  1005 }

  1006 

  1007 //Tests the copyAvailable slot for several cases

  1008 void tst_QPlainTextEdit::copyAvailable()

  1009 {

  1010     QFETCH(pairListType,keystrokes);

  1011     QFETCH(QList<bool>, copyAvailable);

  1012     QFETCH(QString, function);

  1013 

  1014 #ifdef Q_WS_MAC

  1015     QSKIP("copyAvailable has never passed on Mac, task to fix is 132482", SkipAll);

  1016 #endif

  1017     ed->clear();

  1018     QApplication::clipboard()->clear();

  1019     QVERIFY(!ed->canPaste());

  1020     QSignalSpy spyCopyAvailabe(ed, SIGNAL(copyAvailable(bool)));

  1021 

  1022     //Execute Keystrokes

  1023     foreach(keyPairType keyPair, keystrokes) {

  1024         QTest::keyClick(ed, keyPair.first, keyPair.second );

  1025     }

  1026 

  1027     //Execute ed->"function"

  1028     if (function == "cut")

  1029         ed->cut();

  1030     else if (function == "copy")

  1031         ed->copy();

  1032     else if (function == "paste")

  1033         ed->paste();

  1034     else if (function == "undo")

  1035         ed->paste();

  1036     else if (function == "redo")

  1037         ed->paste();

  1038 

  1039     //Compare spied signals

  1040     QEXPECT_FAIL("Case7 T,A,A, <- + shift, <- + shift, <- + shift, ctrl + x, undo() | signals: true, false, true",

  1041         "Wrong undo selection behaviour. Should be fixed in some future release. (See task: 132482)", Abort);

  1042     QCOMPARE(spyCopyAvailabe.count(), copyAvailable.count());

  1043     for (int i=0;i<spyCopyAvailabe.count(); i++) {

  1044         QVariant variantSpyCopyAvailable = spyCopyAvailabe.at(i).at(0);

  1045         QVERIFY2(variantSpyCopyAvailable.toBool() == copyAvailable.at(i), QString("Spied singnal: %1").arg(i).toLatin1());

  1046     }

  1047 }

  1048 #endif

  1049 

  1050 void tst_QPlainTextEdit::undoRedoAfterSetContent()

  1051 {

  1052     QVERIFY(!ed->document()->isUndoAvailable());

  1053     QVERIFY(!ed->document()->isRedoAvailable());

  1054     ed->setPlainText("Foobar");

  1055     QVERIFY(!ed->document()->isUndoAvailable());

  1056     QVERIFY(!ed->document()->isRedoAvailable());

  1057     ed->setPlainText("<p>bleh</p>");

  1058     QVERIFY(!ed->document()->isUndoAvailable());

  1059     QVERIFY(!ed->document()->isRedoAvailable());

  1060 }

  1061 

  1062 void tst_QPlainTextEdit::numPadKeyNavigation()

  1063 {

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

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

  1066     QTest::keyClick(ed, Qt::Key_Right, Qt::KeypadModifier);

  1067     QCOMPARE(ed->textCursor().position(), 1);

  1068 }

  1069 

  1070 void tst_QPlainTextEdit::moveCursor()

  1071 {

  1072     ed->setPlainText("Test");

  1073 

  1074     QSignalSpy cursorMovedSpy(ed, SIGNAL(cursorPositionChanged()));

  1075 

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

  1077     ed->moveCursor(QTextCursor::NextCharacter);

  1078     QCOMPARE(ed->textCursor().position(), 1);

  1079     QCOMPARE(cursorMovedSpy.count(), 1);

  1080     ed->moveCursor(QTextCursor::NextCharacter, QTextCursor::KeepAnchor);

  1081     QCOMPARE(ed->textCursor().position(), 2);

  1082     QCOMPARE(cursorMovedSpy.count(), 2);

  1083     QCOMPARE(ed->textCursor().selectedText(), QString("e"));

  1084 }

  1085 

  1086 class MyTextEdit : public QPlainTextEdit

  1087 {

  1088 public:

  1089     inline MyTextEdit()

  1090         : createMimeDataCallCount(0),

  1091           canInsertCallCount(0),

  1092           insertCallCount(0)

  1093     {}

  1094 

  1095     mutable int createMimeDataCallCount;

  1096     mutable int canInsertCallCount;

  1097     mutable int insertCallCount;

  1098 

  1099     virtual QMimeData *createMimeDataFromSelection() const {

  1100         createMimeDataCallCount++;

  1101         return QPlainTextEdit::createMimeDataFromSelection();

  1102     }

  1103     virtual bool canInsertFromMimeData(const QMimeData *source) const {

  1104         canInsertCallCount++;

  1105         return QPlainTextEdit::canInsertFromMimeData(source);

  1106     }

  1107     virtual void insertFromMimeData(const QMimeData *source) {

  1108         insertCallCount++;

  1109         QPlainTextEdit::insertFromMimeData(source);

  1110     }

  1111 

  1112 };

  1113 

  1114 #ifndef QT_NO_CLIPBOARD

  1115 void tst_QPlainTextEdit::mimeDataReimplementations()

  1116 {

  1117     MyTextEdit ed;

  1118     ed.setPlainText("Hello World");

  1119 

  1120     QCOMPARE(ed.createMimeDataCallCount, 0);

  1121     QCOMPARE(ed.canInsertCallCount, 0);

  1122     QCOMPARE(ed.insertCallCount, 0);

  1123 

  1124     ed.selectAll();

  1125 

  1126     QCOMPARE(ed.createMimeDataCallCount, 0);

  1127     QCOMPARE(ed.canInsertCallCount, 0);

  1128     QCOMPARE(ed.insertCallCount, 0);

  1129 

  1130     ed.copy();

  1131 

  1132     QCOMPARE(ed.createMimeDataCallCount, 1);

  1133     QCOMPARE(ed.canInsertCallCount, 0);

  1134     QCOMPARE(ed.insertCallCount, 0);