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

**

** 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 <qtextdocument.h>

#include <qdebug.h>

#include <qtextcursor.h>

#include <qtextdocumentfragment.h>

#include <qtextformat.h>

#include <qtextobject.h>

#include <qtexttable.h>

#include <qabstracttextdocumentlayout.h>

#include <qtextlist.h>

#include <qtextcodec.h>

#include <qurl.h>

#include <qpainter.h>

#include <qfontmetrics.h>

#include <qimage.h>

#include <qtextlayout.h>

#include <QDomDocument>

#include "common.h"

QT_FORWARD_DECLARE_CLASS(QTextDocument)

//TESTED_CLASS=

//TESTED_FILES=

class tst_QTextDocument : public QObject

{

    Q_OBJECT

public:

    tst_QTextDocument();

    virtual ~tst_QTextDocument();

public slots:

    void init();

    void cleanup();

private slots:

    void getSetCheck();

    void isEmpty();

    void find_data();

    void find();

    void find2();

    void findWithRegExp_data();

    void findWithRegExp();

    void findMultiple();

    void basicIsModifiedChecks();

    void moreIsModified();

    void isModified2();

    void isModified3();

    void isModified4();

    void noundo_basicIsModifiedChecks();

    void noundo_moreIsModified();

    void noundo_isModified2();

    void noundo_isModified3();

    void mightBeRichText();

    void task240325();

    void stylesheetFont_data();

    void stylesheetFont();

    void toHtml_data();

    void toHtml();

    void toHtml2();

    void setFragmentMarkersInHtmlExport();

    void toHtmlBodyBgColor();

    void toHtmlRootFrameProperties();

    void capitalizationHtmlInExport();

    void wordspacingHtmlExport();

    void cursorPositionChanged();

    void cursorPositionChangedOnSetText();

    void textFrameIterator();

    void codecForHtml();

    void markContentsDirty();

    void clonePreservesMetaInformation();

    void clonePreservesPageSize();

    void clonePreservesPageBreakPolicies();

    void clonePreservesDefaultFont();

    void clonePreservesRootFrameFormat();

    void clonePreservesResources();

    void clonePreservesUserStates();

    void clonePreservesIndentWidth();

    void blockCount();

    void defaultStyleSheet();

    void resolvedFontInEmptyFormat();

    void defaultRootFrameMargin();

    void clearResources();

    void setPlainText();

    void toPlainText();

    void deleteTextObjectsOnClear();

    void maximumBlockCount();

    void adjustSize();

    void initialUserData();

    void html_defaultFont();

    void blockCountChanged();

    void nonZeroDocumentLengthOnClear();

    void setTextPreservesUndoRedoEnabled();

    void firstLast();

    void backgroundImage_toHtml();

    void backgroundImage_toHtml2();

    void backgroundImage_clone();

    void backgroundImage_copy();

    void documentCleanup();

    void characterAt();

    void revisions();

    void revisionWithUndoCompressionAndUndo();

    void testUndoCommandAdded();

    void testUndoBlocks();

    void receiveCursorPositionChangedAfterContentsChange();

    void escape_data();

    void escape();

private:

    void backgroundImage_checkExpectedHtml(const QTextDocument &doc);

    QTextDocument *doc;

    QTextCursor cursor;

    QFont defaultFont;

    QString htmlHead;

    QString htmlTail;

};

class MyAbstractTextDocumentLayout : public QAbstractTextDocumentLayout

{

public:

    MyAbstractTextDocumentLayout(QTextDocument *doc) : QAbstractTextDocumentLayout(doc) {}

    void draw(QPainter *, const PaintContext &) {}

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

    int pageCount() const { return 0; }

    QSizeF documentSize() const { return QSizeF(); }

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

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

    void documentChanged(int, int, int) {}

};

// Testing get/set functions

void tst_QTextDocument::getSetCheck()

