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

**

** Copyright (C) 2009 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$

**

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

/*

    !!!!!! Warning !!!!!

    Please don't save this file in emacs. It contains utf8 text sequences emacs will

    silently convert to a series of question marks.

 */

#include <QtTest/QtTest>

#include <private/qtextengine_p.h>

#include <qtextlayout.h>

#include <qdebug.h>

#define TESTFONT_SIZE 12

//TESTED_CLASS=

//TESTED_FILES=

class tst_QTextLayout : public QObject

{

    Q_OBJECT

public:

    tst_QTextLayout();

    virtual ~tst_QTextLayout();

public slots:

    void init();

    void cleanup();

private slots:

    void getSetCheck();

    void lineBreaking();

    void simpleBoundingRect();

    void threeLineBoundingRect();

    void boundingRectWithLongLineAndNoWrap();

    void forcedBreaks();

    void breakAny();

    void noWrap();

    void cursorToXForInlineObjects();

    void cursorToXForSetColumns();

    void defaultWordSeparators_data();

    void defaultWordSeparators();

    void cursorMovementInsideSpaces();

    void charWordStopOnLineSeparator();

    void xToCursorAtEndOfLine();

    void boundingRectTopLeft();

    void charStopForSurrogatePairs();

    void tabStops();

    void integerOverflow();

    void testDefaultTabs();

    void testTabs();

    void testMultilineTab();

    void testRightTab();

    void testTabsInAlignedParag();

    void testCenteredTab();

    void testDelimiterTab();

    void testMultiTab();

    void testTabDPIScale();

    void tabsForRtl();

    void tabHeight();

    void capitalization_allUpperCase();

    void capitalization_allLowerCase();

    void capitalization_smallCaps();

    void capitalization_capitalize();

    void longText();

    void widthOfTabs();

    void columnWrapWithTabs();

    // QTextLine stuff

    void setNumColumnsWrapAtWordBoundaryOrAnywhere();

    void setNumColumnsWordWrap();

    void smallTextLengthNoWrap();

    void smallTextLengthWordWrap();

    void smallTextLengthWrapAtWordBoundaryOrAnywhere();

    void testLineBreakingAllSpaces();

private:

    QFont testFont;

};

// Testing get/set functions

void tst_QTextLayout::getSetCheck()

{

    QString str("Bogus text");

    QTextLayout layout(str, testFont);

    layout.beginLayout();

    QTextEngine *engine = layout.engine();

    QTextInlineObject obj1(0, engine);

    // qreal QTextInlineObject::width()

    // void QTextInlineObject::setWidth(qreal)

    obj1.setWidth(0.0);

    QCOMPARE(0.0, obj1.width());

    obj1.setWidth(1.2);

    QVERIFY(1.0 < obj1.width());

    // qreal QTextInlineObject::ascent()

    // void QTextInlineObject::setAscent(qreal)

    obj1.setAscent(0.0);

    QCOMPARE(0.0, obj1.ascent());

    obj1.setAscent(1.2);

    QVERIFY(1.0 < obj1.ascent());

    // qreal QTextInlineObject::descent()

    // void QTextInlineObject::setDescent(qreal)

    obj1.setDescent(0.0);

    QCOMPARE(0.0, obj1.descent());

    obj1.setDescent(1.2);

    QVERIFY(1.0 < obj1.descent());

    QTextLayout obj2;

    // bool QTextLayout::cacheEnabled()

    // void QTextLayout::setCacheEnabled(bool)

    obj2.setCacheEnabled(false);

    QCOMPARE(false, obj2.cacheEnabled());

    obj2.setCacheEnabled(true);

    QCOMPARE(true, obj2.cacheEnabled());

}

QT_BEGIN_NAMESPACE

extern void qt_setQtEnableTestFont(bool value);

QT_END_NAMESPACE

tst_QTextLayout::tst_QTextLayout()

{

    qt_setQtEnableTestFont(true);

}

tst_QTextLayout::~tst_QTextLayout()

{

}

void tst_QTextLayout::init()

{

    testFont = QFont();

    testFont.setFamily("__Qt__Box__Engine__");

    testFont.setPixelSize(TESTFONT_SIZE);

    testFont.setWeight(QFont::Normal);

    QCOMPARE(QFontMetrics(testFont).width('a'), testFont.pixelSize());

}

