summaryrefslogtreecommitdiffstats
path: root/tests/auto
diff options
context:
space:
mode:
Diffstat (limited to 'tests/auto')
-rw-r--r--tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp29
-rw-r--r--tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp172
-rw-r--r--tests/auto/corelib/tools/qhash/tst_qhash.cpp73
-rw-r--r--tests/auto/gui/rhi/qrhi/tst_qrhi.cpp67
-rw-r--r--tests/auto/gui/util/qdoublevalidator/tst_qdoublevalidator.cpp1
5 files changed, 308 insertions, 34 deletions
diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
index ada3630128..4e30f210b1 100644
--- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
+++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
@@ -123,6 +123,7 @@ private slots:
void compareCustomEqualOnlyType();
void customDebugStream();
void unknownType();
+ void fromType();
};
struct BaseGenericType
@@ -480,6 +481,7 @@ void tst_QMetaType::id()
{
QCOMPARE(QMetaType(QMetaType::QString).id(), QMetaType::QString);
QCOMPARE(QMetaType(::qMetaTypeId<TestSpace::Foo>()).id(), ::qMetaTypeId<TestSpace::Foo>());
+ QCOMPARE(QMetaType::fromType<TestSpace::Foo>().id(), ::qMetaTypeId<TestSpace::Foo>());
}
void tst_QMetaType::qMetaTypeId()
@@ -600,6 +602,12 @@ void tst_QMetaType::typeName()
QCOMPARE(name, aTypeName);
QCOMPARE(name.toLatin1(), QMetaObject::normalizedType(name.toLatin1().constData()));
QCOMPARE(rawname == nullptr, aTypeName.isNull());
+
+ QMetaType mt(aType);
+ if (mt.isValid()) { // Gui type are not valid
+ QCOMPARE(QString::fromLatin1(QMetaType(aType).name()), aTypeName);
+ }
+
}
void tst_QMetaType::type_data()
@@ -1728,6 +1736,7 @@ void tst_QMetaType::automaticTemplateRegistration()
const int type = QMetaType::type(tn); \
const int expectedType = ::qMetaTypeId<CONTAINER< __VA_ARGS__ > >(); \
QCOMPARE(type, expectedType); \
+ QCOMPARE((QMetaType::fromType<CONTAINER< __VA_ARGS__ >>().id()), expectedType); \
}
#define FOR_EACH_1ARG_TEMPLATE_TYPE(F, TYPE) \
@@ -2530,6 +2539,26 @@ void tst_QMetaType::unknownType()
invalid.construct(&buffer);
QCOMPARE(buffer, 0xBAD);
}
+
+void tst_QMetaType::fromType()
+{
+ #define FROMTYPE_CHECK(MetaTypeName, MetaTypeId, RealType) \
+ QCOMPARE(QMetaType::fromType<RealType>(), QMetaType(MetaTypeId)); \
+ QVERIFY(QMetaType::fromType<RealType>() == QMetaType(MetaTypeId)); \
+ QVERIFY(!(QMetaType::fromType<RealType>() != QMetaType(MetaTypeId))); \
+ QCOMPARE(QMetaType::fromType<RealType>().id(), MetaTypeId);
+
+ FOR_EACH_CORE_METATYPE(FROMTYPE_CHECK)
+
+ QVERIFY(QMetaType::fromType<QString>() != QMetaType());
+ QCOMPARE(QMetaType(), QMetaType());
+ QCOMPARE(QMetaType(QMetaType::UnknownType), QMetaType());
+
+ FROMTYPE_CHECK(_, ::qMetaTypeId<Whity<int>>(), Whity<int>)
+ #undef FROMTYPE_CHECK
+}
+
+
// Compile-time test, it should be possible to register function pointer types
class Undefined;
diff --git a/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp b/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp
index 2f3f9c2d79..e3009a78fb 100644
--- a/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp
+++ b/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp
@@ -219,6 +219,8 @@ QByteArray verifyZeroTermination(const QByteArray &ba)
} while (0) \
/**/
+Q_DECLARE_METATYPE(QByteArray::Base64DecodingStatus);
+
tst_QByteArray::tst_QByteArray()
{
}
@@ -618,9 +620,16 @@ void tst_QByteArray::base64()
{
QFETCH(QByteArray, rawdata);
QFETCH(QByteArray, base64);
+ QByteArray::FromBase64Result result;
+
+ result = QByteArray::fromBase64Encoding(base64, QByteArray::Base64Encoding | QByteArray::AbortOnBase64DecodingErrors);
+ QVERIFY(result);
+ QCOMPARE(result.decoded, rawdata);
- QByteArray arr = QByteArray::fromBase64(base64);
- QCOMPARE(arr, rawdata);
+ QByteArray arr = base64;
+ result = QByteArray::fromBase64Encoding(std::move(arr), QByteArray::Base64Encoding | QByteArray::AbortOnBase64DecodingErrors);
+ QVERIFY(result);
+ QCOMPARE(result.decoded, rawdata);
QByteArray arr64 = rawdata.toBase64();
QCOMPARE(arr64, base64);
@@ -649,21 +658,22 @@ void tst_QByteArray::fromBase64_data()
{
QTest::addColumn<QByteArray>("rawdata");
QTest::addColumn<QByteArray>("base64");
-
- QTest::newRow("1") << QByteArray("") << QByteArray(" ");
- QTest::newRow("2") << QByteArray("1") << QByteArray("MQ");
- QTest::newRow("3") << QByteArray("12") << QByteArray("MTI ");
- QTest::newRow("4") << QByteArray("123") << QByteArray("M=TIz");
- QTest::newRow("5") << QByteArray("1234") << QByteArray("MTI zN A ");
- QTest::newRow("6") << QByteArray("\n") << QByteArray("Cg");
- QTest::newRow("7") << QByteArray("a\n") << QByteArray("======YQo=");
- QTest::newRow("8") << QByteArray("ab\n") << QByteArray("Y\nWIK");
- QTest::newRow("9") << QByteArray("abc\n") << QByteArray("YWJjCg==");
- QTest::newRow("a") << QByteArray("abcd\n") << QByteArray("YWJ\1j\x9cZAo=");
- QTest::newRow("b") << QByteArray("abcde\n") << QByteArray("YW JjZ\n G\tUK");
- QTest::newRow("c") << QByteArray("abcdef\n") << QByteArray("YWJjZGVmCg=");
- QTest::newRow("d") << QByteArray("abcdefg\n") << QByteArray("YWJ\rjZGVmZwo");
- QTest::newRow("e") << QByteArray("abcdefgh\n") << QByteArray("YWJjZGVmZ2gK");
+ QTest::addColumn<QByteArray::Base64DecodingStatus>("status");
+
+ QTest::newRow("1") << QByteArray("") << QByteArray(" ") << QByteArray::Base64DecodingStatus::IllegalCharacter;
+ QTest::newRow("2") << QByteArray("1") << QByteArray("MQ=") << QByteArray::Base64DecodingStatus::IllegalInputLength;
+ QTest::newRow("3") << QByteArray("12") << QByteArray("MTI ") << QByteArray::Base64DecodingStatus::IllegalCharacter;
+ QTest::newRow("4") << QByteArray("123") << QByteArray("M=TIz") << QByteArray::Base64DecodingStatus::IllegalInputLength;
+ QTest::newRow("5") << QByteArray("1234") << QByteArray("MTI zN A ") << QByteArray::Base64DecodingStatus::IllegalCharacter;
+ QTest::newRow("6") << QByteArray("\n") << QByteArray("Cg@") << QByteArray::Base64DecodingStatus::IllegalCharacter;
+ QTest::newRow("7") << QByteArray("a\n") << QByteArray("======YQo=") << QByteArray::Base64DecodingStatus::IllegalInputLength;
+ QTest::newRow("8") << QByteArray("ab\n") << QByteArray("Y\nWIK ") << QByteArray::Base64DecodingStatus::IllegalCharacter;
+ QTest::newRow("9") << QByteArray("abc\n") << QByteArray("YWJjCg=") << QByteArray::Base64DecodingStatus::IllegalInputLength;
+ QTest::newRow("a") << QByteArray("abcd\n") << QByteArray("YWJ\1j\x9cZAo=") << QByteArray::Base64DecodingStatus::IllegalCharacter;
+ QTest::newRow("b") << QByteArray("abcde\n") << QByteArray("YW JjZ\n G\tUK") << QByteArray::Base64DecodingStatus::IllegalCharacter;
+ QTest::newRow("c") << QByteArray("abcdef\n") << QByteArray("YWJjZGVmCg=") << QByteArray::Base64DecodingStatus::IllegalInputLength;
+ QTest::newRow("d") << QByteArray("abcdefg\n") << QByteArray("YWJ\rjZGVmZwo") << QByteArray::Base64DecodingStatus::IllegalCharacter;
+ QTest::newRow("e") << QByteArray("abcdefgh\n") << QByteArray("YWJjZGVmZ2gK====") << QByteArray::Base64DecodingStatus::IllegalPadding;
QByteArray ba;
ba.resize(256);
@@ -673,13 +683,12 @@ void tst_QByteArray::fromBase64_data()
"c4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1u\n"
"b3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpa\n"
"anqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd\n"
- "3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w== ");
+ "3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w== ") << QByteArray::Base64DecodingStatus::IllegalCharacter;
- QTest::newRow("g") << QByteArray("foo\0bar", 7) << QByteArray("Zm9vAGJhcg");
- QTest::newRow("h") << QByteArray("f\xd1oo\x9ctar") << QByteArray("ZtFvb5x0YXI=");
- QTest::newRow("i") << QByteArray("\"\0\0\0\0\0\0\"", 8) << QByteArray("IgAAAAAAACI");
-
+ QTest::newRow("g") << QByteArray("foo\0bar", 7) << QByteArray("Zm9vAGJhcg=") << QByteArray::Base64DecodingStatus::IllegalInputLength;
+ QTest::newRow("h") << QByteArray("f\xd1oo\x9ctar") << QByteArray("ZtFvb5x 0YXI") << QByteArray::Base64DecodingStatus::IllegalCharacter;
+ QTest::newRow("i") << QByteArray("\"\0\0\0\0\0\0\"", 8) << QByteArray("IgAAAAAAACI ") << QByteArray::Base64DecodingStatus::IllegalCharacter;
}
@@ -687,25 +696,120 @@ void tst_QByteArray::fromBase64()
{
QFETCH(QByteArray, rawdata);
QFETCH(QByteArray, base64);
-
- QByteArray arr = QByteArray::fromBase64(base64);
- QCOMPARE(arr, rawdata);
-
- arr = QByteArray::fromBase64(base64, QByteArray::Base64Encoding);
- QCOMPARE(arr, rawdata);
+ QFETCH(QByteArray::Base64DecodingStatus, status);
+
+ QByteArray::FromBase64Result result;
+
+ result = QByteArray::fromBase64Encoding(base64);
+ QVERIFY(result);
+ QCOMPARE(result.decoded, rawdata);
+
+ result = QByteArray::fromBase64Encoding(base64, QByteArray::Base64Encoding);
+ QVERIFY(result);
+ QCOMPARE(result.decoded, rawdata);
+
+ result = QByteArray::fromBase64Encoding(base64, QByteArray::Base64Encoding | QByteArray::AbortOnBase64DecodingErrors);
+ QVERIFY(!result);
+ QCOMPARE(result.decodingStatus, status);
+ QVERIFY(result.decoded.isEmpty());
+
+ QByteArray arr = base64;
+ QVERIFY(!arr.isDetached());
+ result = QByteArray::fromBase64Encoding(std::move(arr), QByteArray::Base64Encoding | QByteArray::AbortOnBase64DecodingErrors);
+ QVERIFY(!arr.isEmpty());
+ QVERIFY(!result);
+ QCOMPARE(result.decodingStatus, status);
+ QVERIFY(result.decoded.isEmpty());
+
+ arr.detach();
+ QVERIFY(arr.isDetached());
+ result = QByteArray::fromBase64Encoding(std::move(arr), QByteArray::Base64Encoding | QByteArray::AbortOnBase64DecodingErrors);
+ QVERIFY(arr.isEmpty());
+ QVERIFY(!result);
+ QCOMPARE(result.decodingStatus, status);
+ QVERIFY(result.decoded.isEmpty());
// try "base64url" encoding
QByteArray base64url = base64;
base64url.replace('/', '_').replace('+', '-');
- arr = QByteArray::fromBase64(base64url, QByteArray::Base64UrlEncoding);
- QCOMPARE(arr, rawdata);
+ result = QByteArray::fromBase64Encoding(base64url, QByteArray::Base64UrlEncoding);
+ QVERIFY(result);
+ QCOMPARE(result.decoded, rawdata);
+
+ result = QByteArray::fromBase64Encoding(base64url, QByteArray::Base64UrlEncoding | QByteArray::AbortOnBase64DecodingErrors);
+ QVERIFY(!result);
+ QCOMPARE(result.decodingStatus, status);
+ QVERIFY(result.decoded.isEmpty());
+
+ arr = base64url;
+ arr.detach();
+ result = QByteArray::fromBase64Encoding(std::move(arr), QByteArray::Base64UrlEncoding | QByteArray::AbortOnBase64DecodingErrors);
+ QVERIFY(arr.isEmpty());
+ QVERIFY(!result);
+ QCOMPARE(result.decodingStatus, status);
+ QVERIFY(result.decoded.isEmpty());
if (base64 != base64url) {
// check that the invalid decodings fail
- arr = QByteArray::fromBase64(base64, QByteArray::Base64UrlEncoding);
- QVERIFY(arr != rawdata);
- arr = QByteArray::fromBase64(base64url, QByteArray::Base64Encoding);
- QVERIFY(arr != rawdata);
+ result = QByteArray::fromBase64Encoding(base64, QByteArray::Base64UrlEncoding);
+ QVERIFY(result);
+ QVERIFY(result.decoded != rawdata);
+ result = QByteArray::fromBase64Encoding(base64url, QByteArray::Base64Encoding);
+ QVERIFY(result);
+ QVERIFY(result.decoded != rawdata);
+
+ result = QByteArray::fromBase64Encoding(base64, QByteArray::Base64UrlEncoding | QByteArray::AbortOnBase64DecodingErrors);
+ QVERIFY(!result);
+ QVERIFY(result.decoded.isEmpty());
+
+ arr = base64;
+ arr.detach();
+ result = QByteArray::fromBase64Encoding(std::move(arr), QByteArray::Base64UrlEncoding | QByteArray::AbortOnBase64DecodingErrors);
+ QVERIFY(arr.isEmpty());
+ QVERIFY(!result);
+ QVERIFY(result.decoded.isEmpty());
+
+ result = QByteArray::fromBase64Encoding(base64url, QByteArray::Base64Encoding | QByteArray::AbortOnBase64DecodingErrors);
+ QVERIFY(!result);
+ QVERIFY(result.decoded.isEmpty());
+
+ arr = base64url;
+ arr.detach();
+ result = QByteArray::fromBase64Encoding(std::move(arr), QByteArray::Base64Encoding | QByteArray::AbortOnBase64DecodingErrors);
+ QVERIFY(arr.isEmpty());
+ QVERIFY(!result);
+ QVERIFY(result.decoded.isEmpty());
+ }
+
+ // also remove padding, if any, and test again. note that by doing
+ // that we might be sanitizing the illegal input, so we can't assume now
+ // that result will be invalid in all cases
+ {
+ auto rightmostNotEqualSign = std::find_if_not(base64url.rbegin(), base64url.rend(), [](char c) { return c == '='; });
+ base64url.chop(std::distance(base64url.rbegin(), rightmostNotEqualSign)); // no QByteArray::erase...
+ }
+
+ result = QByteArray::fromBase64Encoding(base64url, QByteArray::Base64UrlEncoding);
+ QVERIFY(result);
+ QCOMPARE(result.decoded, rawdata);
+
+ result = QByteArray::fromBase64Encoding(base64url, QByteArray::Base64UrlEncoding | QByteArray::AbortOnBase64DecodingErrors);
+ if (result) {
+ QCOMPARE(result.decoded, rawdata);
+ } else {
+ QCOMPARE(result.decodingStatus, status);
+ QVERIFY(result.decoded.isEmpty());
+ }
+
+ arr = base64url;
+ arr.detach();
+ result = QByteArray::fromBase64Encoding(std::move(arr), QByteArray::Base64UrlEncoding | QByteArray::AbortOnBase64DecodingErrors);
+ QVERIFY(arr.isEmpty());
+ if (result) {
+ QCOMPARE(result.decoded, rawdata);
+ } else {
+ QCOMPARE(result.decodingStatus, status);
+ QVERIFY(result.decoded.isEmpty());
}
}
diff --git a/tests/auto/corelib/tools/qhash/tst_qhash.cpp b/tests/auto/corelib/tools/qhash/tst_qhash.cpp
index f0eeb70ccb..91cd3eb0bd 100644
--- a/tests/auto/corelib/tools/qhash/tst_qhash.cpp
+++ b/tests/auto/corelib/tools/qhash/tst_qhash.cpp
@@ -69,6 +69,7 @@ private slots:
void initializerList();
void eraseValidIteratorOnSharedHash();
void equal_range();
+ void insert_hash();
};
struct IdentityTracker {
@@ -1636,5 +1637,77 @@ void tst_QHash::equal_range()
}
}
+void tst_QHash::insert_hash()
+{
+ {
+ QHash<int, int> hash;
+ hash.insert(1, 1);
+ hash.insert(2, 2);
+ hash.insert(0, -1);
+
+ QHash<int, int> hash2;
+ hash2.insert(0, 0);
+ hash2.insert(3, 3);
+ hash2.insert(4, 4);
+
+ hash.insert(hash2);
+
+ QCOMPARE(hash.count(), 5);
+ for (int i = 0; i < 5; ++i)
+ QCOMPARE(hash[i], i);
+ }
+ {
+ QHash<int, int> hash;
+ hash.insert(0, 5);
+
+ QHash<int, int> hash2;
+
+ hash.insert(hash2);
+
+ QCOMPARE(hash.count(), 1);
+ QCOMPARE(hash[0], 5);
+ }
+ {
+ QHash<int, int> hash;
+ QHash<int, int> hash2;
+ hash2.insert(0, 5);
+
+ hash.insert(hash2);
+
+ QCOMPARE(hash.count(), 1);
+ QCOMPARE(hash[0], 5);
+ QCOMPARE(hash, hash2);
+ }
+ {
+ QHash<int, int> hash;
+ hash.insert(0, 7);
+ hash.insert(2, 5);
+ hash.insert(7, 55);
+
+ // insert into ourself, nothing should happen
+ hash.insert(hash);
+
+ QCOMPARE(hash.count(), 3);
+ QCOMPARE(hash[0], 7);
+ QCOMPARE(hash[2], 5);
+ QCOMPARE(hash[7], 55);
+ }
+ {
+ // This will use a QMultiHash and then insert that into QHash,
+ // the ordering is undefined so we won't test that but make
+ // sure this isn't adding multiple entries with the same key
+ // to the QHash.
+ QHash<int, int> hash;
+ QMultiHash<int, int> hash2;
+ hash2.insert(0, 5);
+ hash2.insert(0, 6);
+ hash2.insert(0, 7);
+
+ hash.insert(hash2);
+
+ QCOMPARE(hash.count(), 1);
+ }
+}
+
QTEST_APPLESS_MAIN(tst_QHash)
#include "tst_qhash.moc"
diff --git a/tests/auto/gui/rhi/qrhi/tst_qrhi.cpp b/tests/auto/gui/rhi/qrhi/tst_qrhi.cpp
index 302630ae15..6f88b7fab5 100644
--- a/tests/auto/gui/rhi/qrhi/tst_qrhi.cpp
+++ b/tests/auto/gui/rhi/qrhi/tst_qrhi.cpp
@@ -73,6 +73,8 @@ private slots:
void create();
void nativeHandles_data();
void nativeHandles();
+ void nativeTexture_data();
+ void nativeTexture();
void resourceUpdateBatchBuffer_data();
void resourceUpdateBatchBuffer();
void resourceUpdateBatchRGBATextureUpload_data();
@@ -528,6 +530,71 @@ void tst_QRhi::nativeHandles()
}
}
+void tst_QRhi::nativeTexture_data()
+{
+ rhiTestData();
+}
+
+void tst_QRhi::nativeTexture()
+{
+ QFETCH(QRhi::Implementation, impl);
+ QFETCH(QRhiInitParams *, initParams);
+
+ QScopedPointer<QRhi> rhi(QRhi::create(impl, initParams, QRhi::Flags(), nullptr));
+ if (!rhi)
+ QSKIP("QRhi could not be created, skipping testing native texture");
+
+ QScopedPointer<QRhiTexture> tex(rhi->newTexture(QRhiTexture::RGBA8, QSize(512, 256)));
+ QVERIFY(tex->build());
+
+ const QRhiTexture::NativeTexture nativeTex = tex->nativeTexture();
+
+ switch (impl) {
+ case QRhi::Null:
+ break;
+#ifdef TST_VK
+ case QRhi::Vulkan:
+ {
+ auto *image = static_cast<const VkImage *>(nativeTex.object);
+ QVERIFY(image);
+ QVERIFY(*image);
+ QVERIFY(nativeTex.layout >= 1); // VK_IMAGE_LAYOUT_GENERAL
+ QVERIFY(nativeTex.layout <= 8); // VK_IMAGE_LAYOUT_PREINITIALIZED
+ }
+ break;
+#endif
+#ifdef TST_GL
+ case QRhi::OpenGLES2:
+ {
+ auto *textureId = static_cast<const uint *>(nativeTex.object);
+ QVERIFY(textureId);
+ QVERIFY(*textureId);
+ }
+ break;
+#endif
+#ifdef TST_D3D11
+ case QRhi::D3D11:
+ {
+ auto *texture = static_cast<void * const *>(nativeTex.object);
+ QVERIFY(texture);
+ QVERIFY(*texture);
+ }
+ break;
+#endif
+#ifdef TST_MTL
+ case QRhi::Metal:
+ {
+ void * const * texture = (void * const *)nativeTex.object;
+ QVERIFY(texture);
+ QVERIFY(*texture);
+ }
+ break;
+#endif
+ default:
+ Q_ASSERT(false);
+ }
+}
+
static bool submitResourceUpdates(QRhi *rhi, QRhiResourceUpdateBatch *batch)
{
QRhiCommandBuffer *cb = nullptr;
diff --git a/tests/auto/gui/util/qdoublevalidator/tst_qdoublevalidator.cpp b/tests/auto/gui/util/qdoublevalidator/tst_qdoublevalidator.cpp
index 012a7e2ce3..366f3b6fdf 100644
--- a/tests/auto/gui/util/qdoublevalidator/tst_qdoublevalidator.cpp
+++ b/tests/auto/gui/util/qdoublevalidator/tst_qdoublevalidator.cpp
@@ -73,6 +73,7 @@ void tst_QDoubleValidator::validateThouSep_data()
QTest::newRow("1.000,1de_reject") << "de" << QString("1.000,1") << true << INV;
QTest::newRow(",C") << "C" << QString(",") << false << INV;
QTest::newRow(",de") << "de" << QString(",") << false << ITM;
+ QTest::newRow("1,23") << "en_AU" << QString("1,00") << false << ITM;
}
void tst_QDoubleValidator::validateThouSep()
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-26 17:09:56 +0000