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

**

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

**

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

#include <QtTest/QtTest>

#include <QBuffer>

#include <QDebug>

#include <QFile>

#include <QImage>

#include <QImageReader>

#include <QImageWriter>

#include <QLabel>

#include <QPixmap>

#include <QSet>

#include <QTcpSocket>

#include <QTcpServer>

#include <QTimer>

#if defined(Q_OS_SYMBIAN)

# define SRCDIR "."

#endif

typedef QMap<QString, QString> QStringMap;

typedef QList<int> QIntList;

Q_DECLARE_METATYPE(QImage)

Q_DECLARE_METATYPE(QRect)

Q_DECLARE_METATYPE(QSize)

Q_DECLARE_METATYPE(QColor)

Q_DECLARE_METATYPE(QStringMap)

Q_DECLARE_METATYPE(QIntList)

Q_DECLARE_METATYPE(QIODevice *)

Q_DECLARE_METATYPE(QImage::Format)

//TESTED_FILES=

class tst_QImageReader : public QObject

{

    Q_OBJECT

public:

    tst_QImageReader();

    virtual ~tst_QImageReader();

public slots:

    void init();

    void cleanup();

private slots:

    void getSetCheck();

    void readImage_data();

    void readImage();

    void jpegRgbCmyk();

    void setScaledSize_data();

    void setScaledSize();

    void setClipRect_data();

    void setClipRect();

    void setScaledClipRect_data();

    void setScaledClipRect();

    void imageFormat_data();

    void imageFormat();

    void blackXPM();

    void transparentXPM();

    void multiWordNamedColorXPM();

    void supportedFormats();

    void readFromDevice_data();

    void readFromDevice();

    void readFromFileAfterJunk_data();

    void readFromFileAfterJunk();

    void setBackgroundColor_data();

    void setBackgroundColor();

    void supportsAnimation_data();

    void supportsAnimation();

    void description_data();

    void description();

    void readFromResources_data();

    void readFromResources();

    void dotsPerMeter_data();

    void dotsPerMeter();

    void physicalDpi_data();

    void physicalDpi();

    void sizeBeforeRead_data();

    void sizeBeforeRead();

    void imageFormatBeforeRead_data();

    void imageFormatBeforeRead();

#if defined QTEST_HAVE_GIF

    void gifHandlerBugs();

    void animatedGif();

#endif

    void readCorruptImage_data();

    void readCorruptImage();

    void readCorruptBmp();

    void supportsOption_data();

    void supportsOption();

#if defined QTEST_HAVE_TIFF

    void tiffCompression_data();

    void tiffCompression();

    void tiffEndianness();

    void tiffOrientation_data();

    void tiffOrientation();

#endif

    void autoDetectImageFormat();

    void fileNameProbing();

    void pixelCompareWithBaseline_data();

    void pixelCompareWithBaseline();

    void task255627_setNullScaledSize_data();

    void task255627_setNullScaledSize();

    void testIgnoresFormatAndExtension_data();

    void testIgnoresFormatAndExtension();

};

static const QLatin1String prefix(SRCDIR "/images/");

// Testing get/set functions

void tst_QImageReader::getSetCheck()

{

    QImageReader obj1;

    // QIODevice * QImageReader::device()

    // void QImageReader::setDevice(QIODevice *)

    QFile *var1 = new QFile;

    obj1.setDevice(var1);

    //A bit strange but that's the only way to compile under windows.

    QCOMPARE((QIODevice *) var1, obj1.device());

    obj1.setDevice((QIODevice *)0);

    QCOMPARE((QIODevice *) 0,

             obj1.device());

    delete var1;

}

tst_QImageReader::tst_QImageReader()

{

}

tst_QImageReader::~tst_QImageReader()

{

}

void tst_QImageReader::init()

{

}

void tst_QImageReader::cleanup()

{

}

void tst_QImageReader::readImage_data()