void tst_QTextLayout::cleanup()

{

    testFont = QFont();

}

void tst_QTextLayout::lineBreaking()

{

#if defined(Q_WS_X11)

    struct Breaks {

	const char *utf8;

	uchar breaks[32];

    };

    Breaks brks[] = {

	{ "11", { false, 0xff } },

	{ "aa", { false, 0xff } },

	{ "++", { false, 0xff } },

	{ "--", { false, 0xff } },

	{ "((", { false, 0xff } },

	{ "))", { false, 0xff } },

	{ "..", { false, 0xff } },

	{ "\"\"", { false, 0xff } },

	{ "$$", { false, 0xff } },

	{ "!!", { false, 0xff } },

	{ "??", { false, 0xff } },

	{ ",,", { false, 0xff } },

	{ ")()", { true, false, 0xff } },

	{ "?!?", { false, false, 0xff } },

	{ ".,.", { false, false, 0xff } },

	{ "+-+", { false, false, 0xff } },

	{ "+=+", { false, false, 0xff } },

	{ "+(+", { false, false, 0xff } },

	{ "+)+", { false, false, 0xff } },

	{ "a b", { false, true, 0xff } },

	{ "a(b", { false, false, 0xff } },

	{ "a)b", { false, false, 0xff } },

	{ "a-b", { false, true, 0xff } },

	{ "a.b", { false, false, 0xff } },

	{ "a+b", { false, false, 0xff } },

	{ "a?b", { false, false, 0xff } },

	{ "a!b", { false, false, 0xff } },

	{ "a$b", { false, false, 0xff } },

	{ "a,b", { false, false, 0xff } },

	{ "a/b", { false, false, 0xff } },

	{ "1/2", { false, false, 0xff } },

	{ "./.", { false, false, 0xff } },

	{ ",/,", { false, false, 0xff } },

	{ "!/!", { false, false, 0xff } },

	{ "\\/\\", { false, false, 0xff } },

	{ "1 2", { false, true, 0xff } },

	{ "1(2", { false, false, 0xff } },

	{ "1)2", { false, false, 0xff } },

	{ "1-2", { false, false, 0xff } },

	{ "1.2", { false, false, 0xff } },

	{ "1+2", { false, false, 0xff } },

	{ "1?2", { false, true, 0xff } },

	{ "1!2", { false, true, 0xff } },

	{ "1$2", { false, false, 0xff } },

	{ "1,2", { false, false, 0xff } },

	{ "1/2", { false, false, 0xff } },

	{ "\330\260\331\216\331\204\331\220\331\203\331\216", { false, false, false, false, false, 0xff } },

	{ "\330\247\331\204\331\205 \330\247\331\204\331\205", { false, false, false, true, false, false, 0xff } },

	{ "1#2", { false, false, 0xff } },

	{ "!#!", { false, false, 0xff } },

	{ 0, {} }

    };

    Breaks *b = brks;

    while (b->utf8) {

        QString str = QString::fromUtf8(b->utf8);

        QTextEngine engine(str, QFont());

        const HB_CharAttributes *attrs = engine.attributes();

        int i;

        for (i = 0; i < (int)str.length() - 1; ++i) {

            QVERIFY(b->breaks[i] != 0xff);

            if ( (attrs[i].lineBreakType != HB_NoBreak) != (bool)b->breaks[i] ) {

                qDebug("test case \"%s\" failed at char %d; break type: %d", b->utf8, i, attrs[i].lineBreakType);

                QCOMPARE( (attrs[i].lineBreakType != HB_NoBreak), (bool)b->breaks[i] );

            }

        }

        QVERIFY(attrs[i].lineBreakType == HB_ForcedBreak);

        QCOMPARE(b->breaks[i], (uchar)0xff);

        ++b;

    }

#else

    QSKIP("This test can not be run on non-X11 platforms", SkipAll);

#endif

}

void tst_QTextLayout::simpleBoundingRect()

{

    /* just check if boundingRect() gives sane values. The text is not broken. */

    QString hello("hello world");

    const int width = hello.length() * testFont.pixelSize();

    QTextLayout layout(hello, testFont);

    layout.beginLayout();

    QTextLine line = layout.createLine();

    line.setLineWidth(width);

    QCOMPARE(line.textLength(), hello.length());

    QCOMPARE(layout.boundingRect(), QRectF(0, 0, width, QFontMetrics(testFont).height()));

}

