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

**

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

#include <qimagereader.h>

#include <qlist.h>

#include <qmatrix.h>

#include <stdio.h>

#include <qpainter.h>

#include <private/qdrawhelper_p.h>

//TESTED_CLASS=

//TESTED_FILES=

#if defined(Q_OS_SYMBIAN)

# define SRCDIR ""

#endif

Q_DECLARE_METATYPE(QImage::Format)

class tst_QImage : public QObject

{

    Q_OBJECT

public:

    tst_QImage();

private slots:

    void create();

    void createInvalidXPM();

    void createFromUChar();

    void convertBitOrder();

    void formatHandlersInput_data();

    void formatHandlersInput();

    void setAlphaChannel_data();

    void setAlphaChannel();

    void alphaChannel();

    void convertToFormat_data();

    void convertToFormat();

    void createAlphaMask_data();

    void createAlphaMask();

#ifndef QT_NO_IMAGE_HEURISTIC_MASK

    void createHeuristicMask();

#endif

    void dotsPerMeterZero();

    void convertToFormatPreserveDotsPrMeter();

#ifndef QT_NO_IMAGE_TEXT

    void convertToFormatPreserveText();

#endif

    void rotate_data();

    void rotate();

    void copy();

    void setPixel_data();

    void setPixel();

    void setColorCount();

    void setColor();

    void rasterClipping();

    void pointOverloads();

    void destructor();

    void cacheKey();

    void smoothScale();

    void smoothScale2();

    void smoothScale3();

    void smoothScaleBig();

    void smoothScaleAlpha();

    void transformed_data();

    void transformed();

    void transformed2();

    void scaled();

    void paintEngine();

    void setAlphaChannelWhilePainting();

    void smoothScaledSubImage();

    void nullSize_data();

    void nullSize();

    void premultipliedAlphaConsistency();

    void compareIndexed();

};

tst_QImage::tst_QImage()

{

}

// Test if QImage (or any functions called from QImage) throws an

// exception when creating an extremely large image.

// QImage::create() should return "false" in this case.

void tst_QImage::create()

{

    bool cr = true;

#if !defined(Q_WS_QWS) && !defined(Q_OS_WINCE)

    try {

#endif

	//QImage image(7000000, 7000000, 8, 256, QImage::IgnoreEndian);

    QImage image(7000000, 7000000, QImage::Format_Indexed8);

    image.setColorCount(256);

        cr = !image.isNull();

#if !defined(Q_WS_QWS) && !defined(Q_OS_WINCE)

    } catch (...) {

    }

#endif

    QVERIFY( !cr );

}

void tst_QImage::createInvalidXPM()

{

    QTest::ignoreMessage(QtWarningMsg, "QImage::QImage(), XPM is not supported");

    const char *xpm[] = {""};

    QImage invalidXPM(xpm);

    QVERIFY(invalidXPM.isNull());

}

void tst_QImage::createFromUChar()

{

    uchar data[] = {

#if Q_BYTE_ORDER == Q_BIG_ENDIAN

        0xFF,

#endif

        1,1,1, 0xFF, 2,2,2, 0xFF, 3,3,3, 0xFF, 4,4,4,

#if Q_BYTE_ORDER != Q_BIG_ENDIAN

        0xFF,

#endif

    };

    // When the data is const, nothing you do to the image will change the source data.

    QImage i1((const uchar*)data, 2, 2, 8, QImage::Format_RGB32);

    QCOMPARE(i1.pixel(0,0), 0xFF010101U);

    QCOMPARE(i1.pixel(1,0), 0xFF020202U);

    QCOMPARE(i1.pixel(0,1), 0xFF030303U);

    QCOMPARE(i1.pixel(1,1), 0xFF040404U);

    {

        QImage i(i1);

        i.setPixel(0,0,5);

    }

    QCOMPARE(i1.pixel(0,0), 0xFF010101U);

    QCOMPARE(*(QRgb*)data, 0xFF010101U);

    *((QRgb*)i1.bits()) = 7U;

    QCOMPARE(i1.pixel(0,0), 7U);

    QCOMPARE(*(QRgb*)data, 0xFF010101U);

    // Changing copies should not change the original image or data.

    {

        QImage i(i1);

        i.setPixel(0,0,5);

        QCOMPARE(*(QRgb*)data, 0xFF010101U);

        i1.setPixel(0,0,9);

        QCOMPARE(i1.pixel(0,0), 0xFF000009U);

        QCOMPARE(i.pixel(0,0), 0xFF000005U);

    }

    QCOMPARE(i1.pixel(0,0), 0xFF000009U);

    // When the data is non-const, nothing you do to copies of the image will change the source data,

    // but changing the image (here via bits()) will change the source data.

    QImage i2((uchar*)data, 2, 2, 8, QImage::Format_RGB32);

    QCOMPARE(i2.pixel(0,0), 0xFF010101U);

    QCOMPARE(i2.pixel(1,0), 0xFF020202U);

    QCOMPARE(i2.pixel(0,1), 0xFF030303U);

    QCOMPARE(i2.pixel(1,1), 0xFF040404U);

    {

        QImage i(i2);

        i.setPixel(0,0,5);

    }

    QCOMPARE(i2.pixel(0,0), 0xFF010101U);

    QCOMPARE(*(QRgb*)data, 0xFF010101U);

    *((QRgb*)i2.bits()) = 7U;

    QCOMPARE(i2.pixel(0,0), 7U);

    QCOMPARE(*(QRgb*)data, 7U);

    // Changing the data will change the image in either case.

    QImage i3((uchar*)data, 2, 2, 8, QImage::Format_RGB32);

    QImage i4((const uchar*)data, 2, 2, 8, QImage::Format_RGB32);

    *(QRgb*)data = 6U;

    QCOMPARE(i3.pixel(0,0), 6U);

    QCOMPARE(i4.pixel(0,0), 6U);

}

