amass/qt6windows7
1
0
Fork 0
mirror of https://github.com/crystalidea/qt6windows7.git synced 2025-07-04 00:05:25 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

6.5.3 clean

Browse Source
This commit is contained in:
kleuter
2023-11-01 18:02:52 +01:00
parent bbe896803b
commit 7018d9e6c8
2170 changed files with 57471 additions and 43550 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
tests/auto/gui/image/qimagereader/tst_qimagereader.cpp
View File

@ -11,7 +11,7 @@
#include <QImageReader>
#include <QImageWriter>
#include <QPixmap>
#include <QSet>
#include <QScopeGuard>
#include <QTcpSocket>
#include <QTcpServer>
#include <QTimer>
@ -594,41 +594,31 @@ void tst_QImageReader::multiWordNamedColorXPM()
QCOMPARE(image.pixel(0, 2), qRgb(255, 250, 205)); // lemon chiffon
}
namespace {
template <typename ForwardIterator>
bool is_sorted_unique(ForwardIterator first, ForwardIterator last)
{
// a range is sorted with no dups iff each *i < *(i+1), so check that none are >=:
return std::adjacent_find(first, last, std::greater_equal<>{}) == last;
}
}
void tst_QImageReader::supportedFormats()
{
QList<QByteArray> formats = QImageReader::supportedImageFormats();
QList<QByteArray> sortedFormats = formats;
std::sort(sortedFormats.begin(), sortedFormats.end());
// 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());
const QList<QByteArray> formats = QImageReader::supportedImageFormats();
auto printOnFailure = qScopeGuard([&] { qDebug() << formats; });
QVERIFY(is_sorted_unique(formats.begin(), formats.end()));
printOnFailure.dismiss();
}
void tst_QImageReader::supportedMimeTypes()
{
QList<QByteArray> mimeTypes = QImageReader::supportedMimeTypes();
QList<QByteArray> sortedMimeTypes = mimeTypes;
std::sort(sortedMimeTypes.begin(), sortedMimeTypes.end());
// check that the list is sorted
QCOMPARE(mimeTypes, sortedMimeTypes);
QSet<QByteArray> mimeTypeSet;
foreach (QByteArray mimeType, mimeTypes)
mimeTypeSet << mimeType;
const QList<QByteArray> mimeTypes = QImageReader::supportedMimeTypes();
auto printOnFailure = qScopeGuard([&] { qDebug() << mimeTypes; });
QVERIFY(is_sorted_unique(mimeTypes.begin(), mimeTypes.end()));
// check the list as a minimum contains image/bmp
QVERIFY(mimeTypeSet.contains("image/bmp"));
// check that the list does not contain duplicates
QCOMPARE(mimeTypeSet.size(), mimeTypes.size());
QVERIFY(mimeTypes.contains("image/bmp"));
printOnFailure.dismiss();
}
void tst_QImageReader::setBackgroundColor_data()
@ -1623,43 +1613,56 @@ void tst_QImageReader::supportsOption_data()
QTest::addColumn<QIntList>("options");
QTest::newRow("png") << QString("black.png")
<< (QIntList() << QImageIOHandler::Gamma
<< QImageIOHandler::Description
<< QImageIOHandler::Quality
<< QImageIOHandler::CompressionRatio
<< QImageIOHandler::Size
<< QImageIOHandler::ScaledSize);
<< QIntList{
QImageIOHandler::Gamma,
QImageIOHandler::Description,
QImageIOHandler::Quality,
QImageIOHandler::CompressionRatio,
QImageIOHandler::Size,
QImageIOHandler::ScaledSize,
QImageIOHandler::ImageFormat,
};
}
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;
QFETCH(const QIntList, options);
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));
for (int i = 0; ; ++i) {
// this switch ensures the compiler warns when we miss an enumerator [-Wswitch]
// do _not_ add a default case!
switch (const auto o = QImageIOHandler::ImageOption(i)) {
case QImageIOHandler::Size:
case QImageIOHandler::ClipRect:
case QImageIOHandler::Description:
case QImageIOHandler::ScaledClipRect:
case QImageIOHandler::ScaledSize:
case QImageIOHandler::CompressionRatio:
case QImageIOHandler::Gamma:
case QImageIOHandler::Quality:
case QImageIOHandler::Name:
case QImageIOHandler::SubType:
case QImageIOHandler::IncrementalReading:
case QImageIOHandler::Endianness:
case QImageIOHandler::Animation:
case QImageIOHandler::BackgroundColor:
case QImageIOHandler::ImageFormat:
case QImageIOHandler::SupportedSubTypes:
case QImageIOHandler::OptimizedWrite:
case QImageIOHandler::ProgressiveScanWrite:
case QImageIOHandler::ImageTransformation:
{
auto printOnFailure = qScopeGuard([&] { qDebug("failed at %d", i); });
QCOMPARE(reader.supportsOption(o), options.contains(i));
printOnFailure.dismiss();
continue; // ... as long as `i` represents a valid ImageOption value
}
}
break; // ... once `i` no longer represents a valid ImageOption value
}
}
void tst_QImageReader::autoDetectImageFormat()