From a6f7482957d3226795d3f51cf340e4059597bded Mon Sep 17 00:00:00 2001
From: Mirco Miranda <mircomir@gmail.com>
Date: Mon, 16 Dec 2024 13:52:06 +0000
Subject: [PATCH] Read / Write test: added NULL device test

DDS plugin crashes if I request supportedSubTypes()

- Fixed DDS plugin crash
- Added NULL device test on both read and write tests

Closes #14
---
 autotests/readtest.cpp   | 60 ++++++++++++++++++++++++++++++++++++++++
 autotests/writetest.cpp  | 49 ++++++++++++++++++++++++++++++++
 src/imageformats/dds.cpp | 30 ++++++++++++++------
 3 files changed, 130 insertions(+), 9 deletions(-)

diff --git a/autotests/readtest.cpp b/autotests/readtest.cpp
index 4c99256..d829a8c 100644
--- a/autotests/readtest.cpp
+++ b/autotests/readtest.cpp
@@ -375,6 +375,66 @@ int main(int argc, char **argv)
         }
     }
 
+    // NULL device test
+    for (const QFileInfo &fi : lstImgDir) {
+        TemplateImage timg(fi);
+        if (timg.isTemplate() || timg.isLicense()) {
+            continue;
+        }
+
+        QTextStream(stdout) << "* Run on NULL device\n";
+        QImageReader reader;
+        reader.setFormat(fi.suffix().toLatin1());
+        if (reader.canRead() == true) {
+            QTextStream(stdout) << "FAIL : " << fi.suffix() << ": canRead() returns true\n";
+            ++failed;
+            break;
+        }
+
+        if (!reader.read().isNull()) {
+            QTextStream(stdout) << "FAIL : " << fi.suffix() << ": read() returns a non-NULL image\n";
+            ++failed;
+            break;
+        }
+
+        if (reader.size() != QSize()) {
+            QTextStream(stdout) << "FAIL : " << fi.suffix() << ": size() returns a valid size\n";
+            ++failed;
+            break;
+        }
+
+        if (reader.imageFormat() != QImage::Format_Invalid) {
+            QTextStream(stdout) << "FAIL : " << fi.suffix() << ": size() returns a valid format\n";
+            ++failed;
+            break;
+        }
+
+        // test for crash only
+        reader.textKeys();
+        reader.quality();
+        reader.clipRect();
+        reader.scaledSize();
+        reader.scaledClipRect();
+        reader.backgroundColor();
+        reader.supportsAnimation();
+        reader.transformation();
+        reader.autoTransform();
+        reader.subType();
+        reader.supportedSubTypes();
+        reader.jumpToNextImage();
+        reader.loopCount();
+        reader.imageCount();
+        reader.currentImageNumber();
+        reader.currentImageRect();
+
+        // success
+        QTextStream(stdout) << "PASS : " << fi.suffix() << "\n";
+        ++passed;
+
+        // runs once for each format
+        break;
+    }
+
     QTextStream(stdout) << "Totals: " << passed << " passed, " << skipped << " skipped, " << failed << " failed\n";
     QTextStream(stdout) << "********* "
                         << "Finished basic read tests for " << suffix << " images *********\n";
diff --git a/autotests/writetest.cpp b/autotests/writetest.cpp
index de06e7a..db34f97 100644
--- a/autotests/writetest.cpp
+++ b/autotests/writetest.cpp
@@ -329,6 +329,52 @@ int formatTest(const QString &suffix, bool createTemplates)
     return failed == 0 ? 0 : 1;
 }
 
+/*!
+ * \brief nullDeviceTest
+ * Checks the plugin behaviour when using a NULL device.
+ */
+int nullDeviceTest(const QString &suffix)
+{
+    QTextStream(stdout) << "********* "
+                        << "Starting NULL device write tests for " << suffix << " images *********\n";
+
+    int passed = 0;
+    int failed = 0;
+    int skipped = 0;
+
+    QImageWriter writer;
+    writer.setFormat(suffix.toLatin1());
+
+    if (writer.canWrite()) {
+        QTextStream(stdout) << "FAIL : canWrite() returns TRUE\n";
+        ++failed;
+    }
+
+    if (writer.write(QImage(16, 16, QImage::Format_ARGB32))) {
+        QTextStream(stdout) << "FAIL : write() returns TRUE\n";
+        ++failed;
+    }
+
+    // test for crash only
+    writer.compression();
+    writer.quality();
+    writer.transformation();
+    writer.subType();
+    writer.supportedSubTypes();
+    writer.optimizedWrite();
+    writer.progressiveScanWrite();
+
+    if (failed == 0) {// success
+        ++passed;
+    }
+
+    QTextStream(stdout) << "Totals: " << passed << " passed, " << failed << " failed, " << skipped << " skipped\n";
+    QTextStream(stdout) << "********* "
+                        << "Finished format write tests for " << suffix << " images *********\n";
+
+    return failed == 0 ? 0 : 1;
+}
+
 int main(int argc, char **argv)
 {
     QCoreApplication app(argc, argv);
@@ -382,6 +428,9 @@ int main(int argc, char **argv)
     if (ret == 0) {
         ret = formatTest(suffix, parser.isSet(createFormatTempates));
     }
+    if (ret == 0) {
+        ret = nullDeviceTest(suffix);
+    }
 
     return ret;
 }
diff --git a/src/imageformats/dds.cpp b/src/imageformats/dds.cpp
index 0e928f9..b6f8e24 100644
--- a/src/imageformats/dds.cpp
+++ b/src/imageformats/dds.cpp
@@ -1802,18 +1802,26 @@ bool QDDSHandler::write(const QImage &outImage)
 
 QVariant QDDSHandler::option(QImageIOHandler::ImageOption option) const
 {
-    if (!supportsOption(option) || !ensureScanned())
+    if (!supportsOption(option)) {
         return QVariant();
+    }
 
-    switch (option) {
-    case QImageIOHandler::Size:
-        return isCubeMap(m_header) ? QSize(m_header.width * 4, m_header.height * 3) : QSize(m_header.width, m_header.height);
-    case QImageIOHandler::SubType:
-        return formatName(m_format);
-    case QImageIOHandler::SupportedSubTypes:
+    // *** options that do not require a valid stream ***
+    if (option == QImageIOHandler::SupportedSubTypes) {
         return QVariant::fromValue(QList<QByteArray>() << formatName(FormatA8R8G8B8));
-    default:
-        break;
+    }
+
+    // *** options that require a valid stream ***
+    if (!ensureScanned()) {
+        return QVariant();
+    }
+
+    if (option == QImageIOHandler::Size) {
+        return isCubeMap(m_header) ? QSize(m_header.width * 4, m_header.height * 3) : QSize(m_header.width, m_header.height);
+    }
+
+    if (option == QImageIOHandler::SubType) {
+        return formatName(m_format);
     }
 
     return QVariant();
@@ -1868,6 +1876,10 @@ bool QDDSHandler::canRead(QIODevice *device)
 
 bool QDDSHandler::ensureScanned() const
 {
+    if (device() == nullptr) {
+        return false;
+    }
+
     if (m_scanState != ScanNotScanned)
         return m_scanState == ScanSuccess;