/****************************************************************************

**

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

** All rights reserved.

** Contact: Nokia Corporation (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 Technology Preview License Agreement accompanying

** this package.

**

** 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.1, included in the file LGPL_EXCEPTION.txt in this package.

**

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

** Nokia at qt-info@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();

#ifndef QT_NO_CLIPBOARD

    void clearMustNotChangeClipboard();

#endif

    void clearMustNotResetRootFrameMarginToDefault();

    void paragSeparatorOnPlaintextAppend();

#ifndef QT_NO_CLIPBOARD

    void selectAllSetsNotSelection();

#endif

    void asciiTab();

    void setDocument();

    void emptyAppend();

    void appendOnEmptyDocumentShouldReuseInitialParagraph();

    void cursorPositionChanged();

    void setTextCursor();

#ifndef QT_NO_CLIPBOARD

    void undoAvailableAfterPaste();

#endif

    void undoRedoAvailableRepetition();

    void appendShouldNotTouchTheSelection();

    void backspace();

    void shiftBackspace();

    void undoRedo();

    void preserveCharFormatInAppend();

#ifndef QT_NO_CLIPBOARD

    void copyAndSelectAllInReadonly();

#endif

    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();

#ifndef QT_NO_CLIPBOARD

    void mimeDataReimplementations();

#endif

    void shiftEnterShouldInsertLineSeparator();

    void selectWordsFromStringsContainingSeparators_data();

    void selectWordsFromStringsContainingSeparators();

#ifndef QT_NO_CLIPBOARD

    void canPaste();

    void copyAvailable_data();

    void copyAvailable();

#endif

    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) || defined (QT_ARCH_SYMBIAN)

    // 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);

}

#ifndef QT_NO_CLIPBOARD

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

}

#endif

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

}

#ifndef QT_NO_CLIPBOARD

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

}

#endif

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

}

#ifndef QT_NO_CLIPBOARD

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

}

#endif

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;