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

**

** 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$

**

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

#ifdef Q_WS_X11

#define private public

#endif

// cannot do private -> public on windows since it seems to mess up some stl headers

#include <qfont.h>

#ifdef Q_WS_X11

#undef private

#endif

#include <QtTest/QtTest>

#if defined(Q_WS_X11)

#define private public

#include <private/qtextengine_p.h>

#include <qtextlayout.h>

#undef private

#endif

#include <qfontdatabase.h>

#include <qfontinfo.h>

//TESTED_CLASS=

//TESTED_FILES= gui/text/qscriptengine.cpp

// This test depends on the fonts in the following package being installed:

// http://people.freedesktop.org/~hausmann/harfbuzz-test-fonts-0.1.tar.bz2

class tst_QTextScriptEngine : public QObject

{

Q_OBJECT

public:

    tst_QTextScriptEngine();

    virtual ~tst_QTextScriptEngine();

public slots:

    void init();

    void cleanup();

private slots:

    void devanagari();

    void bengali();

    void gurmukhi();

    // gujarati missing

    void oriya();

    void tamil();

    void telugu();

    void kannada();

    void malayalam();

    void sinhala();

    void khmer();

    void linearB();

};

tst_QTextScriptEngine::tst_QTextScriptEngine()

{

}

tst_QTextScriptEngine::~tst_QTextScriptEngine()

{

}

void tst_QTextScriptEngine::init()

{

}

void tst_QTextScriptEngine::cleanup()

{

}

struct ShapeTable {

    unsigned short unicode[16];

    unsigned short glyphs[16];

};

#if defined(Q_WS_X11)

static bool shaping( const QFont &f, const ShapeTable *s)

{

    QString str = QString::fromUtf16( s->unicode );

    QTextLayout layout(str, f);

    QTextEngine *e = layout.d;

    e->itemize();

    e->shape(0);

    int nglyphs = 0;

    const unsigned short *g = s->glyphs;

    while ( *g ) {

	nglyphs++;

	g++;

    }

    if( nglyphs != e->layoutData->items[0].num_glyphs )

	goto error;

    for (int i = 0; i < nglyphs; ++i) {

	if ((e->layoutData->glyphLayout.glyphs[i] & 0xffffff) != s->glyphs[i])

	    goto error;

    }

    return true;

 error:

    str = "";

    const unsigned short *uc = s->unicode;

    while (*uc) {

	str += QString("%1 ").arg(*uc, 4, 16);

	++uc;

    }

    qDebug("%s: shaping of string %s failed, nglyphs=%d, expected %d",

           f.family().toLatin1().constData(),

           str.toLatin1().constData(),

           e->layoutData->items[0].num_glyphs, nglyphs);

    str = "";

    int i = 0;

    while (i < e->layoutData->items[0].num_glyphs) {

	str += QString("%1 ").arg(e->layoutData->glyphLayout.glyphs[i], 4, 16);

	++i;

    }

    qDebug("    glyph result = %s", str.toLatin1().constData());

    return false;

}

#endif

void tst_QTextScriptEngine::devanagari()