void tst_QTextLayout::threeLineBoundingRect()

{

#if defined(Q_WS_MAC)

    QSKIP("QTestFontEngine on the mac does not support logclusters at the moment", SkipAll);

#endif

    /* stricter check. break text into three lines */

    QString firstWord("hello");

    QString secondWord("world");

    QString thirdWord("test");

    QString text(firstWord + ' ' + secondWord + ' ' + thirdWord);

    const int firstLineWidth = firstWord.length() * testFont.pixelSize();

    const int secondLineWidth = secondWord.length() * testFont.pixelSize();

    const int thirdLineWidth = thirdWord.length() * testFont.pixelSize();

    const int longestLine = qMax(firstLineWidth, qMax(secondLineWidth, thirdLineWidth));

    QTextLayout layout(text, testFont);

    layout.beginLayout();

    int pos = 0;

    int y = 0;

    QTextLine line = layout.createLine();

    line.setLineWidth(firstLineWidth);

    line.setPosition(QPoint(0, y));

    QCOMPARE(line.textStart(), pos);

    // + 1 for trailing space

    QCOMPARE(line.textLength(), firstWord.length() + 1);

    QCOMPARE(qRound(line.naturalTextWidth()), firstLineWidth);

    pos += line.textLength();

    y += qRound(line.ascent() + line.descent());

    line = layout.createLine();

    line.setLineWidth(secondLineWidth);

    line.setPosition(QPoint(0, y));

    // + 1 for trailing space

    QCOMPARE(line.textStart(), pos);

    QCOMPARE(line.textLength(), secondWord.length() + 1);

    QCOMPARE(qRound(line.naturalTextWidth()), secondLineWidth);

    pos += line.textLength();

    y += qRound(line.ascent() + line.descent());

    line = layout.createLine();

    line.setLineWidth(secondLineWidth);

    line.setPosition(QPoint(0, y));

    // no trailing space here!

    QCOMPARE(line.textStart(), pos);

    QCOMPARE(line.textLength(), thirdWord.length());

    QCOMPARE(qRound(line.naturalTextWidth()), thirdLineWidth);

    y += qRound(line.ascent() + line.descent());

    QCOMPARE(layout.boundingRect(), QRectF(0, 0, longestLine, y + 1));

}

void tst_QTextLayout::boundingRectWithLongLineAndNoWrap()

{

    QString longString("thisisaverylongstringthatcannotbewrappedatallitjustgoesonandonlikeonebigword");

    const int width = longString.length() * testFont.pixelSize() / 20; // very small widthx

    QTextLayout layout(longString, testFont);

    layout.beginLayout();

    QTextLine line = layout.createLine();

    line.setLineWidth(width);

    QVERIFY(layout.boundingRect().width() >= line.width());

    QCOMPARE(layout.boundingRect().width(), line.naturalTextWidth());

}

void tst_QTextLayout::forcedBreaks()

{

    QString text = "A\n\nB\nC";

    text.replace('\n', QChar::LineSeparator);

    QTextLayout layout(text, testFont);

    layout.beginLayout();

    int pos = 0;

    QTextLine line = layout.createLine();

    line.setLineWidth(0x10000);

    QCOMPARE(line.textStart(), pos);

    QCOMPARE(line.textLength(),2);

    QCOMPARE(qRound(line.naturalTextWidth()),testFont.pixelSize());

    QCOMPARE((int) line.height(), testFont.pixelSize() + 1); // + 1 baseline

    QCOMPARE(line.xToCursor(0), line.textStart());

    pos += line.textLength();

    line = layout.createLine();

    line.setLineWidth(0x10000);

    QCOMPARE(line.textStart(),pos);

    QCOMPARE(line.textLength(),1);

    QCOMPARE(qRound(line.naturalTextWidth()), 0);

    QCOMPARE((int) line.height(), testFont.pixelSize() + 1); // + 1 baseline

    QCOMPARE(line.xToCursor(0), line.textStart());

    pos += line.textLength();

    line = layout.createLine();

    line.setLineWidth(0x10000);

    QCOMPARE(line.textStart(),pos);

    QCOMPARE(line.textLength(),2);

    QCOMPARE(qRound(line.naturalTextWidth()),testFont.pixelSize());

    QCOMPARE(qRound(line.height()), testFont.pixelSize() + 1); // + 1 baseline

    QCOMPARE(line.xToCursor(0), line.textStart());

    pos += line.textLength();

    line = layout.createLine();

    line.setLineWidth(0x10000);

    QCOMPARE(line.textStart(),pos);

    QCOMPARE(line.textLength(),1);

    QCOMPARE(qRound(line.naturalTextWidth()), testFont.pixelSize());

    QCOMPARE((int) line.height(), testFont.pixelSize() + 1); // + 1 baseline

    QCOMPARE(line.xToCursor(0), line.textStart());

}