{

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

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

    QTest::addColumn<QByteArray>("format");

    QTest::newRow("empty") << QString() << false << QByteArray();

    QTest::newRow("BMP: colorful") << QString("colorful.bmp") << true << QByteArray("bmp");

    QTest::newRow("BMP: font") << QString("font.bmp") << true << QByteArray("bmp");

    QTest::newRow("BMP: signed char") << QString("crash-signed-char.bmp") << true << QByteArray("bmp");

    QTest::newRow("BMP: 4bpp RLE") << QString("4bpp-rle.bmp") << true << QByteArray("bmp");

    QTest::newRow("BMP: 4bpp uncompressed") << QString("tst7.bmp") << true << QByteArray("bmp");

    QTest::newRow("BMP: 16bpp") << QString("16bpp.bmp") << true << QByteArray("bmp");

    QTest::newRow("BMP: negative height") << QString("negativeheight.bmp") << true << QByteArray("bmp");

    QTest::newRow("XPM: marble") << QString("marble.xpm") << true << QByteArray("xpm");

    QTest::newRow("PNG: kollada") << QString("kollada.png") << true << QByteArray("png");

    QTest::newRow("PPM: teapot") << QString("teapot.ppm") << true << QByteArray("ppm");

    QTest::newRow("PPM: runners") << QString("runners.ppm") << true << QByteArray("ppm");

    QTest::newRow("PPM: test") << QString("test.ppm") << true << QByteArray("ppm");

    QTest::newRow("XBM: gnus") << QString("gnus.xbm") << true << QByteArray("xbm");

#if defined QTEST_HAVE_JPEG

    QTest::newRow("JPEG: beavis") << QString("beavis.jpg") << true << QByteArray("jpeg");

#endif

#if defined QTEST_HAVE_GIF

    QTest::newRow("GIF: earth") << QString("earth.gif") << true << QByteArray("gif");

    QTest::newRow("GIF: trolltech") << QString("trolltech.gif") << true << QByteArray("gif");

#endif

#if defined QTEST_HAVE_MNG

    QTest::newRow("MNG: ball") << QString("ball.mng") << true << QByteArray("mng");

    QTest::newRow("MNG: fire") << QString("fire.mng") << true << QByteArray("mng");

#endif

}

void tst_QImageReader::readImage()

{

    QFETCH(QString, fileName);

    QFETCH(bool, success);

    QFETCH(QByteArray, format);

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

        QImageReader io(prefix + fileName, i ? QByteArray() : format);

        if (success) {

            if (!io.supportsAnimation())

                QVERIFY(io.imageCount() > 0);

        } else {

            QCOMPARE(io.imageCount(), -1);

        }

        QImage image = io.read();

        if (!success) {

            QVERIFY(image.isNull());

            return;

        }

        QVERIFY2(!image.isNull(), io.errorString().toLatin1().constData());

        // No format

        QImageReader io2(prefix + fileName);

        QVERIFY2(!io2.read().isNull(), io.errorString().toLatin1().constData());

        // No extension, no format

        QImageReader io3(prefix + fileName.left(fileName.lastIndexOf(QLatin1Char('.'))));

        QVERIFY2(!io3.read().isNull(), io.errorString().toLatin1().constData());

        // Read into \a image2

        QImage image2;

        QImageReader image2Reader(prefix + fileName, i ? QByteArray() : format);

        QCOMPARE(image2Reader.format(), format);

        QVERIFY(image2Reader.read(&image2));

        if (image2Reader.canRead()) {

            if (i)

                QVERIFY(!image2Reader.format().isEmpty());

            else

                QCOMPARE(image2Reader.format(), format);

        } else {

            if (i)

                QVERIFY(image2Reader.format().isEmpty());

            else

                QVERIFY(!image2Reader.format().isEmpty());

        }

        QCOMPARE(image, image2);

        do {

            QVERIFY2(!image.isNull(), io.errorString().toLatin1().constData());

        } while (!(image = io.read()).isNull());

    }

}

void tst_QImageReader::jpegRgbCmyk()

{

    QImage image1(prefix + QLatin1String("YCbCr_cmyk.jpg"));

    QImage image2(prefix + QLatin1String("YCbCr_cmyk.png"));

    QCOMPARE(image1, image2);

}

void tst_QImageReader::setScaledSize_data()

