Teach QByteArrayView how to parse numbers

Now that we don't need '\0'-termination on the data, this is possible.
Moved QByteArray's tests to tst_QByteArrayApiSymmetry and added some
more test-cases.

[ChangeLog][QtCore][QByteArrayView] Added numeric parsing methods.

Change-Id: Ic0df91ecfe5dbf6f008d344dd0464d7927f32273
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>

1 files changed, 0 insertions, 574 deletions

diff --git a/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp b/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp
index ff04eca14d..a4798e77aa 100644
--- a/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp
+++ b/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp
@@ -36,7 +36,6 @@
 #include <private/qtools_p.h>
 
 #include "../shared/test_number_shared.h"
-#include <limits>
 
 class tst_QByteArray : public QObject
 {
@@ -90,29 +89,12 @@ private slots:
     void replace_data();
     void replace();
     void replaceWithSpecifiedLength();
-    void toLong_data();
-    void toLong();
-    void toULong_data();
-    void toULong();
-    void toLongLong_data();
-    void toLongLong();
-    void toULongLong_data();
-    void toULongLong();
 
     void number();
     void number_double_data();
     void number_double();
     void number_base_data();
     void number_base();
-    void toShort();
-    void toUShort();
-    void toInt_data();
-    void toInt();
-    void toUInt_data();
-    void toUInt();
-    void toFloat();
-    void toDouble_data();
-    void toDouble();
     void blockSizeCalculations();
 
     void resizeAfterFromRawData();
@@ -1379,560 +1361,6 @@ void tst_QByteArray::number_base()
     }
 }
 