{

    QTextDocument obj1;

    // QAbstractTextDocumentLayout * QTextDocument::documentLayout()

    // void QTextDocument::setDocumentLayout(QAbstractTextDocumentLayout *)

    QPointer<MyAbstractTextDocumentLayout> var1 = new MyAbstractTextDocumentLayout(0);

    obj1.setDocumentLayout(var1);

    QCOMPARE(static_cast<QAbstractTextDocumentLayout *>(var1), obj1.documentLayout());

    obj1.setDocumentLayout((QAbstractTextDocumentLayout *)0);

    QVERIFY(var1.isNull());

    QVERIFY(obj1.documentLayout());

    // bool QTextDocument::useDesignMetrics()

    // void QTextDocument::setUseDesignMetrics(bool)

    obj1.setUseDesignMetrics(false);

    QCOMPARE(false, obj1.useDesignMetrics());

    obj1.setUseDesignMetrics(true);

    QCOMPARE(true, obj1.useDesignMetrics());

}

tst_QTextDocument::tst_QTextDocument()

{

    QImage img(16, 16, QImage::Format_ARGB32_Premultiplied);

    img.save("foo.png");

}

tst_QTextDocument::~tst_QTextDocument()

{

    QFile::remove(QLatin1String("foo.png"));

}

void tst_QTextDocument::init()

{

    doc = new QTextDocument;

    cursor = QTextCursor(doc);

    defaultFont = QFont();

    htmlHead = QString("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\" "

            "\"http://www.w3.org/TR/REC-html40/strict.dtd\">\n"

            "<html><head><meta name=\"qrichtext\" content=\"1\" /><style type=\"text/css\">\n"

            "p, li { white-space: pre-wrap; }\n"

            "</style></head>"

            "<body style=\" font-family:'%1'; font-size:%2pt; font-weight:%3; font-style:%4;\">\n");

    htmlHead = htmlHead.arg(defaultFont.family()).arg(defaultFont.pointSizeF()).arg(defaultFont.weight() * 8).arg((defaultFont.italic() ? "italic" : "normal"));

    htmlTail = QString("</body></html>");

}

void tst_QTextDocument::cleanup()

{

    cursor = QTextCursor();

    delete doc;

    doc = 0;

}

void tst_QTextDocument::isEmpty()

{

    QVERIFY(doc->isEmpty());

}

void tst_QTextDocument::find_data()

{

    QTest::addColumn<QString>("haystack");

    QTest::addColumn<QString>("needle");

    QTest::addColumn<int>("flags");

    QTest::addColumn<int>("from");

    QTest::addColumn<int>("anchor");

    QTest::addColumn<int>("position");

    QTest::newRow("1") << "Hello World" << "World" << int(QTextDocument::FindCaseSensitively) << 0 << 6 << 11;

    QTest::newRow("2") << QString::fromAscii("Hello") + QString(QChar::ParagraphSeparator) + QString::fromAscii("World")

                    << "World" << int(QTextDocument::FindCaseSensitively) << 1 << 6 << 11;

    QTest::newRow("3") << QString::fromAscii("Hello") + QString(QChar::ParagraphSeparator) + QString::fromAscii("World")

                    << "Hello" << int(QTextDocument::FindCaseSensitively | QTextDocument::FindBackward) << 10 << 0 << 5;

    QTest::newRow("4wholewords") << QString::fromAscii("Hello Blah World")

                              << "Blah" << int(QTextDocument::FindWholeWords) << 0 << 6 << 10;

    QTest::newRow("5wholewords") << QString::fromAscii("HelloBlahWorld")

                              << "Blah" << int(QTextDocument::FindWholeWords) << 0 << -1 << -1;

    QTest::newRow("6wholewords") << QString::fromAscii("HelloBlahWorld Blah Hah")

                              << "Blah" << int(QTextDocument::FindWholeWords) << 0 << 15 << 19;

    QTest::newRow("7wholewords") << QString::fromAscii("HelloBlahWorld Blah Hah")

                              << "Blah" << int(QTextDocument::FindWholeWords | QTextDocument::FindBackward) << 23 << 15 << 19;

    QTest::newRow("8wholewords") << QString::fromAscii("Hello: World\n")

                              << "orld" << int(QTextDocument::FindWholeWords) << 0 << -1 << -1;

    QTest::newRow("across-paragraphs") << QString::fromAscii("First Parag\nSecond Parag with a lot more text")

                                       << "Parag" << int(QTextDocument::FindBackward)

                                       << 15 << 6 << 11;

    QTest::newRow("nbsp") << "Hello" + QString(QChar(QChar::Nbsp)) +"World" << " " << int(QTextDocument::FindCaseSensitively) << 0 << 5 << 6;

}