{

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

    QTest::addColumn<QSize>("newSize");

    QTest::addColumn<QByteArray>("format");

    QTest::newRow("BMP: colorful") << "colorful" << QSize(200, 200) << QByteArray("bmp");

    QTest::newRow("BMP: font") << "font" << QSize(200, 200) << QByteArray("bmp");

    QTest::newRow("XPM: marble") << "marble" << QSize(200, 200) << QByteArray("xpm");

    QTest::newRow("PNG: kollada") << "kollada" << QSize(200, 200) << QByteArray("png");

    QTest::newRow("PPM: teapot") << "teapot" << QSize(200, 200) << QByteArray("ppm");

    QTest::newRow("PPM: runners") << "runners.ppm" << QSize(400, 400) << QByteArray("ppm");

    QTest::newRow("PPM: test") << "test.ppm" << QSize(10, 10) << QByteArray("ppm");

    QTest::newRow("XBM: gnus") << "gnus" << QSize(200, 200) << QByteArray("xbm");

#ifdef QTEST_HAVE_JPEG

    QTest::newRow("JPEG: beavis") << "beavis" << QSize(200, 200) << QByteArray("jpeg");

#endif // QTEST_HAVE_JPEG

#ifdef QTEST_HAVE_GIF

    QTest::newRow("GIF: earth") << "earth" << QSize(200, 200) << QByteArray("gif");

    QTest::newRow("GIF: trolltech") << "trolltech" << QSize(200, 200) << QByteArray("gif");

#endif // QTEST_HAVE_GIF

#ifdef QTEST_HAVE_MNG

    QTest::newRow("MNG: ball") << "ball" << QSize(200, 200) << QByteArray("mng");

    QTest::newRow("MNG: fire") << "fire" << QSize(200, 200) << QByteArray("mng");

#endif // QTEST_HAVE_MNG

}

void tst_QImageReader::setScaledSize()

{

    QFETCH(QString, fileName);

    QFETCH(QSize, newSize);

    QFETCH(QByteArray, format);

    if (!format.isEmpty() && !QImageReader::supportedImageFormats().contains(format))

        QSKIP("Qt does not support reading the \"" + format + "\" format", SkipSingle);

    QImageReader reader(prefix + fileName);

    reader.setScaledSize(newSize);

    QImage image = reader.read();

    QVERIFY(!image.isNull());

    QCOMPARE(image.size(), newSize);

}

void tst_QImageReader::task255627_setNullScaledSize_data()

{

    setScaledSize_data();

}

void tst_QImageReader::task255627_setNullScaledSize()

{

    QFETCH(QString, fileName);

    QFETCH(QByteArray, format);

    if (!format.isEmpty() && !QImageReader::supportedImageFormats().contains(format))

        QSKIP("Qt does not support reading the \"" + format + "\" format", SkipSingle);

    QImageReader reader(prefix + fileName);

    // set a null size

    reader.setScaledSize(QSize(0, 0));

    reader.setQuality(0);

    QImage image = reader.read();

    QVERIFY(image.isNull());

    QCOMPARE(image.size(), QSize(0, 0));

}

void tst_QImageReader::setClipRect_data()

{

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

    QTest::addColumn<QRect>("newRect");

    QTest::addColumn<QByteArray>("format");

    QTest::newRow("BMP: colorful") << "colorful" << QRect(0, 0, 50, 50) << QByteArray("bmp");

    QTest::newRow("BMP: font") << "font" << QRect(0, 0, 50, 50) << QByteArray("bmp");

    QTest::newRow("BMP: 4bpp uncompressed") << "tst7.bmp" << QRect(0, 0, 31, 31) << QByteArray("bmp");

    QTest::newRow("XPM: marble") << "marble" << QRect(0, 0, 50, 50) << QByteArray("xpm");

    QTest::newRow("PNG: kollada") << "kollada" << QRect(0, 0, 50, 50) << QByteArray("png");

    QTest::newRow("PPM: teapot") << "teapot" << QRect(0, 0, 50, 50) << QByteArray("ppm");

    QTest::newRow("PPM: runners") << "runners.ppm" << QRect(0, 0, 50, 50) << QByteArray("ppm");

    QTest::newRow("PPM: test") << "test.ppm" << QRect(0, 0, 50, 50) << QByteArray("ppm");

    QTest::newRow("XBM: gnus") << "gnus" << QRect(0, 0, 50, 50) << QByteArray("xbm");

#ifdef QTEST_HAVE_JPEG

    QTest::newRow("JPEG: beavis") << "beavis" << QRect(0, 0, 50, 50) << QByteArray("jpeg");

#endif // QTEST_HAVE_JPEG

#ifdef QTEST_HAVE_GIF

    QTest::newRow("GIF: earth") << "earth" << QRect(0, 0, 50, 50) << QByteArray("gif");

    QTest::newRow("GIF: trolltech") << "trolltech" << QRect(0, 0, 50, 50) << QByteArray("gif");

#endif // QTEST_HAVE_GIF

#ifdef QTEST_HAVE_MNG

    QTest::newRow("MNG: ball") << "ball" << QRect(0, 0, 50, 50) << QByteArray("mng");

    QTest::newRow("MNG: fire") << "fire" << QRect(0, 0, 50, 50) << QByteArray("mng");

#endif // QTEST_HAVE_MNG

}