void tst_QImage::convertBitOrder()

{

#if !defined(QT3_SUPPORT)

    QSKIP("Qt compiled without Qt3Support", SkipAll);

#else

    QImage i(9,5,1,2,QImage::LittleEndian);

    qMemSet(i.bits(), 0, i.byteCount());

    i.setDotsPerMeterX(9);

    i.setDotsPerMeterY(5);

    i.fill(0x12345678);

    QVERIFY(!i.isNull());

    QImage ni = i.convertBitOrder(QImage::BigEndian);

    QVERIFY(!ni.isNull());

    QVERIFY(ni.bitOrder() == QImage::BigEndian);

    // A bunch of verifies to make sure that nothing was lost

    QVERIFY(i.dotsPerMeterX() == ni.dotsPerMeterX());

    QVERIFY(i.dotsPerMeterY() == ni.dotsPerMeterY());

    QVERIFY(i.depth() == ni.depth());

    QVERIFY(i.size() == ni.size());

    QVERIFY(i.colorCount() == ni.colorCount());

#endif

}

void tst_QImage::formatHandlersInput_data()

{

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

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

    #ifdef Q_OS_SYMBIAN

    const QString prefix = QLatin1String(SRCDIR) + "images/";

    #else

    const QString prefix = QLatin1String(SRCDIR) + "/images/";

    #endif

    // add a new line here when a file is added

    QTest::newRow("ICO") << "ICO" << prefix + "image.ico";

    QTest::newRow("PNG") << "PNG" << prefix + "image.png";

    QTest::newRow("GIF") << "GIF" << prefix + "image.gif";

    QTest::newRow("BMP") << "BMP" << prefix + "image.bmp";

    QTest::newRow("JPEG") << "JPEG" << prefix + "image.jpg";

    QTest::newRow("PBM") << "PBM" << prefix + "image.pbm";

    QTest::newRow("PGM") << "PGM" << prefix + "image.pgm";

    QTest::newRow("PPM") << "PPM" << prefix + "image.ppm";

    QTest::newRow("XBM") << "XBM" << prefix + "image.xbm";

    QTest::newRow("XPM") << "XPM" << prefix + "image.xpm";

#if defined QTEST_HAVE_TIFF

    QTest::newRow("TIFF") << "TIFF" << prefix + "image.tif";

#endif

}

void tst_QImage::formatHandlersInput()

{

    QFETCH(QString, testFormat);

    QFETCH(QString, testFile);

    QList<QByteArray> formats = QImageReader::supportedImageFormats();

   // qDebug("Image input formats : %s", formats.join(" | ").latin1());

    bool formatSupported = false;

    for (QList<QByteArray>::Iterator it = formats.begin(); it != formats.end(); ++it) {

        if (*it == testFormat.toLower()) {

	    formatSupported = true;

	    break;

	}

    }

    if (formatSupported) {

//     qDebug(QImage::imageFormat(testFile));

	QCOMPARE(testFormat.toLatin1().toLower(), QImageReader::imageFormat(testFile));

    } else {

	QString msg = "Format not supported : ";

	QSKIP(QString(msg + testFormat).toLatin1(), SkipSingle);

    }

}

void tst_QImage::setAlphaChannel_data()

