Merge remote-tracking branch 'origin/dev' into merge-dev

Change-Id: I31b761cfd5ea01373c60d02a5da8c33398d34739

5 files changed, 414 insertions, 171 deletions

diff --git a/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp b/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp
index 90dfcaef25..e3009a78fb 100644
--- a/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp
+++ b/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp
@@ -149,36 +149,17 @@ private slots:
     void stdString();
 };
 
-static const struct StaticByteArrays {
-    struct Standard {
-        QByteArrayData data;
-        const char string[8];
-    } standard;
-    struct NotNullTerminated {
-        QByteArrayData data;
-        const char string[8];
-    } notNullTerminated;
-    struct Shifted {
-        QByteArrayData data;
-        const char dummy;  // added to change offset of string
-        const char string[8];
-    } shifted;
-    struct ShiftedNotNullTerminated {
-        QByteArrayData data;
-        const char dummy;  // added to change offset of string
-        const char string[8];
-    } shiftedNotNullTerminated;
-
-} statics = {{Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER(4), "data"}
-             ,{Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER(4), "dataBAD"}
-             ,{Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(4, sizeof(QByteArrayData) + sizeof(char)), 0, "data"}
-             ,{Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(4, sizeof(QByteArrayData) + sizeof(char)), 0, "dataBAD"}
-            };
-
-static const QByteArrayDataPtr staticStandard = { const_cast<QByteArrayData *>(&statics.standard.data) };
-static const QByteArrayDataPtr staticNotNullTerminated = { const_cast<QByteArrayData *>(&statics.notNullTerminated.data) };
-static const QByteArrayDataPtr staticShifted = { const_cast<QByteArrayData *>(&statics.shifted.data) };
-static const QByteArrayDataPtr staticShiftedNotNullTerminated = { const_cast<QByteArrayData *>(&statics.shiftedNotNullTerminated.data) };
+static const QArrayData staticDataFlags = { Q_BASIC_ATOMIC_INITIALIZER(-1), QArrayData::StaticDataFlags, 0 };
+static const QByteArray::DataPointer staticStandard = {
+    static_cast<QTypedArrayData<char> *>(const_cast<QArrayData *>(&staticDataFlags)),
+    const_cast<char *>("data"),
+    4
+};
+static const QByteArray::DataPointer staticNotNullTerminated = {
+    static_cast<QTypedArrayData<char> *>(const_cast<QArrayData *>(&staticDataFlags)),
+    const_cast<char *>("dataBAD"),
+    4
+};
 
 template <class T> const T &verifyZeroTermination(const T &t) { return t; }
 
@@ -186,11 +167,10 @@ QByteArray verifyZeroTermination(const QByteArray &ba)
 {
     // This test does some evil stuff, it's all supposed to work.
 
-    QByteArray::DataPtr baDataPtr = const_cast<QByteArray &>(ba).data_ptr();
+    QByteArray::DataPointer baDataPtr = const_cast<QByteArray &>(ba).data_ptr();
 
     // Skip if isStatic() or fromRawData(), as those offer no guarantees
-    if (baDataPtr->ref.isStatic()
-            || baDataPtr->offset != QByteArray().data_ptr()->offset)
+    if (baDataPtr->isStatic() || baDataPtr->flags() & QArrayData::RawDataType)
         return ba;
 
     int baSize = ba.size();
@@ -201,7 +181,7 @@ QByteArray verifyZeroTermination(const QByteArray &ba)
                 .arg(baTerminator, 2, 16, QChar('0')).toLatin1();
 
     // Skip mutating checks on shared strings
-    if (baDataPtr->ref.isShared())
+    if (baDataPtr->isShared())
         return ba;
 
     const char *baData = ba.constData();
@@ -239,6 +219,8 @@ QByteArray verifyZeroTermination(const QByteArray &ba)
     } while (0)                                                         \
     /**/
 
+Q_DECLARE_METATYPE(QByteArray::Base64DecodingStatus);
+
 tst_QByteArray::tst_QByteArray()
 {
 }
@@ -251,11 +233,11 @@ void tst_QByteArray::qChecksum_data()
     QTest::addColumn<uint>("checksum");
 
     // Examples from ISO 14443-3