void tst_QImageReader::setClipRect()

{

    QFETCH(QString, fileName);

    QFETCH(QRect, newRect);

    QFETCH(QByteArray, format);

    if (!format.isEmpty() && !QImageReader::supportedImageFormats().contains(format))

        QSKIP("Qt does not support reading the \"" + format + "\" format", SkipSingle);

    QImageReader reader(prefix + fileName);

    reader.setClipRect(newRect);

    QImage image = reader.read();

    QVERIFY(!image.isNull());

    QCOMPARE(image.rect(), newRect);

    QImageReader originalReader(prefix + fileName);

    QImage originalImage = originalReader.read();

    QCOMPARE(originalImage.copy(newRect), image);

}

void tst_QImageReader::setScaledClipRect_data()

{

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

    QTest::addColumn<QRect>("newRect");

    QTest::addColumn<QByteArray>("format");

    QTest::newRow("BMP: colorful") << "colorful" << QRect(0, 0, 50, 50) << QByteArray("bmp");

    QTest::newRow("BMP: font") << "font" << QRect(0, 0, 50, 50) << QByteArray("bmp");

    QTest::newRow("XPM: marble") << "marble" << QRect(0, 0, 50, 50) << QByteArray("xpm");

    QTest::newRow("PNG: kollada") << "kollada" << QRect(0, 0, 50, 50) << QByteArray("png");

    QTest::newRow("PPM: teapot") << "teapot" << QRect(0, 0, 50, 50) << QByteArray("ppm");

    QTest::newRow("PPM: runners") << "runners.ppm" << QRect(0, 0, 50, 50) << QByteArray("ppm");

    QTest::newRow("PPM: test") << "test.ppm" << QRect(0, 0, 50, 50) << QByteArray("ppm");

    QTest::newRow("XBM: gnus") << "gnus" << QRect(0, 0, 50, 50) << QByteArray("xbm");

#ifdef QTEST_HAVE_JPEG

    QTest::newRow("JPEG: beavis") << "beavis" << QRect(0, 0, 50, 50) << QByteArray("jpeg");

#endif // QTEST_HAVE_JPEG

#ifdef QTEST_HAVE_GIF

    QTest::newRow("GIF: earth") << "earth" << QRect(0, 0, 50, 50) << QByteArray("gif");

    QTest::newRow("GIF: trolltech") << "trolltech" << QRect(0, 0, 50, 50) << QByteArray("gif");

#endif // QTEST_HAVE_GIF

#ifdef QTEST_HAVE_MNG

    QTest::newRow("MNG: ball") << "ball" << QRect(0, 0, 50, 50) << QByteArray("mng");

    QTest::newRow("MNG: fire") << "fire" << QRect(0, 0, 50, 50) << QByteArray("mng");

#endif // QTEST_HAVE_MNG

}

void tst_QImageReader::setScaledClipRect()