{

#if defined(Q_WS_X11)

    {

        if (QFontDatabase().families(QFontDatabase::Devanagari).contains("Raghindi")) {

            QFont f("Raghindi");

	    const ShapeTable shape_table [] = {

		// Ka

		{ { 0x0915, 0x0 },

		  { 0x0080, 0x0 } },

		// Ka Halant

		{ { 0x0915, 0x094d, 0x0 },

		  { 0x0080, 0x0051, 0x0 } },

		// Ka Halant Ka

		{ { 0x0915, 0x094d, 0x0915, 0x0 },

		  { 0x00c8, 0x0080, 0x0 } },

		// Ka MatraI

		{ { 0x0915, 0x093f, 0x0 },

		  { 0x01d1, 0x0080, 0x0 } },

		// Ra Halant Ka

		{ { 0x0930, 0x094d, 0x0915, 0x0 },

		  { 0x0080, 0x005b, 0x0 } },

		// Ra Halant Ka MatraI

		{ { 0x0930, 0x094d, 0x0915, 0x093f, 0x0 },

		  { 0x01d1, 0x0080, 0x005b, 0x0 } },

		// MatraI

		{ { 0x093f, 0x0 },

		  { 0x01d4, 0x029c, 0x0 } },

		// Ka Nukta

		{ { 0x0915, 0x093c, 0x0 },

		  { 0x00a4, 0x0 } },

		// Ka Halant Ra

		{ { 0x0915, 0x094d, 0x0930, 0x0 },

		  { 0x0110, 0x0 } },

		// Ka Halant Ra Halant Ka

		{ { 0x0915, 0x094d, 0x0930, 0x094d, 0x0915, 0x0 },

		  { 0x0158, 0x0080, 0x0 } },

		{ { 0x0930, 0x094d, 0x200d, 0x0 },

		  { 0x00e2, 0x0 } },

		{ { 0x0915, 0x094d, 0x0930, 0x094d, 0x200d, 0x0 },

		  { 0x0158, 0x0 } },

		{ {0}, {0} }

	    };

	    const ShapeTable *s = shape_table;

	    while (s->unicode[0]) {

		QVERIFY( shaping(f, s) );

		++s;

	    }

	} else {

	    QSKIP("couln't find Raghindi", SkipAll);

	}

    }

    {

        if (QFontDatabase().families(QFontDatabase::Devanagari).contains("Mangal")) {

            QFont f("Mangal");

	    const ShapeTable shape_table [] = {

		// Ka

		{ { 0x0915, 0x0 },

		  { 0x0080, 0x0 } },

		// Ka Halant

		{ { 0x0915, 0x094d, 0x0 },

		  { 0x0080, 0x0051, 0x0 } },

		// Ka Halant Ka

		{ { 0x0915, 0x094d, 0x0915, 0x0 },

		  { 0x00c8, 0x0080, 0x0 } },

		// Ka MatraI

		{ { 0x0915, 0x093f, 0x0 },

		  { 0x01d1, 0x0080, 0x0 } },

		// Ra Halant Ka

		{ { 0x0930, 0x094d, 0x0915, 0x0 },

		  { 0x0080, 0x005b, 0x0 } },

		// Ra Halant Ka MatraI

		{ { 0x0930, 0x094d, 0x0915, 0x093f, 0x0 },

		  { 0x01d1, 0x0080, 0x005b, 0x0 } },

		// MatraI

		{ { 0x093f, 0x0 },

		  { 0x01d4, 0x029c, 0x0 } },

		// Ka Nukta

		{ { 0x0915, 0x093c, 0x0 },

		  { 0x00a4, 0x0 } },

		// Ka Halant Ra

		{ { 0x0915, 0x094d, 0x0930, 0x0 },

		  { 0x0110, 0x0 } },

		// Ka Halant Ra Halant Ka

		{ { 0x0915, 0x094d, 0x0930, 0x094d, 0x0915, 0x0 },

		  { 0x0158, 0x0080, 0x0 } },

                { { 0x92b, 0x94d, 0x930, 0x0 },

                  { 0x125, 0x0 } },

                { { 0x92b, 0x93c, 0x94d, 0x930, 0x0 },

                  { 0x149, 0x0 } }, 

		{ {0}, {0} }

	    };

	    const ShapeTable *s = shape_table;

	    while (s->unicode[0]) {

		QVERIFY( shaping(f, s) );

		++s;

	    }

	} else {

	    QSKIP("couldn't find mangal", SkipAll);

	}

    }

#else

    QSKIP("X11 specific test", SkipAll);

#endif

}

void tst_QTextScriptEngine::bengali()