-    QTest::newRow("1") << QByteArray("\x00\x00")         << 2U << Qt::ChecksumItuV41  << 0x1EA0U;
-    QTest::newRow("2") << QByteArray("\x12\x34")         << 2U << Qt::ChecksumItuV41  << 0xCF26U;
-    QTest::newRow("3") << QByteArray("\x00\x00\x00")     << 3U << Qt::ChecksumIso3309 << 0xC6CCU;
-    QTest::newRow("4") << QByteArray("\x0F\xAA\xFF")     << 3U << Qt::ChecksumIso3309 << 0xD1FCU;
-    QTest::newRow("5") << QByteArray("\x0A\x12\x34\x56") << 4U << Qt::ChecksumIso3309 << 0xF62CU;
+    QTest::newRow("1") << QByteArray("\x00\x00", 2)         << 2U << Qt::ChecksumItuV41  << 0x1EA0U;
+    QTest::newRow("2") << QByteArray("\x12\x34", 2)         << 2U << Qt::ChecksumItuV41  << 0xCF26U;
+    QTest::newRow("3") << QByteArray("\x00\x00\x00", 3)     << 3U << Qt::ChecksumIso3309 << 0xC6CCU;
+    QTest::newRow("4") << QByteArray("\x0F\xAA\xFF", 3)     << 3U << Qt::ChecksumIso3309 << 0xD1FCU;
+    QTest::newRow("5") << QByteArray("\x0A\x12\x34\x56", 4) << 4U << Qt::ChecksumIso3309 << 0xF62CU;
 }
 
 void tst_QByteArray::qChecksum()
@@ -265,6 +247,7 @@ void tst_QByteArray::qChecksum()
     QFETCH(Qt::ChecksumType, standard);
     QFETCH(uint, checksum);
 
+    QCOMPARE(data.length(), int(len));
     if (standard == Qt::ChecksumIso3309) {
         QCOMPARE(::qChecksum(data.constData(), len), static_cast<quint16>(checksum));
     }
@@ -637,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);
@@ -668,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);
@@ -692,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;
 }
 
 
@@ -706,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());
     }
 }
 
@@ -950,9 +1035,7 @@ void tst_QByteArray::prependExtended_data()
     QTest::addColumn<QByteArray>("array");
     QTest::newRow("literal") << QByteArray(QByteArrayLiteral("data"));
     QTest::newRow("standard") << QByteArray(staticStandard);
-    QTest::newRow("shifted") << QByteArray(staticShifted);
     QTest::newRow("notNullTerminated") << QByteArray(staticNotNullTerminated);
-    QTest::newRow("shiftedNotNullTerminated") << QByteArray(staticShiftedNotNullTerminated);
     QTest::newRow("non static data") << QByteArray("data");
     QTest::newRow("from raw data") << QByteArray::fromRawData("data", 4);
     QTest::newRow("from raw data not terminated") << QByteArray::fromRawData("dataBAD", 4);
@@ -2018,21 +2101,13 @@ void tst_QByteArray::repeated_data() const
         << QByteArray(staticStandard)
         << QByteArray("datadatadatadata")
         << 4;