{

    QFETCH(QString, fileName);

    QFETCH(QRect, newRect);

    QFETCH(QByteArray, format);

    if (!format.isEmpty() && !QImageReader::supportedImageFormats().contains(format))

        QSKIP("Qt does not support reading the \"" + format + "\" format", SkipSingle);

    QImageReader reader(prefix + fileName);

    reader.setScaledSize(QSize(300, 300));

    reader.setScaledClipRect(newRect);

    QImage image = reader.read();

    QVERIFY(!image.isNull());

    QCOMPARE(image.rect(), newRect);

    QImageReader originalReader(prefix + fileName);

    originalReader.setScaledSize(QSize(300, 300));

    QImage originalImage = originalReader.read();

    QCOMPARE(originalImage.copy(newRect), image);

}

void tst_QImageReader::imageFormat_data()

{

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

    QTest::addColumn<QByteArray>("format");

    QTest::addColumn<QImage::Format>("imageFormat");

    QTest::newRow("pbm") << QString("image.pbm") << QByteArray("pbm") << QImage::Format_Mono;

    QTest::newRow("pgm") << QString("image.pgm") << QByteArray("pgm") << QImage::Format_Indexed8;

    QTest::newRow("ppm-1") << QString("image.ppm") << QByteArray("ppm") << QImage::Format_RGB32;

    QTest::newRow("ppm-2") << QString("teapot.ppm") << QByteArray("ppm") << QImage::Format_RGB32;

    QTest::newRow("ppm-3") << QString("runners.ppm") << QByteArray("ppm") << QImage::Format_RGB32;

    QTest::newRow("ppm-4") << QString("test.ppm") << QByteArray("ppm") << QImage::Format_RGB32;

#ifdef QTEST_HAVE_JPEG

    QTest::newRow("jpeg-1") << QString("beavis.jpg") << QByteArray("jpeg") << QImage::Format_Indexed8;

    QTest::newRow("jpeg-2") << QString("YCbCr_cmyk.jpg") << QByteArray("jpeg") << QImage::Format_RGB32;

    QTest::newRow("jpeg-3") << QString("YCbCr_rgb.jpg") << QByteArray("jpeg") << QImage::Format_RGB32;

#endif

#if defined QTEST_HAVE_GIF

    QTest::newRow("gif-1") << QString("earth.gif") << QByteArray("gif") << QImage::Format_Invalid;

    QTest::newRow("gif-2") << QString("trolltech.gif") << QByteArray("gif") << QImage::Format_Invalid;

#endif

    QTest::newRow("xbm") << QString("gnus.xbm") << QByteArray("xbm") << QImage::Format_MonoLSB;

    QTest::newRow("xpm") << QString("marble.xpm") << QByteArray("xpm") << QImage::Format_Indexed8;

    QTest::newRow("bmp-1") << QString("colorful.bmp") << QByteArray("bmp") << QImage::Format_Indexed8;

    QTest::newRow("bmp-2") << QString("font.bmp") << QByteArray("bmp") << QImage::Format_Indexed8;

    QTest::newRow("png") << QString("kollada.png") << QByteArray("png") << QImage::Format_ARGB32;

    QTest::newRow("png-2") << QString("YCbCr_cmyk.png") << QByteArray("png") << QImage::Format_RGB32;

    QTest::newRow("mng-1") << QString("ball.mng") << QByteArray("mng") << QImage::Format_Invalid;

    QTest::newRow("mng-2") << QString("fire.mng") << QByteArray("mng") << QImage::Format_Invalid;

}

void tst_QImageReader::imageFormat()

{

    QFETCH(QString, fileName);

    QFETCH(QByteArray, format);

    QFETCH(QImage::Format, imageFormat);

    if (QImageReader::imageFormat(prefix + fileName).isEmpty()) {

        if (QByteArray("jpeg") == format)

#ifndef QTEST_HAVE_JPEG

            return;

#endif // !QTEST_HAVE_JPEG

        if (QByteArray("gif") == format)

#ifndef QTEST_HAVE_GIF

            return;

#endif // !QTEST_HAVE_GIF

        if (QByteArray("mng") == format)

#ifndef QTEST_HAVE_MNG

            return;

#endif // !QTEST_HAVE_MNG

        QSKIP(("Qt does not support the " + format + " format.").constData(), SkipSingle);

    } else {

        QCOMPARE(QImageReader::imageFormat(prefix + fileName), format);

    }

    QImageReader reader(prefix + fileName);

    QCOMPARE(reader.imageFormat(), imageFormat);

}