void tst_QTextDocument::find()

{

    QFETCH(QString, haystack);

    QFETCH(QString, needle);

    QFETCH(int, flags);

    QFETCH(int, from);

    QFETCH(int, anchor);

    QFETCH(int, position);

    cursor.insertText(haystack);

    cursor = doc->find(needle, from, QTextDocument::FindFlags(flags));

    if (anchor != -1) {

        QCOMPARE(cursor.anchor(), anchor);

        QCOMPARE(cursor.position(), position);

    } else {

        QVERIFY(cursor.isNull());

    }

    //search using a regular expression

    QRegExp expr(needle);

    expr.setPatternSyntax(QRegExp::FixedString);

    QTextDocument::FindFlags flg(flags);

    expr.setCaseSensitivity((flg & QTextDocument::FindCaseSensitively) ? Qt::CaseSensitive : Qt::CaseInsensitive);

    cursor = doc->find(expr, from, flg);

    if (anchor != -1) {

        QCOMPARE(cursor.anchor(), anchor);

        QCOMPARE(cursor.position(), position);

    } else {

        QVERIFY(cursor.isNull());

    }

}

void tst_QTextDocument::findWithRegExp_data()

{

    QTest::addColumn<QString>("haystack");

    QTest::addColumn<QString>("needle");

    QTest::addColumn<int>("flags");

    QTest::addColumn<int>("from");

    QTest::addColumn<int>("anchor");

    QTest::addColumn<int>("position");

    // match integers 0 to 99

    QTest::newRow("1") << "23" << "^\\d\\d?$" << int(QTextDocument::FindCaseSensitively) << 0 << 0 << 2;

    // match ampersands but not &

    QTest::newRow("2") << "His &amp; hers & theirs" << "&(?!amp;)"<< int(QTextDocument::FindCaseSensitively) << 0 << 15 << 16;

    //backward search

    QTest::newRow("3") << QString::fromAscii("HelloBlahWorld Blah Hah")

                              << "h" << int(QTextDocument::FindBackward) << 18 << 8 << 9;

}

void tst_QTextDocument::findWithRegExp()

{

    QFETCH(QString, haystack);

    QFETCH(QString, needle);

    QFETCH(int, flags);

    QFETCH(int, from);

    QFETCH(int, anchor);

    QFETCH(int, position);

    cursor.insertText(haystack);

    //search using a regular expression

    QRegExp expr(needle);

    QTextDocument::FindFlags flg(flags);

    expr.setCaseSensitivity((flg & QTextDocument::FindCaseSensitively) ? Qt::CaseSensitive : Qt::CaseInsensitive);

    cursor = doc->find(expr, from, flg);

    if (anchor != -1) {

        QCOMPARE(cursor.anchor(), anchor);

        QCOMPARE(cursor.position(), position);

    } else {

        QVERIFY(cursor.isNull());

    }

}

void tst_QTextDocument::find2()

{

    doc->setPlainText("aaa");

    cursor.movePosition(QTextCursor::Start);

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

    QTextCursor hit = doc->find("a", cursor);

    QCOMPARE(hit.position(), 2);

    QCOMPARE(hit.anchor(), 1);

}

void tst_QTextDocument::findMultiple()