{

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

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

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

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

    QTest::addColumn<bool>("gray");

    QTest::newRow("red at 0%, gray") << 255 << 0 << 0 << 0 << true;

    QTest::newRow("red at 25%, gray") << 255 << 0 << 0 << 63 << true;

    QTest::newRow("red at 50%, gray") << 255 << 0 << 0 << 127 << true;

    QTest::newRow("red at 100%, gray") << 255 << 0 << 0 << 191 << true;

    QTest::newRow("red at 0%, 32bit") << 255 << 0 << 0 << 0 << false;

    QTest::newRow("red at 25%, 32bit") << 255 << 0 << 0 << 63 << false;

    QTest::newRow("red at 50%, 32bit") << 255 << 0 << 0 << 127 << false;

    QTest::newRow("red at 100%, 32bit") << 255 << 0 << 0 << 191 << false;

    QTest::newRow("green at 0%, gray") << 0 << 255 << 0 << 0 << true;

    QTest::newRow("green at 25%, gray") << 0 << 255 << 0 << 63 << true;

    QTest::newRow("green at 50%, gray") << 0 << 255 << 0 << 127 << true;

    QTest::newRow("green at 100%, gray") << 0 << 255 << 0 << 191 << true;

    QTest::newRow("green at 0%, 32bit") << 0 << 255 << 0 << 0 << false;

    QTest::newRow("green at 25%, 32bit") << 0 << 255 << 0 << 63 << false;

    QTest::newRow("green at 50%, 32bit") << 0 << 255 << 0 << 127 << false;

    QTest::newRow("green at 100%, 32bit") << 0 << 255 << 0 << 191 << false;

    QTest::newRow("blue at 0%, gray") << 0 << 0 << 255 << 0 << true;

    QTest::newRow("blue at 25%, gray") << 0 << 0 << 255 << 63 << true;

    QTest::newRow("blue at 50%, gray") << 0 << 0 << 255 << 127 << true;

    QTest::newRow("blue at 100%, gray") << 0 << 0 << 255 << 191 << true;

    QTest::newRow("blue at 0%, 32bit") << 0 << 0 << 255 << 0 << false;

    QTest::newRow("blue at 25%, 32bit") << 0 << 0 << 255 << 63 << false;

    QTest::newRow("blue at 50%, 32bit") << 0 << 0 << 255 << 127 << false;

    QTest::newRow("blue at 100%, 32bit") << 0 << 0 << 255 << 191 << false;

}

void tst_QImage::setAlphaChannel()

{

    QFETCH(int, red);

    QFETCH(int, green);

    QFETCH(int, blue);

    QFETCH(int, alpha);

    QFETCH(bool, gray);

    int width = 100;

    int height = 100;

    QImage image(width, height, QImage::Format_RGB32);

    image.fill(qRgb(red, green, blue));

    // Create the alpha channel

    QImage alphaChannel;

    if (gray) {

        alphaChannel = QImage(width, height, QImage::Format_Indexed8);

        alphaChannel.setColorCount(256);

        for (int i=0; i<256; ++i)

            alphaChannel.setColor(i, qRgb(i, i, i));

        alphaChannel.fill(alpha);

    } else {

        alphaChannel = QImage(width, height, QImage::Format_ARGB32);

        alphaChannel.fill(qRgb(alpha, alpha, alpha));

    }

    image.setAlphaChannel(alphaChannel);

    image = image.convertToFormat(QImage::Format_ARGB32);

    QVERIFY(image.format() == QImage::Format_ARGB32);

    // alpha of 0 becomes black at a=0 due to premultiplication

    QRgb pixel = alpha == 0 ? 0 : qRgba(red, green, blue, alpha);

    bool allPixelsOK = true;

    for (int y=0; y<height; ++y) {

        for (int x=0; x<width; ++x) {

            allPixelsOK &= image.pixel(x, y) == pixel;

        }

    }

    QVERIFY(allPixelsOK);

    QImage outAlpha = image.alphaChannel();

    QCOMPARE(outAlpha.size(), image.size());

    bool allAlphaOk = true;

    for (int y=0; y<height; ++y) {

        for (int x=0; x<width; ++x) {

            allAlphaOk &= outAlpha.pixelIndex(x, y) == alpha;

        }

    }

    QVERIFY(allAlphaOk);

}

void tst_QImage::alphaChannel()

{

    QImage img(10, 10, QImage::Format_Mono);

    img.setColor(0, Qt::transparent);

    img.setColor(1, Qt::black);

    img.fill(0);

    QPainter p(&img);

    p.fillRect(2, 2, 6, 6, Qt::black);

    p.end();

    QCOMPARE(img.alphaChannel(), img.convertToFormat(QImage::Format_ARGB32).alphaChannel());

}

void tst_QImage::convertToFormat_data()