{

#if defined(Q_WS_X11)

    {

        if (QFontDatabase().families(QFontDatabase::Bengali).contains("Akaash")) {

            QFont f("Akaash");

	    const ShapeTable shape_table [] = {

		// Ka

		{ { 0x0995, 0x0 },

		  { 0x0151, 0x0 } },

		// Ka Halant

		{ { 0x0995, 0x09cd, 0x0 },

		  { 0x0151, 0x017d, 0x0 } },

		// Ka Halant Ka

		{ { 0x0995, 0x09cd, 0x0995, 0x0 },

		  { 0x019b, 0x0 } },

		// Ka MatraI

		{ { 0x0995, 0x09bf, 0x0 },

		  { 0x0173, 0x0151, 0x0 } },

		// Ra Halant Ka

		{ { 0x09b0, 0x09cd, 0x0995, 0x0 },

		  { 0x0151, 0x0276, 0x0 } },

		// Ra Halant Ka MatraI

		{ { 0x09b0, 0x09cd, 0x0995, 0x09bf, 0x0 },

		  { 0x0173, 0x0151, 0x0276, 0x0 } },

		// Ka Nukta

		{ { 0x0995, 0x09bc, 0x0 },

		  { 0x0151, 0x0171, 0x0 } },

		// Ka Halant Ra

		{ { 0x0995, 0x09cd, 0x09b0, 0x0 },

		  { 0x01f4, 0x0 } },

		// Ka Halant Ra Halant Ka

		{ { 0x0995, 0x09cd, 0x09b0, 0x09cd, 0x0995, 0x0 },

		  { 0x025c, 0x0276, 0x0151, 0x0 } },

		// Ya + Halant

		{ { 0x09af, 0x09cd, 0x0 },

		  { 0x016a, 0x017d, 0x0 } },

		// Da Halant Ya -> Da Ya-Phala

		{ { 0x09a6, 0x09cd, 0x09af, 0x0 },

		  { 0x01e5, 0x0 } },

		// A Halant Ya -> A Ya-phala

		{ { 0x0985, 0x09cd, 0x09af, 0x0 },

		  { 0x0145, 0x01cf, 0x0 } },

		// Na Halant Ka

		{ { 0x09a8, 0x09cd, 0x0995, 0x0 },

		  { 0x026f, 0x0151, 0x0 } },

		// Na Halant ZWNJ Ka

		{ { 0x09a8, 0x09cd, 0x200c, 0x0995, 0x0 },

		  { 0x0164, 0x017d, 0x0151, 0x0 } },

		// Na Halant ZWJ Ka

		{ { 0x09a8, 0x09cd, 0x200d, 0x0995, 0x0 },

		  { 0x026f, 0x0151, 0x0 } },

		// Ka Halant ZWNJ Ka

		{ { 0x0995, 0x09cd, 0x200c, 0x0995, 0x0 },

		  { 0x0151, 0x017d, 0x0151, 0x0 } },

		// Ka Halant ZWJ Ka

		{ { 0x0995, 0x09cd, 0x200d, 0x0995, 0x0 },

		  { 0x025c, 0x0151, 0x0 } },

		// Na Halant Ra

		{ { 0x09a8, 0x09cd, 0x09b0, 0x0 },

		  { 0x0207, 0x0 } },

		// Na Halant ZWNJ Ra

		{ { 0x09a8, 0x09cd, 0x200c, 0x09b0, 0x0 },

		  { 0x0164, 0x017d, 0x016b, 0x0 } },

		// Na Halant ZWJ Ra

		{ { 0x09a8, 0x09cd, 0x200d, 0x09b0, 0x0 },

		  { 0x026f, 0x016b, 0x0 } },

		// Na Halant Ba

		{ { 0x09a8, 0x09cd, 0x09ac, 0x0 },

		  { 0x022f, 0x0 } },

		// Na Halant ZWNJ Ba

		{ { 0x09a8, 0x09cd, 0x200c, 0x09ac, 0x0 },

		  { 0x0164, 0x017d, 0x0167, 0x0 } },

		// Na Halant ZWJ Ba

		{ { 0x09a8, 0x09cd, 0x200d, 0x09ac, 0x0 },

		  { 0x026f, 0x0167, 0x0 } },

		// Na Halant Dha

		{ { 0x09a8, 0x09cd, 0x09a7, 0x0 },

		  { 0x01d3, 0x0 } },

		// Na Halant ZWNJ Dha

		{ { 0x09a8, 0x09cd, 0x200c, 0x09a7, 0x0 },

		  { 0x0164, 0x017d, 0x0163, 0x0 } },

		// Na Halant ZWJ Dha

		{ { 0x09a8, 0x09cd, 0x200d, 0x09a7, 0x0 },

		  { 0x026f, 0x0163, 0x0 } },

		// Ra Halant Ka MatraAU

		{ { 0x09b0, 0x09cd, 0x0995, 0x09cc, 0x0 },

		  { 0x0179, 0x0151, 0x0276, 0x017e, 0x0 } },

		// Ra Halant Ba Halant Ba

		{ { 0x09b0, 0x09cd, 0x09ac, 0x09cd, 0x09ac, 0x0 },

		  { 0x0232, 0x0276, 0x0 } },

                { { 0x9b0, 0x9cd, 0x995, 0x9be, 0x982, 0x0 },

                  { 0x151, 0x276, 0x172, 0x143, 0x0 } },

                { { 0x9b0, 0x9cd, 0x995, 0x9be, 0x983, 0x0 },

                  { 0x151, 0x276, 0x172, 0x144, 0x0 } }, 

                // test decomposed two parts matras

                { { 0x995, 0x9c7, 0x9be, 0x0 },

                  { 0x179, 0x151, 0x172, 0x0 } },

                { { 0x995, 0x9c7, 0x9d7, 0x0 },

                  { 0x179, 0x151, 0x17e, 0x0 } },

		{ {0}, {0} }

	    };

	    const ShapeTable *s = shape_table;

	    while (s->unicode[0]) {

		QVERIFY( shaping(f, s) );

		++s;

	    }

	} else {

	    QSKIP("couln't find Akaash", SkipAll);

	}

    }

    {

        if (QFontDatabase().families(QFontDatabase::Bengali).contains("Mukti Narrow")) {

            QFont f("Mukti Narrow");

	    const ShapeTable shape_table [] = {

		// Ka

		{ { 0x0995, 0x0 },

		  { 0x0073, 0x0 } },

		// Ka Halant

		{ { 0x0995, 0x09cd, 0x0 },

		  { 0x00b9, 0x0 } },

		// Ka Halant Ka

		{ { 0x0995, 0x09cd, 0x0995, 0x0 },

		  { 0x0109, 0x0 } },

		// Ka MatraI

		{ { 0x0995, 0x09bf, 0x0 },

		  { 0x0095, 0x0073, 0x0 } },

		// Ra Halant Ka

		{ { 0x09b0, 0x09cd, 0x0995, 0x0 },

		  { 0x0073, 0x00e1, 0x0 } },

		// Ra Halant Ka MatraI

		{ { 0x09b0, 0x09cd, 0x0995, 0x09bf, 0x0 },

		  { 0x0095, 0x0073, 0x00e1, 0x0 } },

		// MatraI

 		{ { 0x09bf, 0x0 },

		  { 0x0095, 0x01c8, 0x0 } },

		// Ka Nukta

		{ { 0x0995, 0x09bc, 0x0 },

		  { 0x0073, 0x0093, 0x0 } },

		// Ka Halant Ra

		{ { 0x0995, 0x09cd, 0x09b0, 0x0 },

		  { 0x00e5, 0x0 } },

		// Ka Halant Ra Halant Ka

                { { 0x995, 0x9cd, 0x9b0, 0x9cd, 0x995, 0x0 },

                  { 0x234, 0x24e, 0x73, 0x0 } }, 

		// Ya + Halant

		{ { 0x09af, 0x09cd, 0x0 },

		  { 0x00d2, 0x0 } },

		// Da Halant Ya -> Da Ya-Phala

		{ { 0x09a6, 0x09cd, 0x09af, 0x0 },

		  { 0x0084, 0x00e2, 0x0 } },

		// A Halant Ya -> A Ya-phala

		{ { 0x0985, 0x09cd, 0x09af, 0x0 },

		  { 0x0067, 0x00e2, 0x0 } },

		// Na Halant Ka

		{ { 0x09a8, 0x09cd, 0x0995, 0x0 },

		  { 0x0188, 0x0 } },

		// Na Halant ZWNJ Ka

                { { 0x9a8, 0x9cd, 0x200c, 0x995, 0x0 },

                  { 0xcc, 0x73, 0x0 } }, 

		// Na Halant ZWJ Ka

                { { 0x9a8, 0x9cd, 0x200d, 0x995, 0x0 },

                  { 0x247, 0x73, 0x0 } }, 

		// Ka Halant ZWNJ Ka

                { { 0x9a8, 0x9cd, 0x200d, 0x995, 0x0 },

                  { 0x247, 0x73, 0x0 } }, 

		// Ka Halant ZWJ Ka

                { { 0x9a8, 0x9cd, 0x200d, 0x995, 0x0 },

                  { 0x247, 0x73, 0x0 } }, 

		// Na Halant Ra

		{ { 0x09a8, 0x09cd, 0x09b0, 0x0 },

		  { 0x00f8, 0x0 } },

		// Na Halant ZWNJ Ra

		{ { 0x09a8, 0x09cd, 0x200c, 0x09b0, 0x0 },

		  { 0xcc, 0x8d, 0x0 } },

		// Na Halant ZWJ Ra

                { { 0x9a8, 0x9cd, 0x200d, 0x9b0, 0x0 },

                  { 0x247, 0x8d, 0x0 } }, 

		// Na Halant Ba

		{ { 0x09a8, 0x09cd, 0x09ac, 0x0 },

		  { 0x0139, 0x0 } },

		// Na Halant ZWNJ Ba

                { { 0x9a8, 0x9cd, 0x200c, 0x9ac, 0x0 },

                  { 0xcc, 0x89, 0x0 } }, 

		// Na Halant ZWJ Ba

                { { 0x9a8, 0x9cd, 0x200d, 0x9ac, 0x0 },

                  { 0x247, 0x89, 0x0 } }, 

		// Na Halant Dha

		{ { 0x09a8, 0x09cd, 0x09a7, 0x0 },

		  { 0x0145, 0x0 } },

		// Na Halant ZWNJ Dha

		{ { 0x09a8, 0x09cd, 0x200c, 0x09a7, 0x0 },

		  { 0xcc, 0x85, 0x0 } },

		// Na Halant ZWJ Dha

		{ { 0x09a8, 0x09cd, 0x200d, 0x09a7, 0x0 },

		  { 0x247, 0x85, 0x0 } },

		// Ra Halant Ka MatraAU

                { { 0x9b0, 0x9cd, 0x995, 0x9cc, 0x0 },

                  { 0x232, 0x73, 0xe1, 0xa0, 0x0 } }, 

		// Ra Halant Ba Halant Ba

		{ { 0x09b0, 0x09cd, 0x09ac, 0x09cd, 0x09ac, 0x0 },

		  { 0x013b, 0x00e1, 0x0 } },

		{ {0}, {0} }

	    };

	    const ShapeTable *s = shape_table;

	    while (s->unicode[0]) {

		QVERIFY( shaping(f, s) );

		++s;

	    }

	} else {

	    QSKIP("couln't find Mukti", SkipAll);

	}

    }

    {

        if (QFontDatabase().families(QFontDatabase::Bengali).contains("Likhan")) {

            QFont f("Likhan");

	    const ShapeTable shape_table [] = {

                { { 0x9a8, 0x9cd, 0x9af, 0x0 },

                  { 0x1ca, 0x0 } },

		{ { 0x09b8, 0x09cd, 0x09af, 0x0 },

                  { 0x020e, 0x0 } },

		{ { 0x09b6, 0x09cd, 0x09af, 0x0 },

                  { 0x01f4, 0x0 } },

		{ { 0x09b7, 0x09cd, 0x09af, 0x0 },

                  { 0x01fe, 0x0 } },

		{ { 0x09b0, 0x09cd, 0x09a8, 0x09cd, 0x200d, 0x0 },

                  { 0x10b, 0x167, 0x0 } },

		{ {0}, {0} }

	    };

	    const ShapeTable *s = shape_table;

	    while (s->unicode[0]) {

		QVERIFY( shaping(f, s) );