{

    const QString text("foo bar baz foo bar baz");

    doc->setPlainText(text);

    cursor.movePosition(QTextCursor::Start);

    cursor = doc->find("bar", cursor);

    QCOMPARE(cursor.selectionStart(), text.indexOf("bar"));

    QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

    cursor = doc->find("bar", cursor);

    QCOMPARE(cursor.selectionStart(), text.lastIndexOf("bar"));

    QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

    cursor.movePosition(QTextCursor::End);

    cursor = doc->find("bar", cursor, QTextDocument::FindBackward);

    QCOMPARE(cursor.selectionStart(), text.lastIndexOf("bar"));

    QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

    cursor = doc->find("bar", cursor, QTextDocument::FindBackward);

    QCOMPARE(cursor.selectionStart(), text.indexOf("bar"));

    QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

    QRegExp expr("bar");

    expr.setPatternSyntax(QRegExp::FixedString);

    cursor.movePosition(QTextCursor::End);

    cursor = doc->find(expr, cursor, QTextDocument::FindBackward);

    QCOMPARE(cursor.selectionStart(), text.lastIndexOf("bar"));

    QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

    cursor = doc->find(expr, cursor, QTextDocument::FindBackward);

    QCOMPARE(cursor.selectionStart(), text.indexOf("bar"));

    QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

    cursor.movePosition(QTextCursor::Start);

    cursor = doc->find(expr, cursor);

    QCOMPARE(cursor.selectionStart(), text.indexOf("bar"));

    QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

    cursor = doc->find(expr, cursor);

    QCOMPARE(cursor.selectionStart(), text.lastIndexOf("bar"));

    QCOMPARE(cursor.selectionEnd(), cursor.selectionStart() + 3);

}

void tst_QTextDocument::basicIsModifiedChecks()

{

    QSignalSpy spy(doc, SIGNAL(modificationChanged(bool)));

    QVERIFY(!doc->isModified());

    cursor.insertText("Hello World");

    QVERIFY(doc->isModified());

    QCOMPARE(spy.count(), 1);

    QVERIFY(spy.takeFirst().at(0).toBool());

    doc->undo();

    QVERIFY(!doc->isModified());

    QCOMPARE(spy.count(), 1);

    QVERIFY(!spy.takeFirst().at(0).toBool());

    doc->redo();

    QVERIFY(doc->isModified());

    QCOMPARE(spy.count(), 1);

    QVERIFY(spy.takeFirst().at(0).toBool());

}

void tst_QTextDocument::moreIsModified()

{

    QVERIFY(!doc->isModified());

    cursor.insertText("Hello");

    QVERIFY(doc->isModified());

    doc->undo();

    QVERIFY(!doc->isModified());

    cursor.insertText("Hello");

    doc->undo();

    QVERIFY(!doc->isModified());

}

void tst_QTextDocument::isModified2()

{

    // reported on qt4-preview-feedback

    QVERIFY(!doc->isModified());

    cursor.insertText("Hello");

    QVERIFY(doc->isModified());

    doc->setModified(false);

    QVERIFY(!doc->isModified());

    cursor.insertText("Hello");

    QVERIFY(doc->isModified());

}

void tst_QTextDocument::isModified3()

{

    QVERIFY(!doc->isModified());

    doc->setUndoRedoEnabled(false);

    doc->setUndoRedoEnabled(true);

    cursor.insertText("Hello");

    QVERIFY(doc->isModified());

    doc->undo();

    QVERIFY(!doc->isModified());

}

void tst_QTextDocument::isModified4()

{

    QVERIFY(!doc->isModified());

    cursor.insertText("Hello");

    cursor.insertText("World");

    doc->setModified(false);

    QVERIFY(!doc->isModified());

    cursor.insertText("Again");

    QVERIFY(doc->isModified());

    doc->undo();

    QVERIFY(!doc->isModified());

    doc->undo();

    QVERIFY(doc->isModified());

    doc->redo();

    QVERIFY(!doc->isModified());

    doc->redo();

    QVERIFY(doc->isModified());

    doc->undo();

    QVERIFY(!doc->isModified());

    doc->undo();

    QVERIFY(doc->isModified());

    //task 197769

    cursor.insertText("Hello");

    QVERIFY(doc->isModified());

}