Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 2059 insertions, 0 deletions

diff --git a/tests/auto/qimagereader/tst_qimagereader.cpp b/tests/auto/qimagereader/tst_qimagereader.cpp
new file mode 100644
index 0000000000..5db5f5630f
--- /dev/null
+++ b/tests/auto/qimagereader/tst_qimagereader.cpp
@@ -0,0 +1,2059 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 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>
+
+#include "../platformquirks.h"
+
+#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 devicePosition_data();
+    void devicePosition();
+
+    void setBackgroundColor_data();
+    void setBackgroundColor();
+
+    void supportsAnimation_data();
+    void supportsAnimation();
+
+    void readFromResources_data();
+    void readFromResources();
+
+    void dotsPerMeter_data();
+    void dotsPerMeter();
+
+    void physicalDpi_data();
+    void physicalDpi();
+
+    void sizeBeforeRead_data();
+    void sizeBeforeRead();
+
+    void sizeBeforeFormat_data();
+    void sizeBeforeFormat();
+
+    void imageFormatBeforeRead_data();
+    void imageFormatBeforeRead();
+
+#if defined QTEST_HAVE_GIF
+    void gifHandlerBugs();
+    void animatedGif();
+    void gifImageCount();
+    void gifLoopCount();
+#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();
+
+    void tiffGrayscale();
+#endif
+
+    void autoDetectImageFormat();
+    void fileNameProbing();
+
+    void pixelCompareWithBaseline_data();
+    void pixelCompareWithBaseline();
+
+    void task255627_setNullScaledSize_data();
+    void task255627_setNullScaledSize();
+
+    void testIgnoresFormatAndExtension_data();
+    void testIgnoresFormatAndExtension();
+
+    void saveFormat_data();
+    void saveFormat();
+
+    void readText_data();
+    void readText();
+
+    void preserveTexts_data();
+    void preserveTexts();
+};
+
+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");
+    QTest::newRow("JPEG: qtbug13653") << QString("qtbug13653-no_eoi.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
+#if defined QTEST_HAVE_SVG
+    QTest::newRow("SVG: rect") << QString("rect.svg") << true << QByteArray("svg");
+    QTest::newRow("SVGZ: rect") << QString("rect.svgz") << true << QByteArray("svgz");
+#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"));
+
+    if (PlatformQuirks::isImageLoaderImprecise()) {
+        // first, do some obvious tests
+        QCOMPARE(image1.height(), image2.height());
+        QCOMPARE(image1.width(), image2.width());
+        QCOMPARE(image1.format(), image2.format());
+        QCOMPARE(image1.format(), QImage::Format_RGB32);
+
+        // compare all the pixels with a slack of 3. This ignores rounding errors in libjpeg/libpng
+        for (int h = 0; h < image1.height(); ++h) {
+            const uchar *s1 = image1.constScanLine(h);
+            const uchar *s2 = image2.constScanLine(h);
+            for (int w = 0; w < image1.width() * 4; ++w) {
+                if (*s1 != *s2) {
+                    QVERIFY2(qAbs(*s1 - *s2) <= 3, qPrintable(QString("images differ in line %1, col %2 (image1: %3, image2: %4)").arg(h).arg(w).arg(*s1, 0, 16).arg(*s2, 0, 16)));
+                }
+                s1++;
+                s2++;
+            }
+        }
+    } else {
+        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 A") << "beavis" << QSize(200, 200) << QByteArray("jpeg");
+    QTest::newRow("JPEG: beavis B") << "beavis" << QSize(175, 175) << QByteArray("jpeg");
+    QTest::newRow("JPEG: beavis C") << "beavis" << QSize(100, 100) << QByteArray("jpeg");
+    QTest::newRow("JPEG: beavis D") << "beavis" << QSize(100, 200) << QByteArray("jpeg");
+    QTest::newRow("JPEG: beavis E") << "beavis" << QSize(200, 100) << QByteArray("jpeg");
+    QTest::newRow("JPEG: beavis F") << "beavis" << QSize(87, 87) << QByteArray("jpeg");
+    QTest::newRow("JPEG: beavis G") << "beavis" << QSize(50, 45) << QByteArray("jpeg");
+    QTest::newRow("JPEG: beavis H") << "beavis" << QSize(43, 43) << QByteArray("jpeg");
+    QTest::newRow("JPEG: beavis I") << "beavis" << QSize(25, 25) << 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
+#if defined QTEST_HAVE_SVG
+    QTest::newRow("SVG: rect") << "rect" << QSize(200, 200) << QByteArray("svg");
+    QTest::newRow("SVGZ: rect") << "rect" << QSize(200, 200) << QByteArray("svgz");
+#endif
+}
+
+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
+#if defined QTEST_HAVE_SVG
+    QTest::newRow("SVG: rect") << "rect" << QRect(0, 0, 50, 50) << QByteArray("svg");
+    QTest::newRow("SVGZ: rect") << "rect" << QRect(0, 0, 50, 50) << QByteArray("svgz");
+#endif
+}
+
+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
+#if defined QTEST_HAVE_SVG
+    QTest::newRow("SVG: rect") << "rect" << QRect(0, 0, 50, 50) << QByteArray("svg");
+    QTest::newRow("SVGZ: rect") << "rect" << QRect(0, 0, 50, 50) << QByteArray("svgz");
+#endif
+}
+
+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;
+    QTest::newRow("svg") << QString("rect.svg") << QByteArray("svg") << QImage::Format_ARGB32_Premultiplied;
+    QTest::newRow("svgz") << QString("rect.svgz") << QByteArray("svgz") << QImage::Format_ARGB32_Premultiplied;
+}
+
+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
+        if (QByteArray("svg") == format || QByteArray("svgz") == format)
+#ifndef QTEST_HAVE_SVG
+            return;
+#endif // !QTEST_HAVE_SVG
+        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);
+}
+
+void tst_QImageReader::blackXPM()
+{
+    QImage image(prefix + QLatin1String("black.xpm"));
+    QImage image2(prefix + QLatin1String("black.png"));
+    QCOMPARE(image.pixel(25, 25), qRgb(190, 190, 190));
+    QCOMPARE(image.pixel(25, 25), image2.pixel(25, 25));
+}
+
+void tst_QImageReader::transparentXPM()
+{
+    QImage image(prefix + QLatin1String("nontransparent.xpm"));
+    QImage image2(prefix + QLatin1String("transparent.xpm"));
+    QCOMPARE(image.format(), QImage::Format_RGB32);
+    QCOMPARE(image2.format(), QImage::Format_ARGB32);
+}
+
+void tst_QImageReader::multiWordNamedColorXPM()
+{
+    QImage image(prefix + QLatin1String("namedcolors.xpm"));
+    QCOMPARE(image.pixel(0, 0), qRgb(102, 139, 139)); // pale turquoise 4
+    QCOMPARE(image.pixel(0, 1), qRgb(250, 250, 210)); // light golden rod yellow
+    QCOMPARE(image.pixel(0, 2), qRgb(255, 250, 205)); // lemon chiffon
+}
+
+void tst_QImageReader::supportedFormats()
+{
+    QList<QByteArray> formats = QImageReader::supportedImageFormats();
+    QList<QByteArray> sortedFormats = formats;
+    qSort(sortedFormats);
+
+    // check that the list is sorted
+    QCOMPARE(formats, sortedFormats);
+
+    QSet<QByteArray> formatSet;
+    foreach (QByteArray format, formats)
+        formatSet << format;
+
+    // check that the list does not contain duplicates
+    QCOMPARE(formatSet.size(), formats.size());
+}
+
+void tst_QImageReader::setBackgroundColor_data()
+{
+    QTest::addColumn<QString>("fileName");
+    QTest::addColumn<QColor>("color");
+
+    QTest::newRow("BMP: colorful") << QString("colorful.bmp") << QColor(Qt::white);
+    QTest::newRow("BMP: font") << QString("font.bmp") << QColor(Qt::black);
+    QTest::newRow("BMP: signed char") << QString("crash-signed-char.bmp") << QColor(Qt::red);
+    QTest::newRow("XPM: marble") << QString("marble.xpm") << QColor(Qt::darkRed);
+    QTest::newRow("PNG: kollada") << QString("kollada.png") << QColor(Qt::green);
+    QTest::newRow("PPM: teapot") << QString("teapot.ppm") << QColor(Qt::darkGreen);
+    QTest::newRow("PPM: runners") << QString("runners.ppm") << QColor(Qt::red);
+    QTest::newRow("PPM: test") << QString("test.ppm") << QColor(Qt::white);
+    QTest::newRow("XBM: gnus") << QString("gnus.xbm") << QColor(Qt::blue);
+#if defined QTEST_HAVE_JPEG
+    QTest::newRow("JPEG: beavis") << QString("beavis.jpg") << QColor(Qt::darkBlue);
+#endif
+#if defined QTEST_HAVE_GIF
+    QTest::newRow("GIF: earth") << QString("earth.gif") << QColor(Qt::cyan);
+    QTest::newRow("GIF: trolltech") << QString("trolltech.gif") << QColor(Qt::magenta);
+#endif
+#if defined QTEST_HAVE_MNG
+    QTest::newRow("MNG: ball") << QString("ball.mng") << QColor(Qt::yellow);
+    QTest::newRow("MNG: fire") << QString("fire.mng") << QColor(Qt::gray);
+#endif
+#if defined QTEST_HAVE_SVG
+    QTest::newRow("SVG: rect") << QString("rect.svg") << QColor(Qt::darkGreen);
+    QTest::newRow("SVGZ: rect") << QString("rect.svgz") << QColor(Qt::darkGreen);
+#endif
+}
+
+void tst_QImageReader::setBackgroundColor()
+{
+    QFETCH(QString, fileName);
+    QFETCH(QColor, color);
+    QImageReader io("images/" + fileName);
+    io.setBackgroundColor(color);
+    if (io.backgroundColor().isValid())
+        QCOMPARE(io.backgroundColor(), color);
+}
+
+void tst_QImageReader::supportsAnimation_data()
+{
+    QTest::addColumn<QString>("fileName");
+    QTest::addColumn<bool>("success");
+
+    QTest::newRow("BMP: colorful") << QString("colorful.bmp") << false;
+    QTest::newRow("BMP: font") << QString("font.bmp") << false;
+    QTest::newRow("BMP: signed char") << QString("crash-signed-char.bmp") << false;
+    QTest::newRow("XPM: marble") << QString("marble.xpm") << false;
+    QTest::newRow("PNG: kollada") << QString("kollada.png") << false;
+    QTest::newRow("PPM: teapot") << QString("teapot.ppm") << false;
+    QTest::newRow("PPM: teapot") << QString("teapot.ppm") << false;
+    QTest::newRow("PPM: runners") << QString("runners.ppm") << false;
+    QTest::newRow("XBM: gnus") << QString("gnus.xbm") << false;
+#if defined QTEST_HAVE_JPEG
+    QTest::newRow("JPEG: beavis") << QString("beavis.jpg") << false;
+#endif
+#if defined QTEST_HAVE_GIF
+    QTest::newRow("GIF: earth") << QString("earth.gif") << true;
+    QTest::newRow("GIF: trolltech") << QString("trolltech.gif") << true;
+#endif
+#if defined QTEST_HAVE_MNG
+    QTest::newRow("MNG: ball") << QString("ball.mng") << true;
+    QTest::newRow("MNG: fire") << QString("fire.mng") << true;
+#endif
+#if defined QTEST_HAVE_SVG
+    QTest::newRow("SVG: rect") << QString("rect.svg") << false;
+    QTest::newRow("SVGZ: rect") << QString("rect.svgz") << false;
+#endif
+}
+
+void tst_QImageReader::supportsAnimation()
+{
+    QFETCH(QString, fileName);
+    QFETCH(bool, success);
+    QImageReader io(prefix + fileName);
+    QCOMPARE(io.supportsAnimation(), success);
+}
+
+void tst_QImageReader::sizeBeforeRead_data()
+{
+    imageFormat_data();
+}
+
+void tst_QImageReader::sizeBeforeRead()
+{
+    QFETCH(QString, fileName);
+    QFETCH(QByteArray, format);
+    QImageReader reader(prefix + fileName);
+    QVERIFY(reader.canRead());
+    if (format == "mng") {
+        QCOMPARE(reader.size(), QSize());
+        return;
+    }
+
+    QSize size = reader.size();
+    QVERIFY(reader.canRead());
+    QImage image = reader.read();
+    QVERIFY(!image.isNull());
+    QCOMPARE(size, image.size());
+}
+
+void tst_QImageReader::sizeBeforeFormat_data()
+{
+    imageFormat_data();
+}
+
+void tst_QImageReader::sizeBeforeFormat()
+{
+    QFETCH(QString, fileName);
+
+    QByteArray formatA, formatB;
+
+    {
+        QImageReader reader(prefix + fileName);
+        formatA = reader.format();
+    }
+
+    {
+        QImageReader reader(prefix + fileName);
+        QSize size = reader.size();
+        formatB = reader.format();
+    }
+
+    QCOMPARE(formatA, formatB);
+}
+
+void tst_QImageReader::imageFormatBeforeRead_data()
+{
+    imageFormat_data();
+}
+
+void tst_QImageReader::imageFormatBeforeRead()
+{
+    QFETCH(QString, fileName);
+    QFETCH(QImage::Format, imageFormat);
+    QImageReader reader(fileName);
+    if (reader.supportsOption(QImageIOHandler::ImageFormat)) {
+        QImage::Format fileFormat = reader.imageFormat();
+        QCOMPARE(fileFormat, imageFormat);
+        QSize size = reader.size();
+        QImage image(size, fileFormat);
+        QVERIFY(reader.read(&image));
+        QCOMPARE(image.format(), fileFormat);
+    }
+}
+
+#if defined QTEST_HAVE_GIF
+void tst_QImageReader::gifHandlerBugs()
+{
+    {
+        QImageReader io(prefix + "trolltech.gif");
+        QVERIFY(io.loopCount() != 1);
+        int count=0;
+        for (; io.canRead(); io.read(), ++count) ;
+        QVERIFY(count == 34);
+    }
+
+    // Task 95166
+    {
+        QImageReader io1(prefix + "bat1.gif");
+        QImageReader io2(prefix + "bat2.gif");
+        QVERIFY(io1.canRead());
+        QVERIFY(io2.canRead());
+        QImage im1 = io1.read();
+        QImage im2 = io2.read();
+        QVERIFY(!im1.isNull());
+        QVERIFY(!im2.isNull());
+        QCOMPARE(im1, im2);
+    }
+
+    // Task 9994
+    {
+        QImageReader io1(prefix + "noclearcode.gif");
+        QImageReader io2(prefix + "noclearcode.bmp");
+        QVERIFY(io1.canRead());  QVERIFY(io2.canRead());
+        QImage im1 = io1.read(); QImage im2 = io2.read();
+        QVERIFY(!im1.isNull());  QVERIFY(!im2.isNull());
+        QCOMPARE(im1.convertToFormat(QImage::Format_ARGB32), im2.convertToFormat(QImage::Format_ARGB32));
+    }
+
+    // Check the undocumented feature.
+    {
+        QImageReader io(prefix + "endless-anim.gif");
+        QVERIFY(io.canRead());
+        QCOMPARE(io.loopCount(), -1);
+    }
+}
+
+void tst_QImageReader::animatedGif()
+{
+    QImageReader io(":images/qt.gif");
+    QImage image = io.read();
+    QVERIFY(!image.isNull());
+    int i = 0;
+    while(!image.isNull()){
+        QString frameName = QString(":images/qt%1.gif").arg(++i);
+        QCOMPARE(image, QImage(frameName));
+        image = io.read();
+    }
+}
+
+// http://bugreports.qt.nokia.com/browse/QTBUG-6696
+// Check the count of images in various call orders...
+void tst_QImageReader::gifImageCount()
+{
+    // just read every frame... and see how much we got..
+    {
+        QImageReader io(":images/four-frames.gif");
+
+        QVERIFY(io.canRead());
+        QImage blackFrame = io.read();
+
+        QVERIFY(io.canRead());
+        QImage whiteFrame = io.read();
+
+        QVERIFY(io.canRead());
+        QImage greenFrame = io.read();
+
+        QVERIFY(io.imageCount() == 4);
+
+        QVERIFY(io.canRead());
+        QImage blueFrame = io.read();
+
+        QVERIFY(!io.canRead());
+        QImage emptyFrame = io.read();
+
+        QVERIFY(!io.canRead());
+        QCOMPARE(blackFrame.pixel(0,0), qRgb(0, 0, 0));
+        QCOMPARE(blackFrame.size(), QSize(64,64));
+
+        QCOMPARE(whiteFrame.pixel(0,0), qRgb(0xff, 0xff, 0xff));
+        QCOMPARE(whiteFrame.size(), QSize(64,64));
+
+        QCOMPARE(greenFrame.pixel(0,0), qRgb(0x0, 0xff, 0x0));
+        QCOMPARE(greenFrame.size(), QSize(64,64));
+
+        QCOMPARE(blueFrame.pixel(0,0), qRgb(0x0, 0x0, 0xff));
+        QCOMPARE(blueFrame.size(), QSize(64,64));
+        QVERIFY(emptyFrame.isNull());
+    }
+
+    // Read and get the size
+    {
+        QImageReader io(":images/four-frames.gif");
+
+        QVERIFY(io.canRead());
+        QCOMPARE(io.size(), QSize(64,64));
+
+        QVERIFY(io.canRead());
+        QCOMPARE(io.size(), QSize(64,64));
+        QCOMPARE(io.size(), QSize(64,64));
+        QVERIFY(io.canRead());
+        QImage blackFrame = io.read();
+
+        QVERIFY(io.canRead());
+        QCOMPARE(io.size(), QSize(64,64));
+        QCOMPARE(io.size(), QSize(64,64));
+        QVERIFY(io.canRead());
+        QImage whiteFrame = io.read();
+
+        QVERIFY(io.canRead());
+        QCOMPARE(io.size(), QSize(64,64));
+        QCOMPARE(io.size(), QSize(64,64));
+        QVERIFY(io.canRead());
+        QImage greenFrame = io.read();
+
+        QVERIFY(io.canRead());
+        QCOMPARE(io.size(), QSize(64,64));
+        QCOMPARE(io.size(), QSize(64,64));
+        QVERIFY(io.canRead());
+        QImage blueFrame = io.read();
+
+        QVERIFY(!io.canRead());
+        QCOMPARE(io.size(), QSize());
+        QCOMPARE(io.size(), QSize());
+        QVERIFY(!io.canRead());
+        QImage emptyFrame = io.read();
+
+        QVERIFY(!io.canRead());
+        QCOMPARE(blackFrame.pixel(0,0), qRgb(0, 0, 0));
+        QCOMPARE(blackFrame.size(), QSize(64,64));
+
+        QCOMPARE(whiteFrame.pixel(0,0), qRgb(0xff, 0xff, 0xff));
+        QCOMPARE(whiteFrame.size(), QSize(64,64));
+
+        QCOMPARE(greenFrame.pixel(0,0), qRgb(0x0, 0xff, 0x0));
+        QCOMPARE(greenFrame.size(), QSize(64,64));
+
+        QCOMPARE(blueFrame.pixel(0,0), qRgb(0x0, 0x0, 0xff));
+        QCOMPARE(blueFrame.size(), QSize(64,64));
+        QVERIFY(emptyFrame.isNull());
+    }
+
+    // Do a Size query as substitute for canRead
+    {
+        QImageReader io(":images/four-frames.gif");
+
+        QCOMPARE(io.size(), QSize(64,64));
+        QCOMPARE(io.size(), QSize(64,64));
+        QImage blackFrame = io.read();
+
+        QCOMPARE(io.size(), QSize(64,64));
+        QCOMPARE(io.size(), QSize(64,64));
+        QImage whiteFrame = io.read();
+
+        QCOMPARE(io.size(), QSize(64,64));
+        QCOMPARE(io.size(), QSize(64,64));
+        QImage greenFrame = io.read();
+
+        QCOMPARE(io.size(), QSize(64,64));
+        QCOMPARE(io.size(), QSize(64,64));
+        QImage blueFrame = io.read();
+
+        QCOMPARE(io.size(), QSize());
+        QVERIFY(!io.canRead());
+        QImage emptyFrame = io.read();
+
+        QVERIFY(!io.canRead());
+        QCOMPARE(blackFrame.pixel(0,0), qRgb(0, 0, 0));
+        QCOMPARE(blackFrame.size(), QSize(64,64));
+
+        QCOMPARE(whiteFrame.pixel(0,0), qRgb(0xff, 0xff, 0xff));
+        QCOMPARE(whiteFrame.size(), QSize(64,64));
+
+        QCOMPARE(greenFrame.pixel(0,0), qRgb(0x0, 0xff, 0x0));
+        QCOMPARE(greenFrame.size(), QSize(64,64));
+
+        QCOMPARE(blueFrame.pixel(0,0), qRgb(0x0, 0x0, 0xff));
+        QCOMPARE(blueFrame.size(), QSize(64,64));
+        QVERIFY(emptyFrame.isNull());
+    }
+    {
+        QImageReader io(":images/trolltech.gif");
+        QVERIFY(io.imageCount() == 34);
+        QVERIFY(io.size() == QSize(128,64));
+    }
+}
+
+void tst_QImageReader::gifLoopCount()
+{
+    {
+        QImageReader io(":images/qt-gif-anim.gif");
+        QCOMPARE(io.loopCount(), -1); // infinite loop
+    }
+    {
+        QImageReader io(":images/qt-gif-noanim.gif");
+        QCOMPARE(io.loopCount(), 0); // no loop
+    }
+}
+
+#endif
+
+class Server : public QObject
+{
+    Q_OBJECT
+public:
+    Server(const QByteArray &data) :serverSocket(0)
+    {
+        connect(&server, SIGNAL(newConnection()), this, SLOT(acceptNewConnection()));
+        server.listen();
+        this->data = data;
+    }
+
+public slots:
+    void runTest()
+    {
+        connect(&clientSocket, SIGNAL(connected()), this, SLOT(connected()));
+        clientSocket.connectToHost(QHostAddress::LocalHost, server.serverPort());
+    }
+
+public:
+    inline QTcpSocket *socket() const { return serverSocket; }
+
+signals:
+    void ready();
+
+private slots:
+    void acceptNewConnection()
+    {
+        serverSocket = server.nextPendingConnection();
+        connect(serverSocket, SIGNAL(error(QAbstractSocket::SocketError)),
+                this, SLOT(remoteHostClosed()));
+    }
+
+    void connected()
+    {
+        clientSocket.write(data);
+        clientSocket.disconnectFromHost();
+    }
+
+    void remoteHostClosed()
+    {
+        emit ready();
+    }
+
+private:
+    QTcpServer server;
+    QTcpSocket clientSocket;
+    QTcpSocket *serverSocket;
+    QByteArray data;
+};
+
+void tst_QImageReader::readFromDevice_data()
+{
+    QTest::addColumn<QString>("fileName");
+    QTest::addColumn<QByteArray>("format");
+
+    QTest::newRow("pbm") << QString("image.pbm") << QByteArray("pbm");
+    QTest::newRow("pgm") << QString("image.pgm") << QByteArray("pgm");
+    QTest::newRow("ppm-1") << QString("image.ppm") << QByteArray("ppm");
+    QTest::newRow("ppm-2") << QString("teapot.ppm") << QByteArray("ppm");
+    QTest::newRow("ppm-3") << QString("teapot.ppm") << QByteArray("ppm");
+    QTest::newRow("ppm-4") << QString("runners.ppm") << QByteArray("ppm");
+#ifdef QTEST_HAVE_JPEG
+    QTest::newRow("jpeg-1") << QString("beavis.jpg") << QByteArray("jpeg");
+    QTest::newRow("jpeg-2") << QString("YCbCr_cmyk.jpg") << QByteArray("jpeg");
+    QTest::newRow("jpeg-3") << QString("YCbCr_rgb.jpg") << QByteArray("jpeg");
+    QTest::newRow("jpeg-4") << QString("qtbug13653-no_eoi.jpg") << QByteArray("jpeg");
+#endif // QTEST_HAVE_JPEG
+#ifdef QTEST_HAVE_GIF
+    QTest::newRow("gif-1") << QString("earth.gif") << QByteArray("gif");
+    QTest::newRow("gif-2") << QString("trolltech.gif") << QByteArray("gif");
+#endif // QTEST_HAVE_GIF
+    QTest::newRow("xbm") << QString("gnus.xbm") << QByteArray("xbm");
+    QTest::newRow("xpm") << QString("marble.xpm") << QByteArray("xpm");
+    QTest::newRow("bmp-1") << QString("colorful.bmp") << QByteArray("bmp");
+    QTest::newRow("bmp-2") << QString("font.bmp") << QByteArray("bmp");
+    QTest::newRow("png") << QString("kollada.png") << QByteArray("png");
+#ifdef QTEST_HAVE_MNG
+    QTest::newRow("mng-1") << QString("ball.mng") << QByteArray("mng");
+    QTest::newRow("mng-2") << QString("fire.mng") << QByteArray("mng");
+#endif // QTEST_HAVE_MNG
+#if defined QTEST_HAVE_SVG
+    QTest::newRow("svg") << QString("rect.svg") << QByteArray("svg");
+    QTest::newRow("svgz") << QString("rect.svgz") << QByteArray("svgz");
+#endif
+}
+
+void tst_QImageReader::readFromDevice()
+{
+    QFETCH(QString, fileName);
+    QFETCH(QByteArray, format);
+
+    QImage expectedImage(prefix + fileName, format);
+
+    QFile file(prefix + fileName);
+    QVERIFY(file.open(QFile::ReadOnly));
+    QByteArray imageData = file.readAll();
+    QVERIFY(!imageData.isEmpty());
+    {
+        QBuffer buffer;
+        buffer.setData(imageData);
+        QVERIFY(buffer.open(QBuffer::ReadOnly));
+
+        QImageReader reader(&buffer);
+        QVERIFY(reader.canRead());
+        QImage imageReaderImage = reader.read();
+
+        QCOMPARE(imageReaderImage, expectedImage);
+
+        buffer.seek(0);
+
+        QImage image1;
+        QVERIFY(image1.loadFromData((const uchar *)buffer.data().data(),
+                                    buffer.data().size(), format.data()));
+        QCOMPARE(image1, expectedImage);
+
+        QByteArray throughBase64 = QByteArray::fromBase64(imageData.toBase64());
+        QVERIFY(image1.loadFromData((const uchar *)throughBase64.data(),
+                                    throughBase64.size(), format.data()));
+        QCOMPARE(image1, expectedImage);
+    }
+
+#if defined (Q_OS_SYMBIAN) && defined (__WINS__)
+    //the emulator hangs in socket write (this is a test bug, it assumes the TCP stack can accept a whole image to its buffers)
+    if(imageData.size() > 16384)
+        QSKIP("image larger than socket buffer (test needs to be rewritten)", SkipSingle);
+#endif
+    Server server(imageData);
+    QEventLoop loop;
+    connect(&server, SIGNAL(ready()), &loop, SLOT(quit()));
+    QTimer::singleShot(0, &server, SLOT(runTest()));
+    QTimer::singleShot(5000, &loop, SLOT(quit()));
+    loop.exec();
+
+    QImageReader reader(server.socket(), format == "xbm" ? "xbm" : "");
+    if (format == "xbm")
+        QVERIFY(!reader.canRead());
+    else
+        QVERIFY(reader.canRead());
+    QImage imageReaderImage = reader.read();
+    QCOMPARE(imageReaderImage, expectedImage);
+}
+
+void tst_QImageReader::readFromFileAfterJunk_data()
+{
+    QTest::addColumn<QString>("fileName");
+    QTest::addColumn<QByteArray>("format");
+
+    QTest::newRow("pbm") << QString("image.pbm") << QByteArray("pbm");
+    QTest::newRow("pgm") << QString("image.pgm") << QByteArray("pgm");
+    QTest::newRow("ppm-1") << QString("image.ppm") << QByteArray("ppm");
+    QTest::newRow("ppm-2") << QString("teapot.ppm") << QByteArray("ppm");
+    QTest::newRow("ppm-3") << QString("teapot.ppm") << QByteArray("ppm");
+    QTest::newRow("ppm-4") << QString("runners.ppm") << QByteArray("ppm");
+#ifdef QTEST_HAVE_JPEG
+    QTest::newRow("jpeg-1") << QString("beavis.jpg") << QByteArray("jpeg");
+    QTest::newRow("jpeg-2") << QString("YCbCr_cmyk.jpg") << QByteArray("jpeg");
+    QTest::newRow("jpeg-3") << QString("YCbCr_rgb.jpg") << QByteArray("jpeg");
+#endif
+#if defined QTEST_HAVE_GIF
+//    QTest::newRow("gif-1") << QString("images/earth.gif") << QByteArray("gif");
+//    QTest::newRow("gif-2") << QString("images/trolltech.gif") << QByteArray("gif");
+#endif
+    QTest::newRow("xbm") << QString("gnus.xbm") << QByteArray("xbm");
+    QTest::newRow("xpm") << QString("marble.xpm") << QByteArray("xpm");
+    QTest::newRow("bmp-1") << QString("colorful.bmp") << QByteArray("bmp");
+    QTest::newRow("bmp-2") << QString("font.bmp") << QByteArray("bmp");
+    QTest::newRow("png") << QString("kollada.png") << QByteArray("png");
+//    QTest::newRow("mng-1") << QString("images/ball.mng") << QByteArray("mng");
+//    QTest::newRow("mng-2") << QString("images/fire.mng") << QByteArray("mng");
+#if defined QTEST_HAVE_SVG
+    QTest::newRow("svg") << QString("rect.svg") << QByteArray("svg");
+    QTest::newRow("svgz") << QString("rect.svgz") << QByteArray("svgz");
+#endif
+}
+
+void tst_QImageReader::readFromFileAfterJunk()
+{
+    QFETCH(QString, fileName);
+    QFETCH(QByteArray, format);
+
+    if (!QImageReader::supportedImageFormats().contains(format)) {
+        QString cause = QString("Skipping %1; no %2 support").arg(fileName).arg(QString(format));
+        QSKIP(qPrintable(cause), SkipSingle);
+    }
+
+    QFile::remove("junk");
+    QFile junkFile("junk");
+    QVERIFY(junkFile.open(QFile::WriteOnly));
+
+    QFile imageFile(prefix + fileName);
+    QVERIFY(imageFile.open(QFile::ReadOnly));
+    QByteArray imageData = imageFile.readAll();
+    QVERIFY(!imageData.isNull());
+
+    int iterations = 3;
+    if (format == "ppm" || format == "pbm" || format == "pgm" || format == "svg" || format == "svgz")
+        iterations = 1;
+
+    if (format == "mng" || !QImageWriter::supportedImageFormats().contains(format)) {
+        for (int i = 0; i < iterations; ++i) {
+            junkFile.write("deadbeef", 9);
+            QCOMPARE(junkFile.write(imageData), qint64(imageData.size()));
+        }
+    } else {
+        for (int i = 0; i < iterations; ++i) {
+            QImageWriter writer(&junkFile, format);
+            junkFile.write("deadbeef", 9);
+            QVERIFY(writer.write(QImage(prefix + fileName)));
+        }
+    }
+    junkFile.close();
+    junkFile.open(QFile::ReadOnly);
+
+    for (int i = 0; i < iterations; ++i) {
+        QByteArray ole = junkFile.read(9);
+        junkFile.ungetChar(ole[ole.size() - 1]);
+        char c;
+        junkFile.getChar(&c);
+        QImageReader reader(&junkFile);
+        QVERIFY(reader.canRead());
+        QVERIFY(!reader.read().isNull());
+    }
+}
+
+void tst_QImageReader::devicePosition_data()
+{
+    QTest::addColumn<QString>("fileName");
+    QTest::addColumn<QByteArray>("format");
+
+    QTest::newRow("pbm") << QString("image.pbm") << QByteArray("pbm");
+    QTest::newRow("pgm") << QString("image.pgm") << QByteArray("pgm");
+    QTest::newRow("ppm-1") << QString("image.ppm") << QByteArray("ppm");
+#ifdef QTEST_HAVE_JPEG
+    QTest::newRow("jpeg-1") << QString("beavis.jpg") << QByteArray("jpeg");
+    QTest::newRow("jpeg-2") << QString("YCbCr_cmyk.jpg") << QByteArray("jpeg");
+    QTest::newRow("jpeg-3") << QString("YCbCr_rgb.jpg") << QByteArray("jpeg");
+#endif
+#if defined QTEST_HAVE_GIF
+    QTest::newRow("gif-1") << QString("earth.gif") << QByteArray("gif");
+#endif
+    QTest::newRow("xbm") << QString("gnus.xbm") << QByteArray("xbm");
+    QTest::newRow("xpm") << QString("marble.xpm") << QByteArray("xpm");
+    QTest::newRow("bmp-1") << QString("colorful.bmp") << QByteArray("bmp");
+    QTest::newRow("bmp-2") << QString("font.bmp") << QByteArray("bmp");
+    QTest::newRow("png") << QString("kollada.png") << QByteArray("png");
+//    QTest::newRow("mng-1") << QString("images/ball.mng") << QByteArray("mng");
+//    QTest::newRow("mng-2") << QString("images/fire.mng") << QByteArray("mng");
+#if defined QTEST_HAVE_SVG
+    QTest::newRow("svg") << QString("rect.svg") << QByteArray("svg");
+    QTest::newRow("svgz") << QString("rect.svgz") << QByteArray("svgz");
+#endif
+}
+
+void tst_QImageReader::devicePosition()
+{
+    QFETCH(QString, fileName);
+    QFETCH(QByteArray, format);
+
+    QImage expected(prefix + fileName);
+    QVERIFY(!expected.isNull());
+
+    QFile imageFile(prefix + fileName);
+    QVERIFY(imageFile.open(QFile::ReadOnly));
+    QByteArray imageData = imageFile.readAll();
+    QVERIFY(!imageData.isNull());
+    int imageDataSize = imageData.size();
+
+    const char *preStr = "prebeef\n";
+    int preLen = qstrlen(preStr);
+    imageData.prepend(preStr);
+    if (format != "svg" && format != "svgz") // Doesn't handle trailing data
+        imageData.append("\npostbeef");
+    QBuffer buf(&imageData);
+    buf.open(QIODevice::ReadOnly);
+    buf.seek(preLen);
+    QImageReader reader(&buf, format);
+    QCOMPARE(expected, reader.read());
+    if (format != "ppm" &&
+        format != "pgm" &&
+        format != "pbm" &&
+        format != "gif")  // Known not to work
+        QCOMPARE(buf.pos(), qint64(preLen+imageDataSize));
+}
+
+
+void tst_QImageReader::readFromResources_data()
+{
+    QTest::addColumn<QString>("fileName");
+    QTest::addColumn<QByteArray>("format");
+    QTest::addColumn<QSize>("size");
+    QTest::addColumn<QString>("message");
+
+    QTest::newRow("corrupt.bmp") << QString("corrupt.bmp")
+                                        << QByteArray("bmp") << QSize(0, 0)
+                                        << QString("");
+    QTest::newRow("negativeheight.bmp") << QString("negativeheight.bmp")
+                                               << QByteArray("bmp") << QSize(127, 64)
+                                               << QString("");
+    QTest::newRow("font.bmp") << QString("font.bmp")
+                                     << QByteArray("bmp") << QSize(240, 8)
+                                     << QString("");
+    QTest::newRow("noclearcode.bmp") << QString("noclearcode.bmp")
+                                            << QByteArray("bmp") << QSize(29, 18)
+                                            << QString("");
+    QTest::newRow("colorful.bmp") << QString("colorful.bmp")
+                                         << QByteArray("bmp") << QSize(320, 200)
+                                         << QString("");
+    QTest::newRow("16bpp.bmp") << QString("16bpp.bmp")
+                                      << QByteArray("bmp") << QSize(320, 240)
+                                      << QString("");
+    QTest::newRow("crash-signed-char.bmp") << QString("crash-signed-char.bmp")
+                                                  << QByteArray("bmp") << QSize(360, 280)
+                                                  << QString("");
+    QTest::newRow("4bpp-rle.bmp") << QString("4bpp-rle.bmp")
+                                         << QByteArray("bmp") << QSize(640, 480)
+                                         << QString("");
+#ifdef QTEST_HAVE_GIF
+    QTest::newRow("corrupt.gif") << QString("corrupt.gif")
+                                        << QByteArray("gif") << QSize(0, 0)
+                                        << QString("");
+    QTest::newRow("trolltech.gif") << QString("trolltech.gif")
+                                          << QByteArray("gif") << QSize(128, 64)
+                                          << QString("");
+    QTest::newRow("noclearcode.gif") << QString("noclearcode.gif")
+                                            << QByteArray("gif") << QSize(29, 18)
+                                            << QString("");
+    QTest::newRow("earth.gif") << QString("earth.gif")
+                                      << QByteArray("gif") << QSize(320, 200)
+                                      << QString("");
+    QTest::newRow("bat1.gif") << QString("bat1.gif")
+                                     << QByteArray("gif") << QSize(32, 32)
+                                     << QString("");
+    QTest::newRow("bat2.gif") << QString("bat2.gif")
+                                     << QByteArray("gif") << QSize(32, 32)
+                                     << QString("");
+#endif
+#ifdef QTEST_HAVE_JPEG
+    QTest::newRow("corrupt.jpg") << QString("corrupt.jpg")
+                                        << QByteArray("jpg") << QSize(0, 0)
+                                        << QString("JPEG datastream contains no image");
+    QTest::newRow("beavis.jpg") << QString("beavis.jpg")
+                                       << QByteArray("jpg") << QSize(350, 350)
+                                       << QString("");
+    QTest::newRow("YCbCr_cmyk.jpg") << QString("YCbCr_cmyk.jpg")
+                                           << QByteArray("jpg") << QSize(75, 50)
+                                           << QString("");
+    QTest::newRow("YCbCr_rgb.jpg") << QString("YCbCr_rgb.jpg")
+                                          << QByteArray("jpg") << QSize(75, 50)
+                                          << QString("");
+    QTest::newRow("qtbug13653-no_eoi.jpg") << QString("qtbug13653-no_eoi.jpg")
+                                        << QByteArray("jpg") << QSize(240, 180)
+                                        << QString("");
+#endif
+#ifdef QTEST_HAVE_MNG
+    QTest::newRow("corrupt.mng") << QString("corrupt.mng")
+                                        << QByteArray("mng") << QSize(0, 0)
+                                        << QString("MNG error 901: Application signalled I/O error; chunk IHDR; subcode 0:0");
+    QTest::newRow("fire.mng") << QString("fire.mng")
+                                     << QByteArray("mng") << QSize(30, 60)
+                                     << QString("");
+    QTest::newRow("ball.mng") << QString("ball.mng")
+                                     << QByteArray("mng") << QSize(32, 32)
+                                     << QString("");
+#endif
+#ifdef QTEST_HAVE_SVG
+    QTest::newRow("rect.svg") << QString("rect.svg")
+                                     << QByteArray("svg") << QSize(105, 137)
+                                     << QString("");
+    QTest::newRow("rect.svgz") << QString("rect.svgz")
+                                     << QByteArray("svgz") << QSize(105, 137)
+                                     << QString("");
+    QTest::newRow("corrupt.svg") << QString("corrupt.svg")
+                                     << QByteArray("svg") << QSize(0, 0)
+                                     << QString("");
+    QTest::newRow("corrupt.svgz") << QString("corrupt.svgz")
+                                     << QByteArray("svgz") << QSize(0, 0)
+                                     << QString("");
+#endif
+    QTest::newRow("image.pbm") << QString("image.pbm")
+                                      << QByteArray("pbm") << QSize(16, 6)
+                                      << QString("");
+    QTest::newRow("image.pgm") << QString("image.pgm")
+                                      << QByteArray("pgm") << QSize(24, 7)
+                                      << QString("");
+    QTest::newRow("corrupt.png") << QString("corrupt.png")
+                                        << QByteArray("png") << QSize(0, 0)
+                                        << QString("");
+    QTest::newRow("away.png") << QString("away.png")
+                                     << QByteArray("png") << QSize(16, 16)
+                                     << QString("");
+    QTest::newRow("image.png") << QString("image.png")
+                                      << QByteArray("png") << QSize(22, 22)
+                                      << QString("");
+    QTest::newRow("kollada.png") << QString("kollada.png")
+                                        << QByteArray("png") << QSize(436, 160)
+                                        << QString("");
+    QTest::newRow("black.png") << QString("black.png")
+                                      << QByteArray("png") << QSize(48, 48)
+                                      << QString("");
+    QTest::newRow("YCbCr_cmyk.png") << QString("YCbCr_cmyk.png")
+                                           << QByteArray("png") << QSize(75, 50)
+                                           << QString("");
+    QTest::newRow("teapot.ppm") << QString("teapot.ppm")
+                                       << QByteArray("ppm") << QSize(256, 256)
+                                       << QString("");
+    QTest::newRow("image.ppm") << QString("image.ppm")
+                                      << QByteArray("ppm") << QSize(4, 4)
+                                      << QString("");
+    QTest::newRow("runners.ppm") << QString("runners.ppm")
+                                        << QByteArray("ppm") << QSize(400, 400)
+                                        << QString("");
+    QTest::newRow("test.ppm") << QString("test.ppm")
+                                     << QByteArray("ppm") << QSize(10, 10)
+                                     << QString("");
+//    QTest::newRow("corrupt.xbm") << QString("corrupt.xbm") << QByteArray("xbm") << QSize(0, 0);
+    QTest::newRow("gnus.xbm") << QString("gnus.xbm")
+                                     << QByteArray("xbm") << QSize(271, 273)
+                                     << QString("");
+    QTest::newRow("corrupt-colors.xpm") << QString("corrupt-colors.xpm")
+                                               << QByteArray("xpm") << QSize(0, 0)
+                                               << QString("QImage: XPM color specification is missing: bla9an.n#x");
+    QTest::newRow("corrupt-pixels.xpm") << QString("corrupt-pixels.xpm")
+                                               << QByteArray("xpm") << QSize(0, 0)
+                                               << QString("QImage: XPM pixels missing on image line 3");
+    QTest::newRow("corrupt-pixel-count.xpm") << QString("corrupt-pixel-count.xpm")
+                                             << QByteArray("xpm") << QSize(0, 0)
+                                             << QString("");
+    QTest::newRow("marble.xpm") << QString("marble.xpm")
+                                       << QByteArray("xpm") << QSize(240, 240)
+                                       << QString("");
+    QTest::newRow("test.xpm") << QString("test.xpm")
+                                     << QByteArray("xpm") << QSize(256, 256)
+                                     << QString("");
+    QTest::newRow("black.xpm") << QString("black.xpm")
+                                      << QByteArray("xpm") << QSize(48, 48)
+                                      << QString("");
+    QTest::newRow("namedcolors.xpm") << QString("namedcolors.xpm")
+                                            << QByteArray("xpm") << QSize(8, 8)
+                                            << QString("");
+    QTest::newRow("nontransparent.xpm") << QString("nontransparent.xpm")
+                                               << QByteArray("xpm") << QSize(8, 8)
+                                               << QString("");
+    QTest::newRow("transparent.xpm") << QString("transparent.xpm")
+                                            << QByteArray("xpm") << QSize(8, 8)
+                                            << QString("");
+}
+
+void tst_QImageReader::readFromResources()
+{
+    QFETCH(QString, fileName);
+    QFETCH(QByteArray, format);
+    QFETCH(QSize, size);
+    QFETCH(QString, message);
+    for (int i = 0; i < 2; ++i) {
+        QString file = i ? (":/images/" + fileName) : (prefix + fileName);
+        {
+            // suppress warnings if we expect them
+            if (!message.isEmpty()) {
+                for (int j = 0; j < 5; ++j)
+                    QTest::ignoreMessage(QtWarningMsg, message.toLatin1());
+            }
+
+            // 1) full filename, no format
+            QImageReader reader(file);
+            QImage image = reader.read();
+            if (size.isNull())
+                QVERIFY(image.isNull());
+            else
+                QVERIFY(!image.isNull());
+            QCOMPARE(image.size(), size);
+        }
+        {
+            // 2) full filename, with format
+            QImageReader reader(file, format);
+            QImage image = reader.read();
+            if (size.isNull())
+                QVERIFY(image.isNull());
+            else
+                QVERIFY(!image.isNull());
+            QCOMPARE(image.size(), size);
+        }
+        {
+            // 3) full filename, with uppercase format
+            QImageReader reader(file, format.toUpper());
+            QImage image = reader.read();
+            if (size.isNull())
+                QVERIFY(image.isNull());
+            else
+                QVERIFY(!image.isNull());
+            QCOMPARE(image.size(), size);
+        }
+        {
+            // 4) chopped filename, with format
+            QImageReader reader(file.left(file.lastIndexOf(QLatin1Char('.'))), format);
+            QImage image = reader.read();
+            if (size.isNull())
+                QVERIFY(image.isNull());
+            else
+                QVERIFY(!image.isNull());
+            QCOMPARE(image.size(), size);
+        }
+        {
+            // 5) chopped filename, with uppercase format
+            QImageReader reader(file.left(file.lastIndexOf(QLatin1Char('.'))), format.toUpper());
+            QImage image = reader.read();
+            if (size.isNull())
+                QVERIFY(image.isNull());
+            else
+                QVERIFY(!image.isNull());
+            QCOMPARE(image.size(), size);
+        }
+    }
+
+    // Check that the results are identical
+    if (!message.isEmpty()) {
+        QTest::ignoreMessage(QtWarningMsg, message.toLatin1());
+        QTest::ignoreMessage(QtWarningMsg, message.toLatin1());
+    }
+    QCOMPARE(QImageReader(prefix + fileName).read(), QImageReader(":/images/" + fileName).read());
+}
+
+void tst_QImageReader::readCorruptImage_data()
+{
+    QTest::addColumn<QString>("fileName");
+    QTest::addColumn<bool>("shouldFail");
+    QTest::addColumn<QString>("message");
+#if defined QTEST_HAVE_JPEG
+    QTest::newRow("corrupt jpeg") << QString("corrupt.jpg") << true
+                                  << QString("JPEG datastream contains no image");
+#endif
+#if defined QTEST_HAVE_GIF
+    QTest::newRow("corrupt gif") << QString("corrupt.gif") << true << QString("");
+#endif
+#ifdef QTEST_HAVE_MNG
+    QTest::newRow("corrupt mng") << QString("corrupt.mng") << true
+                                 << QString("MNG error 901: Application signalled I/O error; chunk IHDR; subcode 0:0");
+#endif
+    QTest::newRow("corrupt png") << QString("corrupt.png") << true << QString("");
+    QTest::newRow("corrupt bmp") << QString("corrupt.bmp") << true << QString("");
+    QTest::newRow("corrupt xpm (colors)") << QString("corrupt-colors.xpm") << true
+                                          << QString("QImage: XPM color specification is missing: bla9an.n#x");
+    QTest::newRow("corrupt xpm (pixels)") << QString("corrupt-pixels.xpm") << true
+                                          << QString("QImage: XPM pixels missing on image line 3");
+    QTest::newRow("corrupt xbm") << QString("corrupt.xbm") << false << QString("");
+#if defined QTEST_HAVE_TIFF
+    QTest::newRow("corrupt tiff") << QString("corrupt-data.tif") << true << QString("");
+#endif
+#if defined QTEST_HAVE_SVG
+    QTest::newRow("corrupt svg") << QString("corrupt.svg") << true << QString("");
+    QTest::newRow("corrupt svgz") << QString("corrupt.svgz") << true << QString("");
+#endif
+}
+
+void tst_QImageReader::readCorruptImage()
+{
+    QFETCH(QString, fileName);
+    QFETCH(bool, shouldFail);
+    QFETCH(QString, message);
+
+    if (!message.isEmpty())
+        QTest::ignoreMessage(QtWarningMsg, message.toLatin1());
+    QImageReader reader(prefix + fileName);
+    QVERIFY(reader.canRead());
+    QCOMPARE(reader.read().isNull(), shouldFail);
+}
+
+void tst_QImageReader::readCorruptBmp()
+{
+    QCOMPARE(QImage(prefix + "tst7.bmp").convertToFormat(QImage::Format_ARGB32_Premultiplied), QImage(prefix + "tst7.png").convertToFormat(QImage::Format_ARGB32_Premultiplied));
+}
+
+void tst_QImageReader::supportsOption_data()
+{
+    QTest::addColumn<QString>("fileName");
+    QTest::addColumn<QIntList>("options");
+
+    QTest::newRow("png") << QString("black.png")
+                         << (QIntList() << QImageIOHandler::Gamma
+                              << QImageIOHandler::Description
+                              << QImageIOHandler::Quality
+                              << QImageIOHandler::Size);
+}
+
+void tst_QImageReader::supportsOption()
+{
+    QFETCH(QString, fileName);
+    QFETCH(QIntList, options);
+
+    QSet<QImageIOHandler::ImageOption> allOptions;
+    allOptions << QImageIOHandler::Size
+               << QImageIOHandler::ClipRect
+               << QImageIOHandler::Description
+               << QImageIOHandler::ScaledClipRect
+               << QImageIOHandler::ScaledSize
+               << QImageIOHandler::CompressionRatio
+               << QImageIOHandler::Gamma
+               << QImageIOHandler::Quality
+               << QImageIOHandler::Name
+               << QImageIOHandler::SubType
+               << QImageIOHandler::IncrementalReading
+               << QImageIOHandler::Endianness
+               << QImageIOHandler::Animation
+               << QImageIOHandler::BackgroundColor;
+
+    QImageReader reader(prefix + fileName);
+    for (int i = 0; i < options.size(); ++i) {
+        QVERIFY(reader.supportsOption(QImageIOHandler::ImageOption(options.at(i))));
+        allOptions.remove(QImageIOHandler::ImageOption(options.at(i)));
+    }
+
+    foreach (QImageIOHandler::ImageOption option, allOptions)
+        QVERIFY(!reader.supportsOption(option));
+}
+
+#if defined QTEST_HAVE_TIFF
+void tst_QImageReader::tiffCompression_data()
+{
+    QTest::addColumn<QString>("uncompressedFile");
+    QTest::addColumn<QString>("compressedFile");
+
+    QTest::newRow("TIFF: adobedeflate") << "rgba_nocompression_littleendian.tif"
+                                        << "rgba_adobedeflate_littleendian.tif";
+    QTest::newRow("TIFF: lzw") << "rgba_nocompression_littleendian.tif"
+                               << "rgba_lzw_littleendian.tif";
+    QTest::newRow("TIFF: packbits") << "rgba_nocompression_littleendian.tif"
+                                    << "rgba_packbits_littleendian.tif";
+    QTest::newRow("TIFF: zipdeflate") << "rgba_nocompression_littleendian.tif"
+                                      << "rgba_zipdeflate_littleendian.tif";
+}
+
+void tst_QImageReader::tiffCompression()
+{
+    QFETCH(QString, uncompressedFile);
+    QFETCH(QString, compressedFile);
+
+    QImage uncompressedImage(prefix + uncompressedFile);
+    QImage compressedImage(prefix + compressedFile);
+
+    QCOMPARE(uncompressedImage, compressedImage);
+}
+
+void tst_QImageReader::tiffEndianness()
+{
+    QImage littleEndian(prefix + "rgba_nocompression_littleendian.tif");
+    QImage bigEndian(prefix + "rgba_nocompression_bigendian.tif");
+
+    QCOMPARE(littleEndian, bigEndian);
+}
+
+void tst_QImageReader::tiffOrientation_data()
+{
+    QTest::addColumn<QString>("expected");
+    QTest::addColumn<QString>("oriented");
+    QTest::newRow("Indexed TIFF, orientation1") << "tiff_oriented/original_indexed.tiff" << "tiff_oriented/indexed_orientation_1.tiff";
+    QTest::newRow("Indexed TIFF, orientation2") << "tiff_oriented/original_indexed.tiff" << "tiff_oriented/indexed_orientation_2.tiff";
+    QTest::newRow("Indexed TIFF, orientation3") << "tiff_oriented/original_indexed.tiff" << "tiff_oriented/indexed_orientation_3.tiff";
+    QTest::newRow("Indexed TIFF, orientation4") << "tiff_oriented/original_indexed.tiff" << "tiff_oriented/indexed_orientation_4.tiff";
+    QTest::newRow("Indexed TIFF, orientation5") << "tiff_oriented/original_indexed.tiff" << "tiff_oriented/indexed_orientation_5.tiff";
+    QTest::newRow("Indexed TIFF, orientation6") << "tiff_oriented/original_indexed.tiff" << "tiff_oriented/indexed_orientation_6.tiff";
+    QTest::newRow("Indexed TIFF, orientation7") << "tiff_oriented/original_indexed.tiff" << "tiff_oriented/indexed_orientation_7.tiff";
+    QTest::newRow("Indexed TIFF, orientation8") << "tiff_oriented/original_indexed.tiff" << "tiff_oriented/indexed_orientation_8.tiff";
+
+    QTest::newRow("Mono TIFF, orientation1") << "tiff_oriented/original_mono.tiff" << "tiff_oriented/mono_orientation_1.tiff";
+    QTest::newRow("Mono TIFF, orientation2") << "tiff_oriented/original_mono.tiff" << "tiff_oriented/mono_orientation_2.tiff";
+    QTest::newRow("Mono TIFF, orientation3") << "tiff_oriented/original_mono.tiff" << "tiff_oriented/mono_orientation_3.tiff";
+    QTest::newRow("Mono TIFF, orientation4") << "tiff_oriented/original_mono.tiff" << "tiff_oriented/mono_orientation_4.tiff";
+    QTest::newRow("Mono TIFF, orientation5") << "tiff_oriented/original_mono.tiff" << "tiff_oriented/mono_orientation_5.tiff";
+    QTest::newRow("Mono TIFF, orientation6") << "tiff_oriented/original_mono.tiff" << "tiff_oriented/mono_orientation_6.tiff";
+    QTest::newRow("Mono TIFF, orientation7") << "tiff_oriented/original_mono.tiff" << "tiff_oriented/mono_orientation_7.tiff";
+    QTest::newRow("Mono TIFF, orientation8") << "tiff_oriented/original_mono.tiff" << "tiff_oriented/mono_orientation_8.tiff";
+
+    QTest::newRow("RGB TIFF, orientation1") << "tiff_oriented/original_rgb.tiff" << "tiff_oriented/rgb_orientation_1.tiff";
+    QTest::newRow("RGB TIFF, orientation2") << "tiff_oriented/original_rgb.tiff" << "tiff_oriented/rgb_orientation_2.tiff";
+    QTest::newRow("RGB TIFF, orientation3") << "tiff_oriented/original_rgb.tiff" << "tiff_oriented/rgb_orientation_3.tiff";
+    QTest::newRow("RGB TIFF, orientation4") << "tiff_oriented/original_rgb.tiff" << "tiff_oriented/rgb_orientation_4.tiff";
+    QTest::newRow("RGB TIFF, orientation5") << "tiff_oriented/original_rgb.tiff" << "tiff_oriented/rgb_orientation_5.tiff";
+    QTest::newRow("RGB TIFF, orientation6") << "tiff_oriented/original_rgb.tiff" << "tiff_oriented/rgb_orientation_6.tiff";
+    QTest::newRow("RGB TIFF, orientation7") << "tiff_oriented/original_rgb.tiff" << "tiff_oriented/rgb_orientation_7.tiff";
+    QTest::newRow("RGB TIFF, orientation8") << "tiff_oriented/original_rgb.tiff" << "tiff_oriented/rgb_orientation_8.tiff";
+}
+
+void tst_QImageReader::tiffOrientation()
+{
+    QFETCH(QString, expected);
+    QFETCH(QString, oriented);
+
+    QImage expectedImage(prefix + expected);
+    QImage orientedImage(prefix + oriented);
+    QCOMPARE(expectedImage, orientedImage);
+}
+
+void tst_QImageReader::tiffGrayscale()
+{
+    QImage actualImage(prefix + "grayscale.tif");
+    QImage expectedImage(prefix + "grayscale-ref.tif");
+
+    QCOMPARE(expectedImage, actualImage.convertToFormat(expectedImage.format()));
+}
+#endif
+
+void tst_QImageReader::dotsPerMeter_data()
+{
+    QTest::addColumn<QString>("fileName");
+    QTest::addColumn<int>("expectedDotsPerMeterX");
+    QTest::addColumn<int>("expectedDotsPerMeterY");
+#if defined QTEST_HAVE_TIFF
+    QTest::newRow("TIFF: 72 dpi") << ("rgba_nocompression_littleendian.tif") << qRound(72 * (100 / 2.54)) << qRound(72 * (100 / 2.54));
+    QTest::newRow("TIFF: 100 dpi") << ("image_100dpi.tif") << qRound(100 * (100 / 2.54)) << qRound(100 * (100 / 2.54));
+#endif
+}
+
+void tst_QImageReader::dotsPerMeter()
+{
+    QFETCH(QString, fileName);
+    QFETCH(int, expectedDotsPerMeterX);
+    QFETCH(int, expectedDotsPerMeterY);
+
+    QImage image(prefix + fileName);
+
+    QCOMPARE(image.dotsPerMeterX(), expectedDotsPerMeterX);
+    QCOMPARE(image.dotsPerMeterY(), expectedDotsPerMeterY);
+}
+
+void tst_QImageReader::physicalDpi_data()
+{
+    QTest::addColumn<QString>("fileName");
+    QTest::addColumn<int>("expectedPhysicalDpiX");
+    QTest::addColumn<int>("expectedPhysicalDpiY");
+#if defined QTEST_HAVE_TIFF
+    QTest::newRow("TIFF: 72 dpi") << "rgba_nocompression_littleendian.tif" << 72 << 72;
+    QTest::newRow("TIFF: 100 dpi") << "image_100dpi.tif" << 100 << 100;
+#endif
+}
+
+void tst_QImageReader::physicalDpi()
+{
+    QFETCH(QString, fileName);
+    QFETCH(int, expectedPhysicalDpiX);
+    QFETCH(int, expectedPhysicalDpiY);
+
+    QImage image(prefix + fileName);
+
+    QCOMPARE(image.physicalDpiX(), expectedPhysicalDpiX);
+    QCOMPARE(image.physicalDpiY(), expectedPhysicalDpiY);
+}
+
+void tst_QImageReader::autoDetectImageFormat()
+{
+    // Assume PNG is supported :-)
+    {
+        // Disables file name extension probing
+        QImageReader reader(prefix + "kollada");
+        reader.setAutoDetectImageFormat(false);
+        QVERIFY(!reader.canRead());
+        QVERIFY(reader.read().isNull());
+        reader.setAutoDetectImageFormat(true);
+        QVERIFY(reader.canRead());
+        QVERIFY(!reader.read().isNull());
+    }
+    {
+        // Disables detection based on suffix
+        QImageReader reader(prefix + "kollada.png");
+        reader.setAutoDetectImageFormat(false);
+        QVERIFY(!reader.canRead());
+        QVERIFY(reader.read().isNull());
+        reader.setAutoDetectImageFormat(true);
+        QVERIFY(reader.canRead());
+        QVERIFY(!reader.read().isNull());
+    }
+    {
+        // Disables detection based on content
+        QImageReader reader(prefix + "kollada-noext");
+        reader.setAutoDetectImageFormat(false);
+        QVERIFY(!reader.canRead());
+        QVERIFY(reader.read().isNull());
+        reader.setAutoDetectImageFormat(true);
+        QVERIFY(reader.canRead());
+        QVERIFY(!reader.read().isNull());
+    }
+
+#ifdef QTEST_HAVE_JPEG
+    {
+        QImageReader io(prefix + "YCbCr_rgb.jpg");
+        io.setAutoDetectImageFormat(false);
+        // This should fail since no format string is given
+        QImage image;
+        QVERIFY(!io.read(&image));
+    }
+    {
+        QImageReader io(prefix + "YCbCr_rgb.jpg", "jpg");
+        io.setAutoDetectImageFormat(false);
+        QImage image;
+        QVERIFY(io.read(&image));
+    }
+#endif
+    {
+        QImageReader io(prefix + "tst7.png");
+        io.setAutoDetectImageFormat(false);
+        // This should fail since no format string is given
+        QImage image;
+        QVERIFY(!io.read(&image));
+    }
+    {
+        QImageReader io(prefix + "tst7.png", "png");
+        io.setAutoDetectImageFormat(false);
+        QImage image;
+        QVERIFY(io.read(&image));
+    }
+}
+
+void tst_QImageReader::fileNameProbing()
+{
+    QString name("doesnotexist.png");
+    QImageReader r;
+    r.setFileName(name); // non-existing / non-readable file
+    QCOMPARE(r.fileName(), name);
+
+    r.size();
+    QCOMPARE(r.fileName(), name);
+    r.read();
+    QCOMPARE(r.fileName(), name);
+}
+
+void tst_QImageReader::pixelCompareWithBaseline_data()
+{
+    QTest::addColumn<QString>("fileName");
+
+    QTest::newRow("floppy (16px,32px - 16 colors)") << "35floppy.ico";
+    QTest::newRow("semitransparent") << "semitransparent.ico";
+    QTest::newRow("slightlybrokenBMPHeader") << "kde_favicon.ico";
+    QTest::newRow("sightlybrokenIconHeader") << "connect.ico";
+}
+
+void tst_QImageReader::pixelCompareWithBaseline()
+{
+    QFETCH(QString, fileName);
+
+    static int enteredCount = 0;    // Used for better error diagnostics if something fails. We
+    static int loadFailCount = 0;   // don't know if the reason load() fails is that the plugin
+                                    // does not exist or because of a bug in the plugin. But if at
+                                    // least one file succeeded we know that the plugin was built.
+                                    // The other failures are then real failures.
+    QImage icoImg;
+    const QString inputFileName(QString::fromAscii("images/%1").arg(fileName));
+    QFileInfo fi(inputFileName);
+
+    ++enteredCount;
+    // might fail if the plugin does not exist, which is ok.
+    if (icoImg.load(inputFileName)) {
+        icoImg = icoImg.convertToFormat(QImage::Format_ARGB32_Premultiplied);
+        const QString baselineFileName(QString::fromAscii("baseline/%1.png").arg(fi.baseName()));
+#if 0
+        icoImg.save(baselineFileName);
+#else
+        QImage baseImg;
+        QVERIFY(baseImg.load(baselineFileName));
+        baseImg = baseImg.convertToFormat(QImage::Format_ARGB32_Premultiplied);
+        QCOMPARE(int(baseImg.format()), int(icoImg.format()));
+        QCOMPARE(baseImg, icoImg);
+#endif
+    } else {
+        ++loadFailCount;
+        if (enteredCount != loadFailCount) {
+            QFAIL("Plugin is built, but some did not load properly");
+        } else {
+            qWarning("loading failed, check if ico plugin is built");
+        }
+    }
+}
+
+
+void tst_QImageReader::testIgnoresFormatAndExtension_data()
+{
+    QTest::addColumn<QString>("name");
+    QTest::addColumn<QString>("extension");
+    QTest::addColumn<QString>("expected");
+
+    QTest::newRow("black.png") << "black" << "png" << "png";
+    QTest::newRow("black.xpm") << "black" << "xpm" << "xpm";
+    QTest::newRow("colorful.bmp") << "colorful" << "bmp" << "bmp";
+    QTest::newRow("image.ppm") << "image" << "ppm" << "ppm";
+    QTest::newRow("image.pbm") << "image" << "pbm" << "pbm";
+    QTest::newRow("image.pgm") << "image" << "pgm" << "pgm";
+
+#if defined QTEST_HAVE_GIF
+    QTest::newRow("bat1.gif") << "bat1" << "gif" << "gif";
+#endif
+
+#if defined QTEST_HAVE_JPEG
+    QTest::newRow("beavis.jpg") << "beavis" << "jpg" << "jpeg";
+#endif
+
+#if defined QTEST_HAVE_MNG
+    QTest::newRow("fire.mng") << "fire" << "mng" << "mng";
+#endif
+
+#if defined QTEST_HAVE_TIFF
+    QTest::newRow("image_100dpi.tif") << "image_100dpi" << "tif" << "tiff";
+#endif
+
+#if defined QTEST_HAVE_SVG
+    QTest::newRow("rect.svg") << "rect" << "svg" << "svg";
+    QTest::newRow("rect.svgz") << "rect" << "svgz" << "svgz";
+#endif
+}
+
+
+void tst_QImageReader::testIgnoresFormatAndExtension()
+{
+    QFETCH(QString, name);
+    QFETCH(QString, extension);
+    QFETCH(QString, expected);
+
+    QList<QByteArray> formats = QImageReader::supportedImageFormats();
+    QString fileNameBase = prefix + name + ".";
+
+    foreach (const QByteArray &f, formats) {
+        if (f == extension)
+            continue;
+        QFile tmp(QDir::tempPath() + "/" + name + "_" + expected + "." + f);
+
+        QVERIFY(QFile::copy(fileNameBase + extension, QFileInfo(tmp).absoluteFilePath()));
+
+        QString format;
+        QImage image;
+        {
+            // image reader needs to be scoped for the remove() to work..
+            QImageReader r;
+            r.setFileName(QFileInfo(tmp).absoluteFilePath());
+            r.setDecideFormatFromContent(true);
+            format = r.format();
+            r.read(&image);
+        }
+
+        tmp.remove();
+
+        QVERIFY(!image.isNull());
+        QCOMPARE(format, expected);
+    }
+}
+
+
+void tst_QImageReader::saveFormat_data()
+{
+    QTest::addColumn<QImage::Format>("format");
+
+    QTest::newRow("Format_Mono") << QImage::Format_Mono;
+    QTest::newRow("Format_MonoLSB") << QImage::Format_MonoLSB;
+    QTest::newRow("Format_Indexed8") << QImage::Format_Indexed8;
+    QTest::newRow("Format_RGB32") << QImage::Format_RGB32;
+    QTest::newRow("Format_ARGB32") << QImage::Format_ARGB32;
+    QTest::newRow("Format_ARGB32_Premultiplied") << QImage::Format_ARGB32_Premultiplied;
+    QTest::newRow("Format_RGB16") << QImage::Format_RGB16;
+    QTest::newRow("Format_ARGB8565_Premultiplied") << QImage::Format_ARGB8565_Premultiplied;
+    QTest::newRow("Format_RGB666") << QImage::Format_RGB666;
+    QTest::newRow("Format_ARGB6666_Premultiplied") << QImage::Format_ARGB6666_Premultiplied;
+    QTest::newRow("Format_RGB555") << QImage::Format_RGB555;
+    QTest::newRow("Format_ARGB8555_Premultiplied") << QImage::Format_ARGB8555_Premultiplied;
+    QTest::newRow("Format_RGB888") << QImage::Format_RGB888;
+    QTest::newRow("Format_RGB444") << QImage::Format_RGB444;
+    QTest::newRow("Format_ARGB4444_Premultiplied") << QImage::Format_ARGB4444_Premultiplied;
+}
+
+void tst_QImageReader::saveFormat()
+{
+    QFETCH(QImage::Format, format);
+
+    QImage orig(":/images/kollada.png");
+
+    QImage converted = orig.convertToFormat(format);
+    QBuffer buf;
+    buf.open(QIODevice::WriteOnly);
+    QVERIFY(converted.save(&buf, "png"));
+    buf.close();
+    QImage stored = QImage::fromData(buf.buffer(), "png");
+
+    stored = stored.convertToFormat(QImage::Format_ARGB32);
+    converted = converted.convertToFormat(QImage::Format_ARGB32);
+    QCOMPARE(stored, converted);
+}
+
+
+void tst_QImageReader::readText_data()
+{
+    QTest::addColumn<QString>("fileName");
+    QTest::addColumn<QString>("key");
+    QTest::addColumn<QString>("text");
+
+    QTest::newRow("png, tEXt before img") << "txts.png" << "Title" << "PNG";
+    QTest::newRow("png, zTXt before img") << "txts.png" << "Comment" << "Some compressed text.";
+    QTest::newRow("png, tEXt after img") << "txts.png" << "Disclaimer" << "For testing only.";
+    QTest::newRow("png, zTXt after img") << "txts.png" << "Description" << "Rendered by Persistence of Vision (tm) Ray Tracer";
+}
+
+
+void tst_QImageReader::readText()
+{
+    QFETCH(QString, fileName);
+    QFETCH(QString, key);
+    QFETCH(QString, text);
+
+    QImage img(prefix + fileName);
+    QVERIFY(img.textKeys().contains(key));
+    QCOMPARE(img.text(key), text);
+}
+
+
+void tst_QImageReader::preserveTexts_data()
+{
+    QTest::addColumn<QString>("text");
+
+    QTest::newRow("Simple") << "simpletext";
+    QTest::newRow("Whitespace") << " A text  with whitespace ";
+    QTest::newRow("Newline") << "A text\nwith newlines\n";
+    QTest::newRow("Double newlines") << "A text\n\nwith double newlines\n\n";
+    QTest::newRow("Long") << QString("A rather long text, at least after many repetitions. ").repeated(100);
+    QString latin1set;
+    int c;
+    for(c = 0x20; c <= 0x7e; c++)
+        latin1set.append(QLatin1Char(c));
+    for(c = 0xa0; c <= 0xff; c++)
+        latin1set.append(QLatin1Char(c));
+    QTest::newRow("All Latin1 chars") << latin1set;
+
+#if 0
+    // Depends on iTXt support in libpng
+    QTest::newRow("Multibyte string") << QString::fromUtf8("\341\233\222\341\233\226\341\232\251\341\232\271\341\232\242\341\233\232\341\232\240");
+#endif
+}
+
+
+void tst_QImageReader::preserveTexts()
+{
+    QFETCH(QString, text);
+    QString key("testkey");
+    QString key2("testkey2");
+    QString text2("Some other text.");
+    QString key3("testkey3");
+    QString text3("Some more other text.");
+
+    QImage img(":/images/kollada.png");
+    img.setText(key, text);
+    img.setText(key2, text2);
+    QBuffer buf;
+    buf.open(QIODevice::WriteOnly);
+    QVERIFY(img.save(&buf, "png"));
+    buf.close();
+    QImage stored = QImage::fromData(buf.buffer(), "png");
+    QCOMPARE(stored.text(key), text);
+    QCOMPARE(stored.text(key2), text2);
+
+    QImage img2(":/images/kollada.png");
+    img2.setText(key3, text3);
+    QBuffer buf2;
+    QImageWriter w(&buf2, "png");
+    w.setText(key, text);
+    w.setText(key2, text2);
+    QVERIFY(w.write(img2));
+    buf2.close();
+    QImageReader r(&buf2, "png");
+    QCOMPARE(r.text(key), text.simplified());
+    QCOMPARE(r.text(key2), text2.simplified());
+    QCOMPARE(r.text(key3), text3.simplified());
+}
+
+
+QTEST_MAIN(tst_QImageReader)
+#include "tst_qimagereader.moc"