void tst_QTextLayout::breakAny()

{

#if defined(Q_WS_MAC)

    QSKIP("QTestFontEngine on the mac does not support logclusters at the moment", SkipAll);

#endif

    QString text = "ABCD";

    QTextLayout layout(text, testFont);

    QTextLine line;

    QTextOption opt;

    opt.setWrapMode(QTextOption::WrapAnywhere);

    layout.setTextOption(opt);

    layout.beginLayout();

    line = layout.createLine();

    line.setLineWidth(testFont.pixelSize() * 2);

    QCOMPARE(line.textStart(), 0);

    QCOMPARE(line.textLength(), 2);

    line = layout.createLine();

    line.setLineWidth(testFont.pixelSize() * 2);

    QCOMPARE(line.textStart(), 2);

    QCOMPARE(line.textLength(), 2);

    line = layout.createLine();

    QVERIFY(!line.isValid());

    layout.endLayout();

    text = "ABCD EFGH";

    layout.setText(text);

    layout.beginLayout();

    line = layout.createLine();

    line.setLineWidth(testFont.pixelSize() * 7);

    QCOMPARE(line.textStart(), 0);

    QCOMPARE(line.textLength(), 7);

    layout.endLayout();

}

void tst_QTextLayout::noWrap()

{

#if defined(Q_WS_MAC)

    QSKIP("QTestFontEngine on the mac does not support logclusters at the moment", SkipAll);

#endif

    QString text = "AB CD";

    QTextLayout layout(text, testFont);

    QTextLine line;

    QTextOption opt;

    opt.setWrapMode(QTextOption::NoWrap);

    layout.setTextOption(opt);

    layout.beginLayout();

    line = layout.createLine();

    line.setLineWidth(testFont.pixelSize() * 2);

    QCOMPARE(line.textStart(), 0);

    QCOMPARE(line.textLength(), 5);

    line = layout.createLine();

    QVERIFY(!line.isValid());

    layout.endLayout();

}

void tst_QTextLayout::cursorToXForInlineObjects()

{

    QChar ch(QChar::ObjectReplacementCharacter);

    QString text(ch);

    QTextLayout layout(text, testFont);

    layout.beginLayout();

    QTextEngine *engine = layout.engine();

    const int item = engine->findItem(0);

    engine->layoutData->items[item].width = 32;

    QTextLine line = layout.createLine();

    line.setLineWidth(0x10000);

    QCOMPARE(line.cursorToX(0), qreal(0));

    QCOMPARE(line.cursorToX(1), qreal(32));

}

void tst_QTextLayout::cursorToXForSetColumns()

{

    QTextLayout lay("abc", testFont);

    QTextOption o = lay.textOption();

    o.setWrapMode(QTextOption::WrapAnywhere);

    // enable/disable this line for full effect ;)

    o.setAlignment(Qt::AlignHCenter);

    lay.setTextOption(o);

    lay.beginLayout();

    QTextLine line = lay.createLine();

    line.setNumColumns(1);

    lay.endLayout();

    QCOMPARE(line.cursorToX(0), 0.);

    QCOMPARE(line.cursorToX(1), (qreal) TESTFONT_SIZE);

}

void tst_QTextLayout::defaultWordSeparators_data()

{

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

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

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

    QString separators(".,:;-<>[](){}=/+%&^*");

    separators += QLatin1String("!?");

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

        QTest::newRow(QString::number(i).toAscii().data())

            << QString::fromLatin1("abcd") + separators.at(i) + QString::fromLatin1("efgh")