-void tst_QByteArray::toShort()
-{
-    bool ok = true; // opposite to the next expected result
-
-    QCOMPARE(QByteArray().toShort(&ok), 0);
-    QVERIFY(!ok);
-
-    QCOMPARE(QByteArray("").toShort(&ok), 0);
-    QVERIFY(!ok);
-
-    QCOMPARE(QByteArray("12345").toShort(&ok), 12345);
-    QVERIFY(ok);
-
-    QCOMPARE(QByteArray("-12345").toShort(&ok), -12345);
-    QVERIFY(ok);
-
-    QCOMPARE(QByteArray("32767").toShort(&ok), 32767);
-    QVERIFY(ok);
-
-    QCOMPARE(QByteArray("-32768").toShort(&ok), -32768);
-    QVERIFY(ok);
-
-    QCOMPARE(QByteArray("32768").toShort(&ok), 0);
-    QVERIFY(!ok);
-
-    QCOMPARE(QByteArray("-32769").toShort(&ok), 0);
-    QVERIFY(!ok);
-}
-
-void tst_QByteArray::toUShort()
-{
-    bool ok = true; // opposite to the next expected result
-
-    QCOMPARE(QByteArray().toUShort(&ok), 0);
-    QVERIFY(!ok);
-
-    QCOMPARE(QByteArray("").toUShort(&ok), 0);
-    QVERIFY(!ok);
-
-    QCOMPARE(QByteArray("12345").toUShort(&ok), 12345);
-    QVERIFY(ok);
-
-    QCOMPARE(QByteArray("-12345").toUShort(&ok), 0);
-    QVERIFY(!ok);
-
-    QCOMPARE(QByteArray("32767").toUShort(&ok), 32767);
-    QVERIFY(ok);
-
-    QCOMPARE(QByteArray("32768").toUShort(&ok), 32768);
-    QVERIFY(ok);
-
-    QCOMPARE(QByteArray("65535").toUShort(&ok), 65535);
-    QVERIFY(ok);
-
-    QCOMPARE(QByteArray("65536").toUShort(&ok), 0);
-    QVERIFY(!ok);
-}
-
-// defined later
-extern const char globalChar;
-
-void tst_QByteArray::toInt_data()
-{
-    QTest::addColumn<QByteArray>("string");
-    QTest::addColumn<int>("base");
-    QTest::addColumn<int>("expectednumber");
-    QTest::addColumn<bool>("expectedok");
-
-    QTest::newRow("null") << QByteArray() << 10 << 0 << false;
-    QTest::newRow("empty") << QByteArray("") << 10 << 0 << false;
-
-    QTest::newRow("base 10") << QByteArray("100") << 10 << int(100) << true;
-    QTest::newRow("base 16-1") << QByteArray("100") << 16 << int(256) << true;
-    QTest::newRow("base 16-2") << QByteArray("0400") << 16 << int(1024) << true;
-    QTest::newRow("base 2") << QByteArray("1111") << 2 << int(15) << true;
-    QTest::newRow("base 8") << QByteArray("100") << 8 << int(64) << true;
-    QTest::newRow("base 0-1") << QByteArray("0x10") << 0 << int(16) << true;
-    QTest::newRow("base 0-2") << QByteArray("10") << 0 << int(10) << true;
-    QTest::newRow("base 0-3") << QByteArray("010") << 0 << int(8) << true;
-    QTest::newRow("empty") << QByteArray() << 0 << int(0) << false;
-
-    QTest::newRow("leading space") << QByteArray(" 100") << 10 << int(100) << true;
-    QTest::newRow("trailing space") << QByteArray("100 ") << 10 << int(100) << true;
-    QTest::newRow("leading junk") << QByteArray("x100") << 10 << int(0) << false;
-    QTest::newRow("trailing junk") << QByteArray("100x") << 10 << int(0) << false;
-
-    // using fromRawData
-    QTest::newRow("raw1") << QByteArray::fromRawData("1", 1) << 10 << 1 << true;
-    QTest::newRow("raw2") << QByteArray::fromRawData("1foo", 1) << 10 << 1 << true;
-    QTest::newRow("raw3") << QByteArray::fromRawData("12", 1) << 10 << 1 << true;
-    QTest::newRow("raw4") << QByteArray::fromRawData("123456789", 1) << 10 << 1 << true;
-    QTest::newRow("raw5") << QByteArray::fromRawData("123456789", 2) << 10 << 12 << true;
-
-    QTest::newRow("raw-static") << QByteArray::fromRawData(&globalChar, 1) << 10 << 1 << true;
-}
-
-void tst_QByteArray::toInt()
-{
-    QFETCH( QByteArray, string );
-    QFETCH( int, base );
-    QFETCH( int, expectednumber );
-    QFETCH( bool, expectedok );
-
-    bool ok;
-    int number = string.toInt(&ok, base);
-
-    QCOMPARE( ok, expectedok );
-    QCOMPARE( number, expectednumber );
-}
-
-void tst_QByteArray::toUInt_data()
-{
-    QTest::addColumn<QByteArray>("string");
-    QTest::addColumn<int>("base");
-    QTest::addColumn<uint>("expectednumber");
-    QTest::addColumn<bool>("expectedok");
-
-    QTest::newRow("null") << QByteArray() << 10 << 0u << false;
-    QTest::newRow("empty") << QByteArray("") << 10 << 0u << false;
-
-    QTest::newRow("negative value") << QByteArray("-50") << 10 << 0u << false;
-    QTest::newRow("more than MAX_INT") << QByteArray("3234567890") << 10 << 3234567890u << true;
-    QTest::newRow("2^32 - 1") << QByteArray("4294967295") << 10 << 4294967295u << true;
-    if (sizeof(int) == 4)
-        QTest::newRow("2^32") << QByteArray("4294967296") << 10 << 0u << false;
-}
-
-void tst_QByteArray::toUInt()
-{
-    QFETCH(QByteArray, string);
-    QFETCH(int, base);
-    QFETCH(uint, expectednumber);
-    QFETCH(bool, expectedok);
-
-    bool ok;
-    const uint number = string.toUInt(&ok, base);
-
-    QCOMPARE(ok, expectedok);
-    QCOMPARE(number, expectednumber);
-}
-
-void tst_QByteArray::toFloat()
-{
-    bool ok = true; // opposite to the next expected result
-
-    QCOMPARE(QByteArray().toFloat(&ok), 0.0f);
-    QVERIFY(!ok);
-
-    QCOMPARE(QByteArray("").toFloat(&ok), 0.0f);
-    QVERIFY(!ok);
-
-    const QByteArray data("0.000000000931322574615478515625");
-    const float expectedValue = 9.31322574615478515625e-10f;
-    QCOMPARE(data.toFloat(&ok), expectedValue);
-    QVERIFY(ok);
-}
-
-void tst_QByteArray::toDouble_data()
-{
-    QTest::addColumn<QByteArray>("string");
-    QTest::addColumn<double>("expectedNumber");
-    QTest::addColumn<bool>("expectedOk");
-
-    QTest::newRow("null") << QByteArray() << 0.0 << false;
-    QTest::newRow("empty") << QByteArray("") << 0.0 << false;
-
-    QTest::newRow("decimal") << QByteArray("1.2345") << 1.2345 << true;
-    QTest::newRow("exponent lowercase") << QByteArray("1.2345e+01") << 12.345 << true;
-    QTest::newRow("exponent uppercase") << QByteArray("1.2345E+02") << 123.45 << true;
-    QTest::newRow("leading spaces") << QByteArray(" \n\r\t1.2345") << 1.2345 << true;
-    QTest::newRow("trailing spaces") << QByteArray("1.2345 \n\r\t") << 1.2345 << true;
-    QTest::newRow("leading junk") << QByteArray("x1.2345") << 0.0 << false;
-    QTest::newRow("trailing junk") << QByteArray("1.2345x") << 0.0 << false;
-    QTest::newRow("high precision") << QByteArray("0.000000000931322574615478515625")
-                                    << 0.000000000931322574615478515625 << true;
-
-    QTest::newRow("raw, null plus junk") << QByteArray::fromRawData("1.2\0 junk", 9) << 0.0 << false;
-    QTest::newRow("raw, null-terminator not included") << QByteArray::fromRawData("2.3", 3) << 2.3 << true;
-}
-
-void tst_QByteArray::toDouble()
-{
-    QFETCH(QByteArray, string);
-    QFETCH(double, expectedNumber);
-    QFETCH(bool, expectedOk);
-
-    bool ok;
-    const double number = string.toDouble(&ok);
-
-    QCOMPARE(ok, expectedOk);
-    QCOMPARE(number, expectedNumber);
-}
-
-void tst_QByteArray::toLong_data()
-{
-    QTest::addColumn<QByteArray>("str");
-    QTest::addColumn<int>("base");
-    QTest::addColumn<long>("result");
-    QTest::addColumn<bool>("ok");
-
-    QTest::newRow("null") << QByteArray() << 10 << 0L << false;
-    QTest::newRow("empty") << QByteArray("") << 16 << 0L << false;
-    QTest::newRow("in range dec") << QByteArray("1608507359") << 10 << 1608507359L << true;
-    QTest::newRow("in range dec neg") << QByteArray("-1608507359") << 10 << -1608507359L << true;
-    QTest::newRow("in range hex") << QByteArray("12ABCDEF") << 16 << 0x12ABCDEFL << true;
-    QTest::newRow("in range hex neg") << QByteArray("-12ABCDEF") << 16 << -0x12ABCDEFL << true;
-    QTest::newRow("Fibonacci's last int32") << QByteArray("1836311903") << 10 << 1836311903L
-                                            << true;
-
-    QTest::newRow("leading spaces") << QByteArray(" \r\n\tABC123") << 16 << 0xABC123L << true;
-    QTest::newRow("trailing spaces") << QByteArray("1234567\t\r \n") << 10 << 1234567L << true;
-    QTest::newRow("leading junk") << QByteArray("q12345") << 10 << 0L << false;
-    QTest::newRow("trailing junk") << QByteArray("abc12345t") << 16 << 0L << false;
-
-    QTest::newRow("dec with base 0") << QByteArray("123") << 0 << 123L << true;
-    QTest::newRow("neg dec with base 0") << QByteArray("-123") << 0 << -123L << true;
-    QTest::newRow("hex with base 0") << QByteArray("0x123") << 0 << 0x123L << true;
-    QTest::newRow("neg hex with base 0") << QByteArray("-0x123") << 0 << -0x123L << true;
-    QTest::newRow("oct with base 0") << QByteArray("0123") << 0 << 0123L << true;
-    QTest::newRow("neg oct with base 0") << QByteArray("-0123") << 0 << -0123L << true;
-
-    QTest::newRow("base 3") << QByteArray("12012") << 3 << 140L << true;
-    QTest::newRow("neg base 3") << QByteArray("-201") << 3 << -19L << true;
-
-    using Bounds = std::numeric_limits<long>;
-    QTest::newRow("long max") << QByteArray::number(Bounds::max()) << 10 << Bounds::max() << true;
-    QTest::newRow("long min") << QByteArray::number(Bounds::min()) << 10 << Bounds::min() << true;
-
-    using B32 = std::numeric_limits<qint32>;
-    QTest::newRow("int32 min bin") << (QByteArray("-1") + QByteArray(31, '0')) << 2
-                                   << long(B32::min()) << true;
-    QTest::newRow("int32 max bin") << QByteArray(31, '1') << 2 << long(B32::max()) << true;
-    QTest::newRow("int32 min hex") << QByteArray("-80000000") << 16 << long(B32::min()) << true;
-    QTest::newRow("int32 max hex") << QByteArray("7fffffff") << 16 << long(B32::max()) << true;
-    QTest::newRow("int32 min dec") << QByteArray("-2147483648") << 10 << long(B32::min()) << true;
-    QTest::newRow("int32 max dec") << QByteArray("2147483647") << 10 << long(B32::max()) << true;
-
-    if constexpr (sizeof(long) < sizeof(qlonglong)) {
-        const qlonglong longMaxPlusOne = static_cast<qlonglong>(Bounds::max()) + 1;
-        const qlonglong longMinMinusOne = static_cast<qlonglong>(Bounds::min()) - 1;
-        QTest::newRow("long max + 1") << QByteArray::number(longMaxPlusOne) << 10 << 0L << false;
-        QTest::newRow("long min - 1") << QByteArray::number(longMinMinusOne) << 10 << 0L << false;
-    }
-}
-
-void tst_QByteArray::toLong()
-{
-    QFETCH(QByteArray, str);
-    QFETCH(int, base);
-    QFETCH(long, result);
-    QFETCH(bool, ok);
-
-    bool b;
-    QCOMPARE(str.toLong(nullptr, base), result);
-    QCOMPARE(str.toLong(&b, base), result);
-    QCOMPARE(b, ok);
-    if (base == 10) {
-        // check that by default base is assumed to be 10
-        QCOMPARE(str.toLong(&b), result);
-        QCOMPARE(b, ok);
-    }
-}
-
-void tst_QByteArray::toULong_data()
-{
-    QTest::addColumn<QByteArray>("str");
-    QTest::addColumn<int>("base");
-    QTest::addColumn<ulong>("result");
-    QTest::addColumn<bool>("ok");
-
-    ulong LongMaxPlusOne = (ulong)LONG_MAX + 1;
-    QTest::newRow("LONG_MAX+1") << QString::number(LongMaxPlusOne).toUtf8() << 10 << LongMaxPlusOne << true;
-    QTest::newRow("null") << QByteArray() << 10 << 0UL << false;
-    QTest::newRow("empty") << QByteArray("") << 10 << 0UL << false;
-    QTest::newRow("ulong1") << QByteArray("3234567890") << 10 << 3234567890UL << true;
-    QTest::newRow("ulong2") << QByteArray("fFFfFfFf") << 16 << 0xFFFFFFFFUL << true;
-
-    QTest::newRow("leading spaces") << QByteArray(" \n\r\t100") << 10 << 100UL << true;
-    QTest::newRow("trailing spaces") << QByteArray("100 \n\r\t") << 10 << 100UL << true;
-    QTest::newRow("leading junk") << QByteArray("x100") << 10 << 0UL << false;
-    QTest::newRow("trailing junk") << QByteArray("100x") << 10 << 0UL << false;
-}
-
-void tst_QByteArray::toULong()
-{
-    QFETCH(QByteArray, str);
-    QFETCH(int, base);
-    QFETCH(ulong, result);
-    QFETCH(bool, ok);
-
-    bool b;
-    QCOMPARE(str.toULong(0, base), result);
-    QCOMPARE(str.toULong(&b, base), result);
-    QCOMPARE(b, ok);
-}
-
-static QByteArray decNext(QByteArray &&big)
-{
-    // Increments a decimal digit-string (ignoring sign, so decrements if
-    // negative); only intended for taking a boundary value just out of range,
-    // so big is never a string of only 9s (that'd be one less than a power of
-    // ten, which cannot be a power of two, as odd, or one less than one, as the
-    // power of ten isn't a power of two).
-    int i = big.size() - 1;
-    while (big.at(i) == '9')
-        big[i--] = '0';
-    big[i] += 1;
-    return big;
-}
-
-void tst_QByteArray::toLongLong_data()
-{
-    QTest::addColumn<QByteArray>("str");
-    QTest::addColumn<int>("base");
-    QTest::addColumn<qlonglong>("result");
-    QTest::addColumn<bool>("ok");
-
-    QTest::newRow("null") << QByteArray() << 10 << 0LL << false;
-    QTest::newRow("empty") << QByteArray("") << 10 << 0LL << false;
-    QTest::newRow("out of base bound") << QByteArray("c") << 10 << 0LL << false;
-
-    QTest::newRow("in range dec") << QByteArray("7679359922672374856") << 10
-                                  << 7679359922672374856LL << true;
-    QTest::newRow("in range dec neg") << QByteArray("-7679359922672374856") << 10
-                                      << -7679359922672374856LL << true;
-    QTest::newRow("in range hex")
-        << QByteArray("6A929129A5421448") << 16 << 0x6A929129A5421448LL << true;
-    QTest::newRow("in range hex prefix")
-        << QByteArray("0x6A929129A5421448") << 16 << 0x6A929129A5421448LL << true;
-    QTest::newRow("in range hex neg")
-        << QByteArray("-6A929129A5421448") << 16 << -0x6A929129A5421448LL << true;
-    QTest::newRow("in range hex prefix neg")
-        << QByteArray("-0x6A929129A5421448") << 16 << -0x6A929129A5421448LL << true;
-    QTest::newRow("Fibonacci's last int64") << QByteArray("7540113804746346429") << 10
-                                            << 7540113804746346429LL << true;
-
-    QTest::newRow("leading spaces") << QByteArray(" \r\n\tABCFFFFFFF123") << 16
-                                    << 0xABCFFFFFFF123LL << true;
-    QTest::newRow("trailing spaces") << QByteArray("9876543210\t\r \n") << 10
-                                     << 9876543210LL << true;
-    QTest::newRow("space after plus") << QByteArray("+ 12") << 10 << 0LL << false;
-    QTest::newRow("space after minus") << QByteArray("- 12") << 10 << 0LL << false;
-    QTest::newRow("leading junk") << QByteArray("q12345") << 10 << 0LL << false;
-    QTest::newRow("trailing junk") << QByteArray("abc12345t") << 16 << 0LL << false;
-
-    QTest::newRow("dec with base 0") << QByteArray("9876543210") << 0 << 9876543210LL << true;
-    QTest::newRow("neg dec with base 0") << QByteArray("-9876543210") << 0 << -9876543210LL << true;
-    QTest::newRow("hex with base 0") << QByteArray("0x9876543210") << 0 << 0x9876543210LL << true;
-    QTest::newRow("neg hex with base 0") << QByteArray("-0x9876543210") << 0 << -0x9876543210LL
-                                         << true;
-    QTest::newRow("oct with base 0") << QByteArray("07654321234567") << 0 << 07654321234567LL
-                                     << true;
-    QTest::newRow("neg oct with base 0") << QByteArray("-07654321234567") << 0 << -07654321234567LL
-                                         << true;
-
-    QTest::newRow("base 3") << QByteArray("12012") << 3 << 140LL << true;
-    QTest::newRow("neg base 3") << QByteArray("-201") << 3 << -19LL << true;
-
-    // Boundary values, first in every base:
-    using LL = std::numeric_limits<qlonglong>;
-    for (int b = 0; b <= 36; ++b) {
-        if (b == 1) // bases 0 and 2 through 36 are allowed
-            ++b;
-        QTest::addRow("max base %d", b)
-            << QByteArray::number(LL::max(), b ? b : 10) << b << LL::max() << true;
-        QTest::addRow("min base %d", b)
-            << QByteArray::number(LL::min(), b ? b : 10) << b << LL::min() << true;
-    }
-    // Check leading zeros don't hit any buffer-too-big problems:
-    QTest::newRow("many-0 max dec")
-        << (QByteArray(512, '0') + QByteArray::number(LL::max())) << 10 << LL::max() << true;
-
-    // Special bases (and let's include some leading space, too !), first decimal:
-    QTest::newRow("max dec, base 0") << QByteArray::number(LL::max()) << 0 << LL::max() << true;
-    QTest::newRow("max space dec")
-        << ("\t\r\n\f\v " + QByteArray::number(LL::max())) << 10 << LL::max() << true;
-    QTest::newRow("max space dec, base 0")
-        << ("\t\r\n\f\v " + QByteArray::number(LL::max())) << 0 << LL::max() << true;
-    QTest::newRow("min dec, base 0") << QByteArray::number(LL::min()) << 0 << LL::min() << true;
-    QTest::newRow("min space dec")
-        << ("\t\r\n\f\v " + QByteArray::number(LL::min())) << 10 << LL::min() << true;
-    QTest::newRow("min space dec, base 0")
-        << ("\t\r\n\f\v " + QByteArray::number(LL::min())) << 0 << LL::min() << true;
-
-    // Hex with prefix:
-    QTest::newRow("max 0x base 0")
-        << ("0x" + QByteArray::number(LL::max(), 16)) << 0 << LL::max() << true;
-    QTest::newRow("max +0x base 0")
-        << ("+0x" + QByteArray::number(LL::max(), 16)) << 0 << LL::max() << true;
-    QTest::newRow("max space 0x base 0")
-        << ("\t\r\n\f\v 0x" + QByteArray::number(LL::max(), 16)) << 0 << LL::max() << true;
-    QTest::newRow("max space +0x base 0")
-        << ("\t\r\n\f\v +0x" + QByteArray::number(LL::max(), 16)) << 0 << LL::max() << true;
-    QByteArray big = QByteArray::number(LL::min(), 16);
-    big.insert(1, "0x"); // after sign
-    QTest::newRow("min hex prefix") << big << 16 << LL::min() << true;
-    QTest::newRow("min 0x base 0") << big << 0 << LL::min() << true;
-    big.prepend("\t\r\n\f\v ");
-    QTest::newRow("min space hex prefix") << big << 16 << LL::min() << true;
-    QTest::newRow("min space 0x base 0") << big << 0 << LL::min() << true;
-
-    // Octal with prefix:
-    QTest::newRow("max octal base 0")
-        << ('0' + QByteArray::number(LL::max(), 8)) << 0 << LL::max() << true;
-    QTest::newRow("max +octal base 0")
-        << ("+0" + QByteArray::number(LL::max(), 8)) << 0 << LL::max() << true;
-    QTest::newRow("max space octal base 0")
-        << ("\t\r\n\f\v 0" + QByteArray::number(LL::max(), 8)) << 0 << LL::max() << true;
-    QTest::newRow("max space +octal base 0")
-        << ("\t\r\n\f\v +0" + QByteArray::number(LL::max(), 8)) << 0 << LL::max() << true;
-    big = QByteArray::number(LL::min(), 8);
-    big.insert(1, '0'); // after sign
-    QTest::newRow("min octal prefix") << big << 8 << LL::min() << true;
-    QTest::newRow("min octal base 0") << big << 0 << LL::min() << true;
-    big.prepend("\t\r\n\f\v ");
-    QTest::newRow("min space octal prefix") << big << 8 << LL::min() << true;
-    QTest::newRow("min space octal base 0") << big << 0 << LL::min() << true;
-
-    // Values *just* out of range:
-    QTest::newRow("max + 1 dec") << decNext(QByteArray::number(LL::max())) << 10 << 0LL << false;
-    QTest::newRow("max + 1 dec base 0")
-        << decNext(QByteArray::number(LL::max())) << 0 << 0LL << false;
-    QTest::newRow("min - 1 dec") << decNext(QByteArray::number(LL::min())) << 10 << 0LL << false;
-    QTest::newRow("min - 1 dec base 0")
-        << decNext(QByteArray::number(LL::min())) << 0 << 0LL << false;
-    // For hex and octal, we know the last digit of min is 0 and skipping its sign gets max+1:
-    big = QByteArray::number(LL::min(), 8);
-    QTest::newRow("max + 1 oct") << big.sliced(1) << 8 << 0LL << false;
-    big[big.size() - 1] = '1';
-    QTest::newRow("min - 1 oct") << big << 8 << 0LL << false;
-    big.insert(1, '0'); // after minus sign
-    QTest::newRow("min - 1 octal base 0") << big << 0 << 0LL << false;
-    big = QByteArray::number(LL::min(), 16);
-    QTest::newRow("max + 1 hex") << big.sliced(1) << 16 << 0LL << false;
-    big[big.size() - 1] = '1';
-    QTest::newRow("min - 1 hex") << big << 16 << 0LL << false;
-    big.insert(1, "0x"); // after minus sign
-    QTest::newRow("min - 1, 0x base 0") << big << 0 << 0LL << false;
-}
-
-void tst_QByteArray::toLongLong()
-{
-    QFETCH(QByteArray, str);
-    QFETCH(int, base);
-    QFETCH(qlonglong, result);
-    QFETCH(bool, ok);
-
-    bool b;
-    QCOMPARE(str.toLongLong(nullptr, base), result);
-    QCOMPARE(str.toLongLong(&b, base), result);
-    QCOMPARE(b, ok);
-    if (base == 10) {
-        QCOMPARE(str.toLongLong(&b), result);
-        QCOMPARE(b, ok);
-    }
-}
-
-void tst_QByteArray::toULongLong_data()
-{
-    QTest::addColumn<QByteArray>("str");
-    QTest::addColumn<int>("base");
-    QTest::addColumn<qulonglong>("result");
-    QTest::addColumn<bool>("ok");
-
-    QTest::newRow("null") << QByteArray() << 10 << 0ULL << false;
-    QTest::newRow("empty") << QByteArray("") << 10 << 0ULL << false;
-    QTest::newRow("out of base bound") << QByteArray("c") << 10 << 0ULL << false;
-
-    QTest::newRow("in range dec")
-        << QByteArray("7679359922672374856") << 10 << 7679359922672374856ULL << true;
-    QTest::newRow("in range hex")
-        << QByteArray("6A929129A5421448") << 16 << 0x6A929129A5421448ULL << true;
-    QTest::newRow("in range hex prefix")
-        << QByteArray("0x6A929129A5421448") << 16 << 0x6A929129A5421448ULL << true;
-
-    QTest::newRow("leading spaces") << QByteArray(" \n\r\t100") << 10 << 100ULL << true;
-    QTest::newRow("trailing spaces") << QByteArray("100 \n\r\t") << 10 << 100ULL << true;
-    QTest::newRow("leading plus") << QByteArray("+100") << 10 << 100ULL << true;
-    QTest::newRow("space after plus") << QByteArray("+ 12") << 10 << 0ULL << false;
-    QTest::newRow("leading minus") << QByteArray("-100") << 10 << 0ULL << false;
-    QTest::newRow("leading junk") << QByteArray("x100") << 10 << 0ULL << false;
-    QTest::newRow("trailing junk") << QByteArray("100x") << 10 << 0ULL << false;
-
-    QTest::newRow("dec, base 0") << QByteArray("9876543210") << 0 << 9876543210ULL << true;
-    QTest::newRow("hex, base 0") << QByteArray("0x9876543210") << 0 << 0x9876543210ULL << true;
-    QTest::newRow("oct, base 0") << QByteArray("07654321234567") << 0 << 07654321234567ULL << true;
-    QTest::newRow("base 3") << QByteArray("12012") << 3 << 140ULL << true;
-
-    // Boundary values, first in every base:
-    using ULL = std::numeric_limits<qulonglong>;
-    for (int b = 0; b <= 36; ++b) {
-        if (b == 1) // bases 0 and 2 through 36 are allowed
-            ++b;
-        QTest::addRow("max base %d", b)
-            << QByteArray::number(ULL::max(), b ? b : 10) << b << ULL::max() << true;
-    }
-    // Check leading zeros don't hit any buffer-too-big problems:
-    QTest::newRow("many-0 max dec")
-        << (QByteArray(512, '0') + QByteArray::number(ULL::max())) << 10 << ULL::max() << true;
-
-    // Special bases (and let's include some leading space, too !), first decimal:
-    QTest::newRow("max dec, base 0") << QByteArray::number(ULL::max()) << 0 << ULL::max() << true;
-    QTest::newRow("max space dec")
-        << ("\t\r\n\f\v " + QByteArray::number(ULL::max())) << 10 << ULL::max() << true;
-    QTest::newRow("max space dec, base 0")
-        << ("\t\r\n\f\v " + QByteArray::number(ULL::max())) << 0 << ULL::max() << true;
-
-    // Hex with prefix:
-    QTest::newRow("max 0x base 0")
-        << ("0x" + QByteArray::number(ULL::max(), 16)) << 0 << ULL::max() << true;
-    QTest::newRow("max +0x base 0")
-        << ("+0x" + QByteArray::number(ULL::max(), 16)) << 0 << ULL::max() << true;
-    QTest::newRow("max space 0x base 0")
-        << ("\t\r\n\f\v 0x" + QByteArray::number(ULL::max(), 16)) << 0 << ULL::max() << true;
-    QTest::newRow("max space +0x base 0")
-        << ("\t\r\n\f\v +0x" + QByteArray::number(ULL::max(), 16)) << 0 << ULL::max() << true;
-
-    // Octal with prefix:
-    QTest::newRow("max octal base 0")
-        << ('0' + QByteArray::number(ULL::max(), 8)) << 0 << ULL::max() << true;
-    QTest::newRow("max +octal base 0")
-        << ("+0" + QByteArray::number(ULL::max(), 8)) << 0 << ULL::max() << true;
-    QTest::newRow("max space octal base 0")
-        << ("\t\r\n\f\v 0" + QByteArray::number(ULL::max(), 8)) << 0 << ULL::max() << true;
-    QTest::newRow("max space +octal base 0")
-        << ("\t\r\n\f\v +0" + QByteArray::number(ULL::max(), 8)) << 0 << ULL::max() << true;
-
-    // Values *just* out of range:
-    QTest::newRow("max + 1 dec") << decNext(QByteArray::number(ULL::max())) << 10 << 0ULL << false;
-    QTest::newRow("max + 1 dec base 0")
-        << decNext(QByteArray::number(ULL::max())) << 0 << 0ULL << false;
-    auto big = QByteArray::number(ULL::max(), 8).replace('7', '0');
-    // Number of bits is a power of two, so not a multiple of three; so (only)
-    // first digit of max wasn't 7:
-    big[0] += 1;
-    QTest::newRow("max + 1 oct") << big << 8 << 0ULL << false;
-    // Number of bits is a multiple of four, so every digit of max is 'f'.
-    big = '1' + QByteArray::number(ULL::max(), 16).replace('f', '0');
-    QTest::newRow("max + 1 hex") << big << 16 << 0ULL << false;
-}
-
-void tst_QByteArray::toULongLong()
-{
-    QFETCH(QByteArray, str);
-    QFETCH(int, base);
-    QFETCH(qulonglong, result);
-    QFETCH(bool, ok);
-
-    bool b;
-    QCOMPARE(str.toULongLong(0, base), result);
-    QCOMPARE(str.toULongLong(&b, base), result);
-    QCOMPARE(b, ok);
-}
-
 static bool checkSize(qsizetype value, qsizetype min)
 {
     return value >= min && value <= std::numeric_limits<qsizetype>::max();
@@ -3056,7 +2484,5 @@ void tst_QByteArray::length_data()
     QTest::newRow("with '\\0' no size") << QByteArray("abc\0def") << qsizetype(3);
 }
 
-const char globalChar = '1';
-
 QTEST_MAIN(tst_QByteArray)
 #include "tst_qbytearray.moc"