-    QTest::newRow("static shifted not null terminated")
-        << QByteArray(staticShiftedNotNullTerminated)
-        << QByteArray("datadatadatadata")
-        << 4;
-    QTest::newRow("static shifted")
-        << QByteArray(staticShifted)
-        << QByteArray("datadatadatadata")
-        << 4;
 }
 
 void tst_QByteArray::byteRefDetaching() const
 {
     {
         QByteArray str = "str";
-        QByteArray copy;
+        QByteArray copy = str;
         copy[0] = 'S';
 
         QCOMPARE(str, QByteArray("str"));
@@ -2162,7 +2237,7 @@ void tst_QByteArray::movablity()
     const int newSize = size + 2;
     const bool newIsEmpty = false;
     const bool newIsNull = false;
-    const int newCapacity = 16;
+    const int newCapacity = memSpace.capacity();
 
     // move back memSpace -> array
     array.~QByteArray();
@@ -2197,8 +2272,7 @@ void tst_QByteArray::literals()
 
     QVERIFY(str.length() == 4);
     QVERIFY(str == "abcd");
-    QVERIFY(str.data_ptr()->ref.isStatic());
-    QVERIFY(str.data_ptr()->offset == sizeof(QByteArrayData));
+    QVERIFY(str.data_ptr()->isStatic());
 
     const char *s = str.constData();
     QByteArray str2 = str;
diff --git a/tests/auto/corelib/text/qlocale/tst_qlocale.cpp b/tests/auto/corelib/text/qlocale/tst_qlocale.cpp
index 3aa3d97dbc..7b2d92f9cb 100644
--- a/tests/auto/corelib/text/qlocale/tst_qlocale.cpp
+++ b/tests/auto/corelib/text/qlocale/tst_qlocale.cpp
@@ -147,6 +147,8 @@ private slots:
     void systemLocale_data();
     void systemLocale();
 
+    void IndianNumberGrouping();
+
     // *** ORDER-DEPENDENCY *** (This Is Bad.)
     // Test order is determined by order of declaration here: *all* tests that
     // QLocale::setDefault() *must* appear *after* all other tests !
@@ -595,10 +597,7 @@ void tst_QLocale::emptyCtor_data()
     ADD_CTOR_TEST("zz_zz", "C");
     ADD_CTOR_TEST("zz...", "C");
     ADD_CTOR_TEST("en.bla", "en_US");
-#if !(defined(Q_OS_DARWIN) && QT_HAS_FEATURE(address_sanitizer))
-    // See QTBUG-69875
     ADD_CTOR_TEST("en@bla", "en_US");
-#endif
     ADD_CTOR_TEST("en_blaaa", "en_US");
     ADD_CTOR_TEST("en_zz", "en_US");
     ADD_CTOR_TEST("en_GB.bla", "en_GB");
@@ -607,10 +606,7 @@ void tst_QLocale::emptyCtor_data()
 
     // Empty optional fields, but with punctuators supplied
     ADD_CTOR_TEST("en.", "en_US");
-#if !(defined(Q_OS_DARWIN) && QT_HAS_FEATURE(address_sanitizer))
-    // See QTBUG-69875
     ADD_CTOR_TEST("en@", "en_US");
-#endif
     ADD_CTOR_TEST("en.@", "en_US");
     ADD_CTOR_TEST("en_", "en_US");
     ADD_CTOR_TEST("en_.", "en_US");
@@ -1346,7 +1342,7 @@ void tst_QLocale::long_long_conversion()
 void tst_QLocale::long_long_conversion_extra()
 {
     QLocale l(QLocale::C);
-    l.setNumberOptions(0);
+    l.setNumberOptions({ });
     QCOMPARE(l.toString((qlonglong)1), QString("1"));
     QCOMPARE(l.toString((qlonglong)12), QString("12"));
     QCOMPARE(l.toString((qlonglong)123), QString("123"));
@@ -2093,7 +2089,7 @@ void tst_QLocale::numberOptions()
     QVERIFY(ok);
     QCOMPARE(locale.toString(12345), QString("12345"));
 
-    locale.setNumberOptions(0);
+    locale.setNumberOptions({ });
     QCOMPARE(locale.numberOptions(), 0);
     QCOMPARE(locale.toInt(QString("12,345"), &ok), 12345);
     QVERIFY(ok);
@@ -2997,5 +2993,56 @@ void tst_QLocale::systemLocale()
     QCOMPARE(QLocale::system(), originalSystemLocale);
 }
 
+void tst_QLocale::IndianNumberGrouping()
+{
+    QLocale indian(QLocale::Hindi, QLocale::India);
+
+    qint8 int8 = 100;
+    QString strResult8("100");
+    QCOMPARE(indian.toString(int8), strResult8);
+    QCOMPARE(indian.toShort(strResult8), short(int8));
+
+    quint8 uint8 = 100;
+    QCOMPARE(indian.toString(uint8), strResult8);
+    QCOMPARE(indian.toShort(strResult8), short(uint8));
+
+    // Boundary case 1000 for short and ushort
+    short shortInt = 1000;
+    QString strResult16("1,000");
+    QCOMPARE(indian.toString(shortInt), strResult16);
+    QCOMPARE(indian.toShort(strResult16), shortInt);
+
+    ushort uShortInt = 1000;
+    QCOMPARE(indian.toString(uShortInt), strResult16);
+    QCOMPARE(indian.toUShort(strResult16), uShortInt);
+
+    shortInt = 10000;
+    strResult16 = "10,000";
+    QCOMPARE(indian.toString(shortInt), strResult16);
+    QCOMPARE(indian.toShort(strResult16), shortInt);
+
+    uShortInt = 10000;
+    QCOMPARE(indian.toString(uShortInt), strResult16);
+    QCOMPARE(indian.toUShort(strResult16), uShortInt);
+
+    int intInt = 1000000000;
+    QString strResult32("1,00,00,00,000");
+    QCOMPARE(indian.toString(intInt), strResult32);
+    QCOMPARE(indian.toInt(strResult32), intInt);
+
+    uint uIntInt = 1000000000;
+    QCOMPARE(indian.toString(uIntInt), strResult32);
+    QCOMPARE(indian.toUInt(strResult32), uIntInt);
+
+    QString strResult64("10,00,00,00,00,00,00,00,000");
+    qint64 int64 = Q_INT64_C(1000000000000000000);
+    QCOMPARE(indian.toString(int64), strResult64);
+    QCOMPARE(indian.toLongLong(strResult64), int64);
+
+    quint64 uint64 = Q_UINT64_C(1000000000000000000);
+    QCOMPARE(indian.toString(uint64), strResult64);
+    QCOMPARE(indian.toULongLong(strResult64), uint64);
+}
+
 QTEST_MAIN(tst_QLocale)
 #include "tst_qlocale.moc"
diff --git a/tests/auto/corelib/text/qregularexpression/tst_qregularexpression.cpp b/tests/auto/corelib/text/qregularexpression/tst_qregularexpression.cpp
index c02756d76a..83f9c17a42 100644
--- a/tests/auto/corelib/text/qregularexpression/tst_qregularexpression.cpp
+++ b/tests/auto/corelib/text/qregularexpression/tst_qregularexpression.cpp
@@ -365,22 +365,22 @@ void tst_QRegularExpression::provideRegularExpressions()
     QTest::addColumn<QRegularExpression::PatternOptions>("patternOptions");
 
     QTest::newRow("emptynull01") << QString()
-                                 << QRegularExpression::PatternOptions(0);
+                                 << QRegularExpression::PatternOptions{};
     QTest::newRow("emptynull02") << QString()
                                  << QRegularExpression::PatternOptions(QRegularExpression::CaseInsensitiveOption
                                                                        | QRegularExpression::DotMatchesEverythingOption
                                                                        | QRegularExpression::MultilineOption);
     QTest::newRow("emptynull03") << ""
-                                 << QRegularExpression::PatternOptions(0);
+                                 << QRegularExpression::PatternOptions{};
     QTest::newRow("emptynull04") << ""
                                  << QRegularExpression::PatternOptions(QRegularExpression::CaseInsensitiveOption
                                                                        | QRegularExpression::DotMatchesEverythingOption
                                                                        | QRegularExpression::MultilineOption);
 
     QTest::newRow("regexp01") << "a pattern"
-                              << QRegularExpression::PatternOptions(0);
+                              << QRegularExpression::PatternOptions{};
     QTest::newRow("regexp02") << "^a (.*) more complicated(?<P>pattern)$"
-                              << QRegularExpression::PatternOptions(0);
+                              << QRegularExpression::PatternOptions{};
     QTest::newRow("regexp03") << "(?:a) pAttErN"
                               << QRegularExpression::PatternOptions(QRegularExpression::CaseInsensitiveOption);
     QTest::newRow("regexp04") << "a\nmultiline\npattern"
@@ -397,13 +397,13 @@ void tst_QRegularExpression::provideRegularExpressions()
                                                                     | QRegularExpression::InvertedGreedinessOption);
 
     QTest::newRow("unicode01") << QString::fromUtf8("^s[ome] latin-1 \xc3\x80\xc3\x88\xc3\x8c\xc3\x92\xc3\x99 chars$")
-                               << QRegularExpression::PatternOptions(0);
+                               << QRegularExpression::PatternOptions{};
     QTest::newRow("unicode02") << QString::fromUtf8("^s[ome] latin-1 \xc3\x80\xc3\x88\xc3\x8c\xc3\x92\xc3\x99 chars$")
                                << QRegularExpression::PatternOptions(QRegularExpression::CaseInsensitiveOption
                                                                      | QRegularExpression::DotMatchesEverythingOption
                                                                      | QRegularExpression::InvertedGreedinessOption);
     QTest::newRow("unicode03") << QString::fromUtf8("Unicode \xf0\x9d\x85\x9d \xf0\x9d\x85\x9e\xf0\x9d\x85\x9f")
-                               << QRegularExpression::PatternOptions(0);
+                               << QRegularExpression::PatternOptions{};
     QTest::newRow("unicode04") << QString::fromUtf8("Unicode \xf0\x9d\x85\x9d \xf0\x9d\x85\x9e\xf0\x9d\x85\x9f")
                                << QRegularExpression::PatternOptions(QRegularExpression::CaseInsensitiveOption
                                                                      | QRegularExpression::DotMatchesEverythingOption
diff --git a/tests/auto/corelib/text/qstring/tst_qstring.cpp b/tests/auto/corelib/text/qstring/tst_qstring.cpp
index 2108e99f20..e5b5e526de 100644
--- a/tests/auto/corelib/text/qstring/tst_qstring.cpp
+++ b/tests/auto/corelib/text/qstring/tst_qstring.cpp
@@ -459,8 +459,8 @@ private slots:
     void trimmed();
     void toUpper();
     void toLower();
-    void isUpper();
-    void isLower();
+    void isLower_isUpper_data();
+    void isLower_isUpper();
     void toCaseFolded();
     void rightJustified();
     void leftJustified();
@@ -596,6 +596,8 @@ private slots:
     void assignQChar();
     void isRightToLeft_data();
     void isRightToLeft();
+    void isValidUtf16_data();
+    void isValidUtf16();
     void unicodeStrings();
 };
 
@@ -605,11 +607,10 @@ QString verifyZeroTermination(const QString &str)
 {
     // This test does some evil stuff, it's all supposed to work.
 
-    QString::DataPtr strDataPtr = const_cast<QString &>(str).data_ptr();
+    QString::DataPointer strDataPtr = const_cast<QString &>(str).data_ptr();
 
     // Skip if isStatic() or fromRawData(), as those offer no guarantees
-    if (strDataPtr->ref.isStatic()
-            || strDataPtr->offset != QString().data_ptr()->offset)
+    if (strDataPtr->isStatic() || !strDataPtr->isMutable())
         return str;
 
     int strSize = str.size();
@@ -620,7 +621,7 @@ QString verifyZeroTermination(const QString &str)
                 .arg(strTerminator.unicode(), 4, 16, QChar('0'));
 
     // Skip mutating checks on shared strings
-    if (strDataPtr->ref.isShared())
+    if (strDataPtr->isShared())
         return str;
 
     const QChar *strData = str.constData();
@@ -984,28 +985,6 @@ void tst_QString::acc_01()
     f[7]='F';
     QCOMPARE(text[7],'!');
 
-    a="";
-    a[0]='A';
-    QCOMPARE(a, QLatin1String("A"));
-    QCOMPARE(a.length(),1);
-    a[1]='B';
-    QCOMPARE(a, QLatin1String("AB"));
-    QCOMPARE(a.length(),2);
-    a[2]='C';
-    QCOMPARE(a, QLatin1String("ABC"));
-    QCOMPARE(a.length(),3);
-    a = QString();
-    QVERIFY(a.isNull());
-    a[0]='A';
-    QCOMPARE(a, QLatin1String("A"));
-    QCOMPARE(a.length(),1);
-    a[1]='B';
-    QCOMPARE(a, QLatin1String("AB"));
-    QCOMPARE(a.length(),2);
-    a[2]='C';
-    QCOMPARE(a, QLatin1String("ABC"));
-    QCOMPARE(a.length(),3);
-
     a="123";
     b="456";
     a[0]=a[1];
@@ -2311,44 +2290,83 @@ void tst_QString::toLower()
 #endif // icu
 }
 
-void tst_QString::isUpper()
-{
-    QVERIFY(!QString().isUpper());
-    QVERIFY(!QString("").isUpper());
-    QVERIFY(QString("TEXT").isUpper());
-    QVERIFY(!QString("text").isUpper());
-    QVERIFY(!QString("Text").isUpper());
-    QVERIFY(!QString("tExt").isUpper());
-    QVERIFY(!QString("teXt").isUpper());
-    QVERIFY(!QString("texT").isUpper());
-    QVERIFY(!QString("TExt").isUpper());
-    QVERIFY(!QString("teXT").isUpper());
-    QVERIFY(!QString("tEXt").isUpper());
-    QVERIFY(!QString("tExT").isUpper());
-    QVERIFY(!QString("@ABYZ[").isUpper());
-    QVERIFY(!QString("@abyz[").isUpper());
-    QVERIFY(!QString("`ABYZ{").isUpper());
-    QVERIFY(!QString("`abyz{").isUpper());
-}
-
-void tst_QString::isLower()
-{
-    QVERIFY(!QString().isLower());
-    QVERIFY(!QString("").isLower());
-    QVERIFY(QString("text").isLower());
-    QVERIFY(!QString("Text").isLower());
-    QVERIFY(!QString("tExt").isLower());
-    QVERIFY(!QString("teXt").isLower());
-    QVERIFY(!QString("texT").isLower());
-    QVERIFY(!QString("TExt").isLower());
-    QVERIFY(!QString("teXT").isLower());
-    QVERIFY(!QString("tEXt").isLower());
-    QVERIFY(!QString("tExT").isLower());
-    QVERIFY(!QString("TEXT").isLower());
-    QVERIFY(!QString("@ABYZ[").isLower());
-    QVERIFY(!QString("@abyz[").isLower());
-    QVERIFY(!QString("`ABYZ{").isLower());
-    QVERIFY(!QString("`abyz{").isLower());
+void tst_QString::isLower_isUpper_data()
+{
+    QTest::addColumn<QString>("string");
+    QTest::addColumn<bool>("isLower");
+    QTest::addColumn<bool>("isUpper");
+
+    int row = 0;
+    QTest::addRow("lower-and-upper-%02d", row++) << QString() << true << true;
+    QTest::addRow("lower-and-upper-%02d", row++) << QString("") << true << true;
+    QTest::addRow("lower-and-upper-%02d", row++) << QString(" ") << true << true;
+    QTest::addRow("lower-and-upper-%02d", row++) << QString("123") << true << true;
+    QTest::addRow("lower-and-upper-%02d", row++) << QString("@123$#") << true << true;
+    QTest::addRow("lower-and-upper-%02d", row++) << QString("𝄞𝄴𝆏♫") << true << true; // Unicode Block 'Musical Symbols'
+    // not foldable
+    QTest::addRow("lower-and-upper-%02d", row++) << QString("𝚊𝚋𝚌𝚍𝚎") << true << true; // MATHEMATICAL MONOSPACE SMALL A, ... E
+    QTest::addRow("lower-and-upper-%02d", row++) << QString("𝙖,𝙗,𝙘,𝙙,𝙚") << true << true; // MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL A, ... E
+    QTest::addRow("lower-and-upper-%02d", row++) << QString("𝗔𝗕𝗖𝗗𝗘") << true << true; // MATHEMATICAL SANS-SERIF BOLD CAPITAL A, ... E
+    QTest::addRow("lower-and-upper-%02d", row++) << QString("𝐀,𝐁,𝐂,𝐃,𝐄") << true << true; // MATHEMATICAL BOLD CAPITAL A, ... E
+
+    row = 0;
+    QTest::addRow("only-lower-%02d", row++) << QString("text") << true << false;
+    QTest::addRow("only-lower-%02d", row++) << QString("àaa") << true << false;
+    QTest::addRow("only-lower-%02d", row++) << QString("øæß") << true << false;
+    QTest::addRow("only-lower-%02d", row++) << QString("text ") << true << false;
+    QTest::addRow("only-lower-%02d", row++) << QString(" text") << true << false;
+    QTest::addRow("only-lower-%02d", row++) << QString("hello, world!") << true << false;
+    QTest::addRow("only-lower-%02d", row++) << QString("123@abyz[") << true << false;
+    QTest::addRow("only-lower-%02d", row++) << QString("`abyz{") << true << false;
+    QTest::addRow("only-lower-%02d", row++) << QString("a𝙖a|b𝙗b|c𝙘c|d𝙙d|e𝙚e") << true << false; // MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL A, ... E
+    QTest::addRow("only-lower-%02d", row++) << QString("𐐨") << true << false; // DESERET SMALL LETTER LONG I
+    // uppercase letters, not foldable
+    QTest::addRow("only-lower-%02d", row++) << QString("text𝗔text") << true << false; // MATHEMATICAL SANS-SERIF BOLD CAPITAL A
+
+    row = 0;
+    QTest::addRow("only-upper-%02d", row++) << QString("TEXT") << false << true;
+    QTest::addRow("only-upper-%02d", row++) << QString("ÀAA") << false << true;
+    QTest::addRow("only-upper-%02d", row++) << QString("ØÆẞ") << false << true;
+    QTest::addRow("only-upper-%02d", row++) << QString("TEXT ") << false << true;
+    QTest::addRow("only-upper-%02d", row++) << QString(" TEXT") << false << true;
+    QTest::addRow("only-upper-%02d", row++) << QString("HELLO, WORLD!") << false << true;
+    QTest::addRow("only-upper-%02d", row++) << QString("123@ABYZ[") << false << true;
+    QTest::addRow("only-upper-%02d", row++) << QString("`ABYZ{") << false << true;
+    QTest::addRow("only-upper-%02d", row++) << QString("A𝐀A|B𝐁B|C𝐂C|D𝐃D|E𝐄E") << false << true; // MATHEMATICAL BOLD CAPITAL A, ... E
+    QTest::addRow("only-upper-%02d", row++) << QString("𐐀") << false << true; // DESERET CAPITAL LETTER LONG I
+    // lowercase letters, not foldable
+    QTest::addRow("only-upper-%02d", row++) << QString("TEXT𝚊TEXT") << false << true; // MATHEMATICAL MONOSPACE SMALL A
+
+    row = 0;
+    QTest::addRow("not-lower-nor-upper-%02d", row++) << QString("Text") << false << false;
+    QTest::addRow("not-lower-nor-upper-%02d", row++) << QString("tExt") << false << false;
+    QTest::addRow("not-lower-nor-upper-%02d", row++) << QString("teXt") << false << false;
+    QTest::addRow("not-lower-nor-upper-%02d", row++) << QString("texT") << false << false;
+    QTest::addRow("not-lower-nor-upper-%02d", row++) << QString("TExt") << false << false;
+    QTest::addRow("not-lower-nor-upper-%02d", row++) << QString("teXT") << false << false;
+    QTest::addRow("not-lower-nor-upper-%02d", row++) << QString("tEXt") << false << false;
+    QTest::addRow("not-lower-nor-upper-%02d", row++) << QString("tExT") << false << false;
+    // not foldable
+    QTest::addRow("not-lower-nor-upper-%02d", row++) << QString("TEXT𝚊text") << false << false; // MATHEMATICAL MONOSPACE SMALL A
+    QTest::addRow("not-lower-nor-upper-%02d", row++) << QString("text𝗔TEXT") << false << false; // MATHEMATICAL SANS-SERIF BOLD CAPITAL A
+    // titlecase, foldable
+    QTest::addRow("not-lower-nor-upper-%02d", row++) << QString("abcLjdef") << false << false; // LATIN CAPITAL LETTER L WITH SMALL LETTER J
+    QTest::addRow("not-lower-nor-upper-%02d", row++) << QString("ABCLjDEF") << false << false; // LATIN CAPITAL LETTER L WITH SMALL LETTER J
+}
+
+void tst_QString::isLower_isUpper()
+{
+    QFETCH(QString, string);
+    QFETCH(bool, isLower);
+    QFETCH(bool, isUpper);
+
+    QCOMPARE(string.isLower(), isLower);
+    QCOMPARE(string.toLower() == string, isLower);
+    QVERIFY(string.toLower().isLower());
+
+    QCOMPARE(string.isUpper(), isUpper);
+    QCOMPARE(string.toUpper() == string, isUpper);
+    QVERIFY(string.toUpper().isUpper());
 }
 
 void tst_QString::toCaseFolded()
@@ -4069,8 +4087,9 @@ void tst_QString::setRawData()
     QVERIFY(cstr.constData() == ptr);
     QVERIFY(cstr == QString(ptr, 1));
 
+    QSKIP("This is currently not working.");
     // This actually tests the recycling of the shared data object
-    QString::DataPtr csd = cstr.data_ptr();
+    QString::DataPointer csd = cstr.data_ptr();
     cstr.setRawData(ptr2, 1);
     QVERIFY(cstr.isDetached());
     QVERIFY(cstr.constData() == ptr2);
@@ -6416,7 +6435,7 @@ void tst_QString::QCharRefDetaching() const
 {
     {
         QString str = QString::fromLatin1("str");
-        QString copy;
+        QString copy = str;
         copy[0] = QLatin1Char('S');
 
         QCOMPARE(str, QString::fromLatin1("str"));
@@ -6637,8 +6656,7 @@ void tst_QString::literals()
 
     QVERIFY(str.length() == 4);
     QVERIFY(str == QLatin1String("abcd"));
-    QVERIFY(str.data_ptr()->ref.isStatic());
-    QVERIFY(str.data_ptr()->offset == sizeof(QStringData));
+    QVERIFY(str.data_ptr()->isStatic());
 
     const QChar *s = str.constData();
     QString str2 = str;
@@ -7025,6 +7043,52 @@ void tst_QString::isRightToLeft()
     QCOMPARE(unicode.isRightToLeft(), rtl);
 }
 
+void tst_QString::isValidUtf16_data()
+{
+    QTest::addColumn<QString>("string");
+    QTest::addColumn<bool>("valid");
+
+    int row = 0;
+    QTest::addRow("valid-%02d", row++) << QString() << true;
+    QTest::addRow("valid-%02d", row++) << QString("") << true;
+    QTest::addRow("valid-%02d", row++) << QString("abc def") << true;
+    QTest::addRow("valid-%02d", row++) << QString("àbç") << true;
+    QTest::addRow("valid-%02d", row++) << QString("ßẞ") << true;
+    QTest::addRow("valid-%02d", row++) << QString("𝐀𝐁𝐂abc𝐃𝐄𝐅def") << true;
+    QTest::addRow("valid-%02d", row++) << QString("abc𝐀𝐁𝐂def𝐃𝐄𝐅") << true;
+    QTest::addRow("valid-%02d", row++) << (QString("abc") + QChar(0x0000) + QString("def")) << true;
+    QTest::addRow("valid-%02d", row++) << (QString("abc") + QChar(0xFFFF) + QString("def")) << true;
+    // check that BOM presence doesn't make any difference
+    QTest::addRow("valid-%02d", row++) << (QString() + QChar(0xFEFF) + QString("abc𝐀𝐁𝐂def𝐃𝐄𝐅")) << true;
+    QTest::addRow("valid-%02d", row++) << (QString() + QChar(0xFFFE) + QString("abc𝐀𝐁𝐂def𝐃𝐄𝐅")) << true;
+
+    row = 0;
+    QTest::addRow("stray-high-%02d", row++) << (QString() + QChar(0xD800)) << false;
+    QTest::addRow("stray-high-%02d", row++) << (QString() + QString("abc") + QChar(0xD800)) << false;
+    QTest::addRow("stray-high-%02d", row++) << (QString() + QChar(0xD800) + QString("def")) << false;
+    QTest::addRow("stray-high-%02d", row++) << (QString() + QString("abc") + QChar(0xD800) + QString("def")) << false;
+    QTest::addRow("stray-high-%02d", row++) << (QString() + QChar(0xD800) + QChar(0xD800)) << false;
+    QTest::addRow("stray-high-%02d", row++) << (QString() + QString("abc") + QChar(0xD800) + QChar(0xD800)) << false;
+    QTest::addRow("stray-high-%02d", row++) << (QString() + QChar(0xD800) + QChar(0xD800) + QString("def")) << false;
+    QTest::addRow("stray-high-%02d", row++) << (QString() + QString("abc") + QChar(0xD800) + QChar(0xD800) + QString("def")) << false;
+
+    row = 0;
+    QTest::addRow("stray-low-%02d", row++) << (QString() + QChar(0xDC00)) << false;
+    QTest::addRow("stray-low-%02d", row++) << (QString() + QString("abc") + QChar(0xDC00)) << false;
+    QTest::addRow("stray-low-%02d", row++) << (QString() + QChar(0xDC00) + QString("def")) << false;
+    QTest::addRow("stray-low-%02d", row++) << (QString() + QString("abc") + QChar(0xDC00) + QString("def")) << false;
+    QTest::addRow("stray-low-%02d", row++) << (QString() + QChar(0xDC00) + QChar(0xDC00)) << false;
+    QTest::addRow("stray-low-%02d", row++) << (QString() + QString("abc") + QChar(0xDC00) + QChar(0xDC00)) << false;
+    QTest::addRow("stray-low-%02d", row++) << (QString() + QChar(0xDC00) + QChar(0xDC00) + QString("def")) << false;
+    QTest::addRow("stray-low-%02d", row++) << (QString() + QString("abc") + QChar(0xDC00) + QChar(0xDC00) + QString("def")) << false;
+}
+
+void tst_QString::isValidUtf16()
+{
+    QFETCH(QString, string);
+    QTEST(string.isValidUtf16(), "valid");
+}
+
 QTEST_APPLESS_MAIN(tst_QString)
 
 #include "tst_qstring.moc"
diff --git a/tests/auto/corelib/text/qstringview/tst_qstringview.cpp b/tests/auto/corelib/text/qstringview/tst_qstringview.cpp
index 47ce9a6f63..631bcce508 100644
--- a/tests/auto/corelib/text/qstringview/tst_qstringview.cpp
+++ b/tests/auto/corelib/text/qstringview/tst_qstringview.cpp
@@ -221,6 +221,8 @@ private Q_SLOTS:
 
     void comparison();
 
+    void overloadResolution();
+
 private:
     template <typename String>
     void conversion_tests(String arg) const;
@@ -678,5 +680,61 @@ void tst_QStringView::comparison()
     QVERIFY(bb.compare(aa) > 0);
 }
 
+namespace QStringViewOverloadResolution {
+static void test(QString) = delete;
+static void test(QStringView) {}
+}
+
+// Compile-time only test: overload resolution prefers QStringView over QString
+void tst_QStringView::overloadResolution()
+{
+    {
+        QChar qcharArray[42] = {};
+        QStringViewOverloadResolution::test(qcharArray);
+        QChar *qcharPointer = qcharArray;
+        QStringViewOverloadResolution::test(qcharPointer);
+    }
+
+    {
+        ushort ushortArray[42] = {};
+        QStringViewOverloadResolution::test(ushortArray);
+        ushort *ushortPointer = ushortArray;
+        QStringViewOverloadResolution::test(ushortPointer);
+    }
+
+    {
+        QStringRef stringRef;
+        QStringViewOverloadResolution::test(stringRef);
+        QStringViewOverloadResolution::test(qAsConst(stringRef));
+        QStringViewOverloadResolution::test(std::move(stringRef));
+    }
+
+#if defined(Q_OS_WIN)
+    {
+        wchar_t wchartArray[42] = {};
+        QStringViewOverloadResolution::test(wchartArray);
+        QStringViewOverloadResolution::test(L"test");
+    }
+#endif
+
+#if defined(Q_COMPILER_UNICODE_STRINGS)
+    {
+        char16_t char16Array[] = u"test";
+        QStringViewOverloadResolution::test(char16Array);
+        char16_t *char16Pointer = char16Array;
+        QStringViewOverloadResolution::test(char16Pointer);
+    }
+#endif
+
+#if defined(Q_STDLIB_UNICODE_STRINGS)
+    {
+        std::u16string string;
+        QStringViewOverloadResolution::test(string);
+        QStringViewOverloadResolution::test(qAsConst(string));
+        QStringViewOverloadResolution::test(std::move(string));
+    }
+#endif
+}
+
 QTEST_APPLESS_MAIN(tst_QStringView)
 #include "tst_qstringview.moc"