{

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

    QTest::addColumn<uint>("inPixel");

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

    QTest::addColumn<uint>("resPixel");

    QTest::newRow("red rgb32 -> argb32") << int(QImage::Format_RGB32) << 0xffff0000

                                      << int(QImage::Format_ARGB32) << 0xffff0000;

    QTest::newRow("green rgb32 -> argb32") << int(QImage::Format_RGB32) << 0xff00ff00

                                        << int(QImage::Format_ARGB32) << 0xff00ff00;

    QTest::newRow("blue rgb32 -> argb32") << int(QImage::Format_RGB32) << 0xff0000ff

                                       << int(QImage::Format_ARGB32) << 0xff0000ff;

    QTest::newRow("red rgb32 -> rgb16") << int(QImage::Format_RGB32) << 0xffff0000

                                      << int(QImage::Format_RGB16) << 0xffff0000;

    QTest::newRow("green rgb32 -> rgb16") << int(QImage::Format_RGB32) << 0xff00ff00

                                        << int(QImage::Format_RGB16) << 0xff00ff00;

    QTest::newRow("blue rgb32 -> rgb16") << int(QImage::Format_RGB32) << 0xff0000ff

                                       << int(QImage::Format_RGB16) << 0xff0000ff;

    QTest::newRow("funky rgb32 -> rgb16") << int(QImage::Format_RGB32) << 0xfff0c080

                                       << int(QImage::Format_RGB16) << 0xfff7c384;

    QTest::newRow("red rgb32 -> argb32_pm") << int(QImage::Format_RGB32) << 0xffff0000

                                         << int(QImage::Format_ARGB32_Premultiplied) << 0xffff0000;

    QTest::newRow("green rgb32 -> argb32_pm") << int(QImage::Format_RGB32) << 0xff00ff00

                                           << int(QImage::Format_ARGB32_Premultiplied) <<0xff00ff00;

    QTest::newRow("blue rgb32 -> argb32_pm") << int(QImage::Format_RGB32) << 0xff0000ff

                                          << int(QImage::Format_ARGB32_Premultiplied) << 0xff0000ff;

    QTest::newRow("semired argb32 -> pm") << int(QImage::Format_ARGB32) << 0x7fff0000u

                                       << int(QImage::Format_ARGB32_Premultiplied) << 0x7f7f0000u;

    QTest::newRow("semigreen argb32 -> pm") << int(QImage::Format_ARGB32) << 0x7f00ff00u

                                         << int(QImage::Format_ARGB32_Premultiplied) << 0x7f007f00u;

    QTest::newRow("semiblue argb32 -> pm") << int(QImage::Format_ARGB32) << 0x7f0000ffu

                                        << int(QImage::Format_ARGB32_Premultiplied) << 0x7f00007fu;

    QTest::newRow("semiwhite argb32 -> pm") << int(QImage::Format_ARGB32) << 0x7fffffffu

                                         << int(QImage::Format_ARGB32_Premultiplied) << 0x7f7f7f7fu;

    QTest::newRow("semiblack argb32 -> pm") << int(QImage::Format_ARGB32) << 0x7f000000u

                                         << int(QImage::Format_ARGB32_Premultiplied) << 0x7f000000u;

    QTest::newRow("semired pm -> argb32") << int(QImage::Format_ARGB32_Premultiplied) << 0x7f7f0000u

                                       << int(QImage::Format_ARGB32) << 0x7fff0000u;

    QTest::newRow("semigreen pm -> argb32") << int(QImage::Format_ARGB32_Premultiplied) << 0x7f007f00u

                                         << int(QImage::Format_ARGB32) << 0x7f00ff00u;

    QTest::newRow("semiblue pm -> argb32") << int(QImage::Format_ARGB32_Premultiplied) << 0x7f00007fu

                                        << int(QImage::Format_ARGB32) << 0x7f0000ffu;

    QTest::newRow("semiwhite pm -> argb32") << int(QImage::Format_ARGB32_Premultiplied) << 0x7f7f7f7fu

                                         << int(QImage::Format_ARGB32) << 0x7fffffffu;

    QTest::newRow("semiblack pm -> argb32") << int(QImage::Format_ARGB32_Premultiplied) << 0x7f000000u

                                         << int(QImage::Format_ARGB32) << 0x7f000000u;

    QTest::newRow("semired pm -> rgb32") << int(QImage::Format_ARGB32_Premultiplied) << 0x7f7f0000u

                                       << int(QImage::Format_RGB32) << 0xffff0000u;

    QTest::newRow("semigreen pm -> rgb32") << int(QImage::Format_ARGB32_Premultiplied) << 0x7f007f00u

                                         << int(QImage::Format_RGB32) << 0xff00ff00u;

    QTest::newRow("semiblue pm -> rgb32") << int(QImage::Format_ARGB32_Premultiplied) << 0x7f00007fu

                                        << int(QImage::Format_RGB32) << 0xff0000ffu;

    QTest::newRow("semiwhite pm -> rgb32") << int(QImage::Format_ARGB32_Premultiplied) << 0x7f7f7f7fu

                                         << int(QImage::Format_RGB32) << 0xffffffffu;

    QTest::newRow("semiblack pm -> rgb32") << int(QImage::Format_ARGB32_Premultiplied) << 0x7f000000u

                                         << int(QImage::Format_RGB32) << 0xff000000u;

    QTest::newRow("semired argb32 -> rgb32") << int(QImage::Format_ARGB32) << 0x7fff0000u

                                             << int(QImage::Format_RGB32) << 0xffff0000u;

    QTest::newRow("semigreen argb32 -> rgb32") << int(QImage::Format_ARGB32) << 0x7f00ff00u

                                               << int(QImage::Format_RGB32) << 0xff00ff00u;

    QTest::newRow("semiblue argb32 -> rgb32") << int(QImage::Format_ARGB32) << 0x7f0000ffu

                                              << int(QImage::Format_RGB32) << 0xff0000ffu;

    QTest::newRow("semiwhite argb -> rgb32") << int(QImage::Format_ARGB32) << 0x7fffffffu

                                             << int(QImage::Format_RGB32) << 0xffffffffu;

    QTest::newRow("semiblack argb -> rgb32") << int(QImage::Format_ARGB32) << 0x7f000000u

                                             << int(QImage::Format_RGB32) << 0xff000000u;

    QTest::newRow("black mono -> rgb32") << int(QImage::Format_Mono) << 0x00000000u

                                         << int(QImage::Format_RGB32) << 0xff000000u;

    QTest::newRow("white mono -> rgb32") << int(QImage::Format_Mono) << 0x00000001u

                                         << int(QImage::Format_RGB32) << 0xffffffffu;

    QTest::newRow("red rgb16 -> argb32") << int(QImage::Format_RGB16) << 0xffff0000

                                         << int(QImage::Format_ARGB32) << 0xffff0000;

    QTest::newRow("green rgb16 -> argb32") << int(QImage::Format_RGB16) << 0xff00ff00

                                           << int(QImage::Format_ARGB32) << 0xff00ff00;

    QTest::newRow("blue rgb16 -> argb32") << int(QImage::Format_RGB16) << 0xff0000ff

                                          << int(QImage::Format_ARGB32) << 0xff0000ff;

    QTest::newRow("red rgb16 -> rgb16") << int(QImage::Format_RGB32) << 0xffff0000

                                         << int(QImage::Format_RGB16) << 0xffff0000;

    QTest::newRow("green rgb16 -> rgb16") << int(QImage::Format_RGB32) << 0xff00ff00

                                           << int(QImage::Format_RGB16) << 0xff00ff00;

    QTest::newRow("blue rgb16 -> rgb16") << int(QImage::Format_RGB32) << 0xff0000ff

                                          << int(QImage::Format_RGB16) << 0xff0000ff;

    QTest::newRow("semired argb32 -> rgb16") << int(QImage::Format_ARGB32) << 0x7fff0000u

                                             << int(QImage::Format_RGB16) << 0xffff0000;

    QTest::newRow("semigreen argb32 -> rgb16") << int(QImage::Format_ARGB32) << 0x7f00ff00u

                                               << int(QImage::Format_RGB16) << 0xff00ff00;

    QTest::newRow("semiblue argb32 -> rgb16") << int(QImage::Format_ARGB32) << 0x7f0000ffu

                                              << int(QImage::Format_RGB16) << 0xff0000ff;

    QTest::newRow("semired pm -> rgb16") << int(QImage::Format_ARGB32_Premultiplied) << 0x7f7f0000u

                                       << int(QImage::Format_RGB16) << 0xffff0000u;

    QTest::newRow("semigreen pm -> rgb16") << int(QImage::Format_ARGB32_Premultiplied) << 0x7f007f00u

                                         << int(QImage::Format_RGB16) << 0xff00ff00u;

    QTest::newRow("semiblue pm -> rgb16") << int(QImage::Format_ARGB32_Premultiplied) << 0x7f00007fu

                                        << int(QImage::Format_RGB16) << 0xff0000ffu;

    QTest::newRow("semiwhite pm -> rgb16") << int(QImage::Format_ARGB32_Premultiplied) << 0x7f7f7f7fu