Long live Qt 4.5!

1 files changed, 1424 insertions, 0 deletions

diff --git a/tests/auto/qbytearray/tst_qbytearray.cpp b/tests/auto/qbytearray/tst_qbytearray.cpp
new file mode 100644
index 0000000..4da8c5c
--- /dev/null
+++ b/tests/auto/qbytearray/tst_qbytearray.cpp
@@ -0,0 +1,1424 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+
+#include <qbytearray.h>
+#include <qfile.h>
+#include <limits.h>
+#include <private/qtools_p.h>
+#if defined(Q_OS_WINCE)
+#include <qcoreapplication.h>
+#endif
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QByteArray : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QByteArray();
+    virtual ~tst_QByteArray();
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+private slots:
+    void qCompress_data();
+#ifndef QT_NO_COMPRESS
+    void qCompress();
+    void qUncompress_data();
+    void qUncompress();
+#endif
+    void constByteArray();
+    void leftJustified();
+    void rightJustified();
+    void startsWith_data();
+    void startsWith();
+    void startsWith_char();
+    void endsWith_data();
+    void endsWith();
+    void endsWith_char();
+    void split_data();
+    void split();
+    void base64_data();
+    void base64();
+    void qvsnprintf();
+    void qstrlen();
+    void qstrnlen();
+    void qstrcpy();
+    void qstrncpy();
+    void qstricmp_data();
+    void qstricmp();
+    void qstricmp_singularities();
+    void qstrnicmp_singularities();
+    void chop_data();
+    void chop();
+    void prepend();
+    void append();
+    void insert();
+    void remove_data();
+    void remove();
+    void replace_data();
+    void replace();
+    void indexOf_data();
+    void indexOf();
+    void lastIndexOf_data();
+    void lastIndexOf();
+    void toULong_data();
+    void toULong();
+    void toULongLong_data();
+    void toULongLong();
+
+    void number();
+    void toInt_data();
+    void toInt();
+    void qAllocMore();
+
+    void resizeAfterFromRawData();
+    void appendAfterFromRawData();
+    void toFromHex_data();
+    void toFromHex();
+    void toFromPercentEncoding();
+
+    void compare_data();
+    void compare();
+    void compareCharStar_data();
+    void compareCharStar();
+
+    void repeatedSignature() const;
+    void repeated() const;
+    void repeated_data() const;
+
+    void byteRefDetaching() const;
+};
+
+tst_QByteArray::tst_QByteArray()
+{
+    qRegisterMetaType<qulonglong>("qulonglong");
+}
+
+tst_QByteArray::~tst_QByteArray()
+{
+}
+
+void tst_QByteArray::initTestCase()
+{
+}
+
+void tst_QByteArray::cleanupTestCase()
+{
+}
+
+void tst_QByteArray::init()
+{
+}
+
+void tst_QByteArray::cleanup()
+{
+}
+
+void tst_QByteArray::qCompress_data()
+{
+    QTest::addColumn<QByteArray>("ba");
+
+#ifndef Q_OS_WINCE
+    const int size1 = 1024*1024;
+#else
+    const int size1 = 1024;
+#endif
+    QByteArray ba1( size1, 0 );
+
+    QTest::newRow( "00" ) << QByteArray();
+
+    int i;
+    for ( i=0; i<size1; i++ )
+	ba1[i] = (char)( i / 1024 );
+    QTest::newRow( "01" ) << ba1;
+
+    for ( i=0; i<size1; i++ )
+	ba1[i] = (char)( i % 256 );
+    QTest::newRow( "02" ) << ba1;
+
+    ba1.fill( 'A' );
+    QTest::newRow( "03" ) << ba1;
+
+#if defined(Q_OS_WINCE)
+    int tmpArgc = 0;
+    char** tmpArgv = 0;
+    QCoreApplication app(tmpArgc, tmpArgv);
+#endif
+    QFile file( SRCDIR "rfc3252.txt" );
+    QVERIFY( file.open(QIODevice::ReadOnly) );
+    QTest::newRow( "04" ) << file.readAll();
+}
+
+#ifndef QT_NO_COMPRESS
+void tst_QByteArray::qCompress()
+{
+    QFETCH( QByteArray, ba );
+    QByteArray compressed = ::qCompress( ba );
+    //qDebug( "size uncompressed: %d    size compressed: %d", ba.size(), compressed.size() );
+    QTEST( ::qUncompress( compressed ), "ba" );
+}
+
+/*
+    Just making sure it doesn't crash on invalid data.
+*/
+void tst_QByteArray::qUncompress_data()
+{
+    QTest::addColumn<QByteArray>("in");
+    QTest::addColumn<QByteArray>("out");
+
+    QTest::newRow("0x00000000") << QByteArray("\x00\x00\x00\x00") << QByteArray();
+    QTest::newRow("0x000000ff") << QByteArray("\x00\x00\x00\xff") << QByteArray();
+    QTest::newRow("0x3f000000") << QByteArray("\x3f\x00\x00\x00") << QByteArray();
+    QTest::newRow("0x3fffffff") << QByteArray("\x3f\xff\xff\xff") << QByteArray();
+    QTest::newRow("0x7fffff00") << QByteArray("\x7f\xff\xff\x00") << QByteArray();
+    QTest::newRow("0x7fffffff") << QByteArray("\x7f\xff\xff\xff") << QByteArray();
+    QTest::newRow("0x80000000") << QByteArray("\x80\x00\x00\x00") << QByteArray();
+    QTest::newRow("0x800000ff") << QByteArray("\x80\x00\x00\xff") << QByteArray();
+    QTest::newRow("0xcf000000") << QByteArray("\xcf\x00\x00\x00") << QByteArray();
+    QTest::newRow("0xcfffffff") << QByteArray("\xcf\xff\xff\xff") << QByteArray();
+    QTest::newRow("0xffffff00") << QByteArray("\xff\xff\xff\x00") << QByteArray();
+    QTest::newRow("0xffffffff") << QByteArray("\xff\xff\xff\xff") << QByteArray();
+}
+
+void tst_QByteArray::qUncompress()
+{
+    QFETCH(QByteArray, in);
+
+#if defined Q_OS_HPUX && !defined __ia64 && defined Q_CC_GNU
+    QSKIP("Corrupt data causes this tests to lock up on HP-UX / PA-RISC with gcc", SkipAll);
+#elif defined Q_OS_SOLARIS
+    QSKIP("Corrupt data causes this tests to lock up on Solaris", SkipAll);
+#endif
+
+    QTEST(::qUncompress(in), "out");
+
+#if defined Q_WS_MAC && (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_4)
+    QSKIP("Corrupt data causes this test to lock up on Mac OS X Panther", SkipSingle);
+#endif
+
+    QTEST(::qUncompress(in + "blah"), "out");
+}
+#endif
+
+void tst_QByteArray::constByteArray()
+{
+    const char *ptr = "abc";
+    QByteArray cba = QByteArray::fromRawData(ptr, 3);
+    QVERIFY(cba.constData() == ptr);
+    cba.squeeze();
+    QVERIFY(cba.constData() == ptr);
+    cba.detach();
+    QVERIFY(cba.size() == 3);
+    QVERIFY(cba.capacity() == 3);
+    QVERIFY(cba.constData() != ptr);
+    QVERIFY(cba.constData()[0] == 'a');
+    QVERIFY(cba.constData()[1] == 'b');
+    QVERIFY(cba.constData()[2] == 'c');
+    QVERIFY(cba.constData()[3] == '\0');
+}
+
+void tst_QByteArray::leftJustified()
+{
+    QByteArray a;
+    a = "ABC";
+    QCOMPARE(a.leftJustified(5,'-'), QByteArray("ABC--"));
+    QCOMPARE(a.leftJustified(4,'-'), QByteArray("ABC-"));
+    QCOMPARE(a.leftJustified(4), QByteArray("ABC "));
+    QCOMPARE(a.leftJustified(3), QByteArray("ABC"));
+    QCOMPARE(a.leftJustified(2), QByteArray("ABC"));
+    QCOMPARE(a.leftJustified(1), QByteArray("ABC"));
+    QCOMPARE(a.leftJustified(0), QByteArray("ABC"));
+
+    QByteArray n;
+    QVERIFY(!n.leftJustified(3).isNull());    // I expected true
+    QCOMPARE(a.leftJustified(4,' ',true), QByteArray("ABC "));
+    QCOMPARE(a.leftJustified(3,' ',true), QByteArray("ABC"));
+    QCOMPARE(a.leftJustified(2,' ',true), QByteArray("AB"));
+    QCOMPARE(a.leftJustified(1,' ',true), QByteArray("A"));
+    QCOMPARE(a.leftJustified(0,' ',true), QByteArray(""));
+}
+
+void tst_QByteArray::rightJustified()
+{
+    QByteArray a;
+    a="ABC";
+    QCOMPARE(a.rightJustified(5,'-'),QByteArray("--ABC"));
+    QCOMPARE(a.rightJustified(4,'-'),QByteArray("-ABC"));
+    QCOMPARE(a.rightJustified(4),QByteArray(" ABC"));
+    QCOMPARE(a.rightJustified(3),QByteArray("ABC"));
+    QCOMPARE(a.rightJustified(2),QByteArray("ABC"));
+    QCOMPARE(a.rightJustified(1),QByteArray("ABC"));
+    QCOMPARE(a.rightJustified(0),QByteArray("ABC"));
+
+    QByteArray n;
+    QVERIFY(!n.rightJustified(3).isNull());  // I expected true
+    QCOMPARE(a.rightJustified(4,'-',true),QByteArray("-ABC"));
+    QCOMPARE(a.rightJustified(4,' ',true),QByteArray(" ABC"));
+    QCOMPARE(a.rightJustified(3,' ',true),QByteArray("ABC"));
+    QCOMPARE(a.rightJustified(2,' ',true),QByteArray("AB"));
+    QCOMPARE(a.rightJustified(1,' ',true),QByteArray("A"));
+    QCOMPARE(a.rightJustified(0,' ',true),QByteArray(""));
+    QCOMPARE(a,QByteArray("ABC"));
+}
+
+void tst_QByteArray::startsWith_data()
+{
+    QTest::addColumn<QByteArray>("ba");
+    QTest::addColumn<QByteArray>("sw");
+    QTest::addColumn<bool>("result");
+
+    QTest::newRow("01") << QByteArray() << QByteArray() << true;
+    QTest::newRow("02") << QByteArray() << QByteArray("") << true;
+    QTest::newRow("03") << QByteArray() << QByteArray("hallo") << false;
+
+    QTest::newRow("04") << QByteArray("") << QByteArray() << true;
+    QTest::newRow("05") << QByteArray("") << QByteArray("") << true;
+    QTest::newRow("06") << QByteArray("") << QByteArray("h") << false;
+
+    QTest::newRow("07") << QByteArray("hallo") << QByteArray("h") << true;
+    QTest::newRow("08") << QByteArray("hallo") << QByteArray("hallo") << true;
+    QTest::newRow("09") << QByteArray("hallo") << QByteArray("") << true;
+    QTest::newRow("10") << QByteArray("hallo") << QByteArray("hallohallo") << false;
+    QTest::newRow("11") << QByteArray("hallo") << QByteArray() << true;
+}
+
+void tst_QByteArray::startsWith()
+{
+    QFETCH(QByteArray, ba);
+    QFETCH(QByteArray, sw);
+    QFETCH(bool, result);
+
+    QVERIFY(ba.startsWith(sw) == result);
+
+    if (sw.isNull()) {
+        QVERIFY(ba.startsWith((char*)0) == result);
+    } else {
+        QVERIFY(ba.startsWith(sw.data()) == result);
+    }
+}
+
+void tst_QByteArray::startsWith_char()
+{
+    QVERIFY(QByteArray("hallo").startsWith('h'));
+    QVERIFY(!QByteArray("hallo").startsWith('\0'));
+    QVERIFY(!QByteArray("hallo").startsWith('o'));
+    QVERIFY(QByteArray("h").startsWith('h'));
+    QVERIFY(!QByteArray("h").startsWith('\0'));
+    QVERIFY(!QByteArray("h").startsWith('o'));
+    QVERIFY(!QByteArray("hallo").startsWith('l'));
+    QVERIFY(!QByteArray("").startsWith('\0'));
+    QVERIFY(!QByteArray("").startsWith('a'));
+    QVERIFY(!QByteArray().startsWith('a'));
+    QVERIFY(!QByteArray().startsWith('\0'));
+}
+
+void tst_QByteArray::endsWith_data()
+{
+    QTest::addColumn<QByteArray>("ba");
+    QTest::addColumn<QByteArray>("sw");
+    QTest::addColumn<bool>("result");
+
+    QTest::newRow("01") << QByteArray() << QByteArray() << true;
+    QTest::newRow("02") << QByteArray() << QByteArray("") << true;
+    QTest::newRow("03") << QByteArray() << QByteArray("hallo") << false;
+
+    QTest::newRow("04") << QByteArray("") << QByteArray() << true;
+    QTest::newRow("05") << QByteArray("") << QByteArray("") << true;
+    QTest::newRow("06") << QByteArray("") << QByteArray("h") << false;
+
+    QTest::newRow("07") << QByteArray("hallo") << QByteArray("o") << true;
+    QTest::newRow("08") << QByteArray("hallo") << QByteArray("hallo") << true;
+    QTest::newRow("09") << QByteArray("hallo") << QByteArray("") << true;
+    QTest::newRow("10") << QByteArray("hallo") << QByteArray("hallohallo") << false;
+    QTest::newRow("11") << QByteArray("hallo") << QByteArray() << true;
+}
+
+void tst_QByteArray::endsWith()
+{
+    QFETCH(QByteArray, ba);
+    QFETCH(QByteArray, sw);
+    QFETCH(bool, result);
+
+    QVERIFY(ba.endsWith(sw) == result);
+
+    if (sw.isNull()) {
+        QVERIFY(ba.endsWith((char*)0) == result);
+    } else {
+        QVERIFY(ba.endsWith(sw.data()) == result);
+    }
+}
+
+void tst_QByteArray::endsWith_char()
+{
+    QVERIFY(QByteArray("hallo").endsWith('o'));
+    QVERIFY(!QByteArray("hallo").endsWith('\0'));
+    QVERIFY(!QByteArray("hallo").endsWith('h'));
+    QVERIFY(QByteArray("h").endsWith('h'));
+    QVERIFY(!QByteArray("h").endsWith('\0'));
+    QVERIFY(!QByteArray("h").endsWith('o'));
+    QVERIFY(!QByteArray("hallo").endsWith('l'));
+    QVERIFY(!QByteArray("").endsWith('\0'));
+    QVERIFY(!QByteArray("").endsWith('a'));
+    QVERIFY(!QByteArray().endsWith('a'));
+    QVERIFY(!QByteArray().endsWith('\0'));
+}
+
+void tst_QByteArray::split_data()
+{
+    QTest::addColumn<QByteArray>("sample");
+    QTest::addColumn<int>("size");
+
+    QTest::newRow("1") << QByteArray("-rw-r--r--  1 0  0  519240 Jul  9  2002 bigfile")
+		    << 14;
+    QTest::newRow("2") << QByteArray("abcde") << 1;
+    QTest::newRow("one empty") << QByteArray("") << 1;
+    QTest::newRow("two empty") << QByteArray(" ") << 2;
+    QTest::newRow("three empty") << QByteArray("  ") << 3;
+
+}
+
+void tst_QByteArray::split()
+{
+    QFETCH(QByteArray, sample);
+    QFETCH(int, size);
+
+    QList<QByteArray> list = sample.split(' ');
+    QCOMPARE(list.count(), size);
+}
+
+void tst_QByteArray::base64_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("MTIz");
+    QTest::newRow("5") << QByteArray("1234") << QByteArray("MTIzNA==");
+    QTest::newRow("6") << QByteArray("\n") << QByteArray("Cg==");
+    QTest::newRow("7") << QByteArray("a\n") << QByteArray("YQo=");
+    QTest::newRow("8") << QByteArray("ab\n") << QByteArray("YWIK");
+    QTest::newRow("9") << QByteArray("abc\n") << QByteArray("YWJjCg==");
+    QTest::newRow("a") << QByteArray("abcd\n") << QByteArray("YWJjZAo=");
+    QTest::newRow("b") << QByteArray("abcde\n") << QByteArray("YWJjZGUK");
+    QTest::newRow("c") << QByteArray("abcdef\n") << QByteArray("YWJjZGVmCg==");
+    QTest::newRow("d") << QByteArray("abcdefg\n") << QByteArray("YWJjZGVmZwo=");
+    QTest::newRow("e") << QByteArray("abcdefgh\n") << QByteArray("YWJjZGVmZ2gK");
+
+    QByteArray ba;
+    ba.resize(256);
+    for (int i = 0; i < 256; ++i)
+        ba[i] = i;
+    QTest::newRow("f") << ba << QByteArray("AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==");
+}
+
+
+void tst_QByteArray::base64()
+{
+    QFETCH(QByteArray, rawdata);
+    QFETCH(QByteArray, base64);
+
+    QByteArray arr = QByteArray::fromBase64(base64);
+    QCOMPARE(arr, rawdata);
+
+    QByteArray arr64 = rawdata.toBase64();
+    QCOMPARE(arr64, base64);
+}
+
+void tst_QByteArray::qvsnprintf()
+{
+    char buf[20];
+    qMemSet(buf, 42, sizeof(buf));
+
+    QCOMPARE(::qsnprintf(buf, 10, "%s", "bubu"), 4);
+    QCOMPARE(static_cast<const char *>(buf), "bubu");
+    QCOMPARE(buf[5], char(42));
+
+    qMemSet(buf, 42, sizeof(buf));
+    QCOMPARE(::qsnprintf(buf, 5, "%s", "bubu"), 4);
+    QCOMPARE(static_cast<const char *>(buf), "bubu");
+    QCOMPARE(buf[5], char(42));
+
+    qMemSet(buf, 42, sizeof(buf));
+#ifdef Q_OS_WIN
+    // VS 2005 uses the Qt implementation of vsnprintf.
+# if defined(_MSC_VER) && _MSC_VER >= 1400 && !defined(Q_OS_WINCE)
+    QCOMPARE(::qsnprintf(buf, 3, "%s", "bubu"), -1);
+    QCOMPARE(static_cast<const char*>(buf), "bu");
+# else
+    // windows has to do everything different, of course.
+    QCOMPARE(::qsnprintf(buf, 3, "%s", "bubu"), -1);
+    buf[19] = '\0';
+    QCOMPARE(static_cast<const char *>(buf), "bub****************");
+# endif
+#else
+#ifdef Q_OS_IRIX
+    // Irix reports back the amount of characters written without the \0
+    QCOMPARE(::qsnprintf(buf, 3, "%s", "bubu"), 2);
+#else
+    // Every other system in this world reports the amount of data that could have been written
+    QCOMPARE(::qsnprintf(buf, 3, "%s", "bubu"), 4);
+#endif
+    QCOMPARE(static_cast<const char*>(buf), "bu");
+#endif
+    QCOMPARE(buf[4], char(42));
+
+#ifndef Q_OS_WIN
+    qMemSet(buf, 42, sizeof(buf));
+    QCOMPARE(::qsnprintf(buf, 10, ""), 0);
+#endif
+}
+
+
+void tst_QByteArray::qstrlen()
+{
+    const char *src = "Something about ... \0 a string.";
+    QCOMPARE(::qstrlen((char*)0), (uint)0);
+    QCOMPARE(::qstrlen(src), (uint)20);
+}
+
+void tst_QByteArray::qstrnlen()
+{
+    const char *src = "Something about ... \0 a string.";
+    QCOMPARE(::qstrnlen((char*)0, 1), (uint)0);
+    QCOMPARE(::qstrnlen(src, 31), (uint)20);
+    QCOMPARE(::qstrnlen(src, 19), (uint)19);
+    QCOMPARE(::qstrnlen(src, 21), (uint)20);
+    QCOMPARE(::qstrnlen(src, 20), (uint)20);
+}
+
+void tst_QByteArray::qstrcpy()
+{
+    const char *src = "Something about ... \0 a string.";
+    const char *expected = "Something about ... ";
+    char dst[128];
+
+    QCOMPARE(::qstrcpy(0, 0), (char*)0);
+    QCOMPARE(::qstrcpy(dst, 0), (char*)0);
+
+    QCOMPARE(::qstrcpy(dst ,src), (char *)dst);
+    QCOMPARE((char *)dst, const_cast<char *>(expected));
+}
+
+void tst_QByteArray::qstrncpy()
+{
+    QByteArray src(1024, 'a'), dst(1024, 'b');
+
+    // singularities
+    QCOMPARE(::qstrncpy(0, 0,0), (char*)0);
+    QCOMPARE(::qstrncpy(dst.data(), 0, 0), (char*)0);
+
+    // normal copy
+    QCOMPARE(::qstrncpy(dst.data(), src.data(), src.size()), dst.data());
+
+    src = QByteArray( "Tumdelidum" );
+    QCOMPARE(QByteArray(::qstrncpy(dst.data(), src.data(), src.size())),
+            QByteArray("Tumdelidu"));
+
+    // normal copy with length is longer than neccessary
+    src = QByteArray( "Tumdelidum\0foo" );
+    dst.resize(128*1024);
+    QCOMPARE(QByteArray(::qstrncpy(dst.data(), src.data(), dst.size())),
+            QByteArray("Tumdelidum"));
+}
+
+void tst_QByteArray::qstricmp_data()
+{
+    QTest::addColumn<QString>("str1");
+    QTest::addColumn<QString>("str2");
+
+    QTest::newRow("equal   1") << "abcEdb"  << "abcEdb";
+    QTest::newRow("equal   2") << "abcEdb"  << "ABCeDB";
+    QTest::newRow("equal   3") << "ABCEDB"  << "abcedb";
+    QTest::newRow("less    1") << "abcdef"  << "abcdefg";
+    QTest::newRow("less    2") << "abcdeF"  << "abcdef";
+    QTest::newRow("greater 1") << "abcdef"  << "abcdeF";
+    QTest::newRow("greater 2") << "abcdefg" << "abcdef";
+}
+
+void tst_QByteArray::qstricmp()
+{
+    QFETCH(QString, str1);
+    QFETCH(QString, str2);
+
+    int expected = strcmp(str1.toUpper().toLatin1(),
+                          str2.toUpper().toLatin1());
+    if ( expected != 0 ) {
+        expected = (expected < 0 ? -1 : 1);
+    }
+    int actual = ::qstricmp(str1.toLatin1(), str2.toLatin1());
+    if ( actual != 0 ) {
+        actual = (actual < 0 ? -1 : 1);
+    }
+    QCOMPARE(expected, actual);
+}
+
+void tst_QByteArray::qstricmp_singularities()
+{
+    QCOMPARE(::qstricmp(0, 0), 0);
+    QVERIFY(::qstricmp(0, "a") != 0);
+    QVERIFY(::qstricmp("a", 0) != 0);
+    QCOMPARE(::qstricmp("", ""), 0);
+}
+
+void tst_QByteArray::qstrnicmp_singularities()
+{
+    QCOMPARE(::qstrnicmp(0, 0, 123), 0);
+    QVERIFY(::qstrnicmp(0, "a", 123) != 0);
+    QVERIFY(::qstrnicmp("a", 0, 123) != 0);
+    QCOMPARE(::qstrnicmp("", "", 123), 0);
+    QCOMPARE(::qstrnicmp("a", "B", 0), 0);
+}
+
+void tst_QByteArray::chop_data()
+{
+    QTest::addColumn<QByteArray>("src");
+    QTest::addColumn<int>("choplength");
+    QTest::addColumn<QByteArray>("expected");
+
+    QTest::newRow("1") << QByteArray("short1") << 128 << QByteArray();
+    QTest::newRow("2") << QByteArray("short2") << int(strlen("short2"))
+                    << QByteArray();
+    QTest::newRow("3") << QByteArray("abcdef\0foo", 10) << 2
+                    << QByteArray("abcdef\0f", 8);
+    QTest::newRow("4") << QByteArray("STARTTLS\r\n") << 2
+                    << QByteArray("STARTTLS");
+    QTest::newRow("5") << QByteArray("") << 1 << QByteArray();
+    QTest::newRow("6") << QByteArray("foo") << 0 << QByteArray("foo");
+    QTest::newRow("7") << QByteArray(0) << 28 << QByteArray();
+}
+
+void tst_QByteArray::chop()
+{
+    QFETCH(QByteArray, src);
+    QFETCH(int, choplength);
+    QFETCH(QByteArray, expected);
+
+    src.chop(choplength);
+    QCOMPARE(src, expected);
+}
+
+void tst_QByteArray::prepend()
+{
+    QByteArray ba("foo");
+    QCOMPARE(ba.prepend((char*)0), QByteArray("foo"));
+    QCOMPARE(ba.prepend(QByteArray()), QByteArray("foo"));
+    QCOMPARE(ba.prepend("1"), QByteArray("1foo"));
+    QCOMPARE(ba.prepend(QByteArray("2")), QByteArray("21foo"));
+    QCOMPARE(ba.prepend('3'), QByteArray("321foo"));
+}
+
+void tst_QByteArray::append()
+{
+    QByteArray ba("foo");
+    QCOMPARE(ba.append((char*)0), QByteArray("foo"));
+    QCOMPARE(ba.append(QByteArray()), QByteArray("foo"));
+    QCOMPARE(ba.append("1"), QByteArray("foo1"));
+    QCOMPARE(ba.append(QByteArray("2")), QByteArray("foo12"));
+    QCOMPARE(ba.append('3'), QByteArray("foo123"));
+}
+
+void tst_QByteArray::insert()
+{
+    QByteArray ba("Meal");
+    QCOMPARE(ba.insert(1, QByteArray("ontr")), QByteArray("Montreal"));
+    QCOMPARE(ba.insert(ba.size(), "foo"), QByteArray("Montrealfoo"));
+
+    ba = QByteArray("13");
+    QCOMPARE(ba.insert(1, QByteArray("2")), QByteArray("123"));
+
+    ba = "ac";
+    QCOMPARE(ba.insert(1, 'b'), QByteArray("abc"));
+    QCOMPARE(ba.size(), 3);
+
+    ba = "ikl";
+    QCOMPARE(ba.insert(1, "j"), QByteArray("ijkl"));
+    QCOMPARE(ba.size(), 4);
+}
+
+void tst_QByteArray::remove_data()
+{
+    QTest::addColumn<QByteArray>("src");
+    QTest::addColumn<int>("position");
+    QTest::addColumn<int>("length");
+    QTest::addColumn<QByteArray>("expected");
+
+    QTest::newRow("1") << QByteArray("Montreal") << 1 << 4
+                    << QByteArray("Meal");
+    QTest::newRow("2") << QByteArray() << 10 << 10 << QByteArray();
+    QTest::newRow("3") << QByteArray("hi") << 0 << 10 << QByteArray();
+    QTest::newRow("4") << QByteArray("Montreal") << 4 << 100
+                    << QByteArray("Mont");
+
+    // index out of range
+    QTest::newRow("5") << QByteArray("Montreal") << 8 << 1
+                    << QByteArray("Montreal");
+    QTest::newRow("6") << QByteArray("Montreal") << 18 << 4
+                    << QByteArray("Montreal");
+}
+
+void tst_QByteArray::remove()
+{
+    QFETCH(QByteArray, src);
+    QFETCH(int, position);
+    QFETCH(int, length);
+    QFETCH(QByteArray, expected);
+    QCOMPARE(src.remove(position, length), expected);
+}
+
+void tst_QByteArray::replace_data()
+{
+    QTest::addColumn<QByteArray>("src");
+    QTest::addColumn<int>("pos");
+    QTest::addColumn<int>("len");
+    QTest::addColumn<QByteArray>("after");
+    QTest::addColumn<QByteArray>("expected");
+
+    QTest::newRow("1") << QByteArray("Say yes!") << 4 << 3
+                    << QByteArray("no") << QByteArray("Say no!");
+    QTest::newRow("2") << QByteArray("rock and roll") << 5 << 3
+                    << QByteArray("&") << QByteArray("rock & roll");
+    QTest::newRow("3") << QByteArray("foo") << 3 << 0 << QByteArray("bar")
+                    << QByteArray("foobar");
+    QTest::newRow("4") << QByteArray() << 0 << 0 << QByteArray() << QByteArray();
+    // index out of range
+    QTest::newRow("5") << QByteArray() << 3 << 0 << QByteArray("hi")
+                    << QByteArray("   hi");
+    // Optimized path
+    QTest::newRow("6") << QByteArray("abcdef") << 3 << 12 << QByteArray("abcdefghijkl") << QByteArray("abcabcdefghijkl");
+    QTest::newRow("7") << QByteArray("abcdef") << 3 << 4  << QByteArray("abcdefghijkl") << QByteArray("abcabcdefghijkl");
+    QTest::newRow("8") << QByteArray("abcdef") << 3 << 3  << QByteArray("abcdefghijkl") << QByteArray("abcabcdefghijkl");
+    QTest::newRow("9") << QByteArray("abcdef") << 3 << 2  << QByteArray("abcdefghijkl") << QByteArray("abcabcdefghijklf");
+    QTest::newRow("10") << QByteArray("abcdef") << 2 << 2  << QByteArray("xx") << QByteArray("abxxef");
+}
+
+void tst_QByteArray::replace()
+{
+    QFETCH(QByteArray, src);
+    QFETCH(int, pos);
+    QFETCH(int, len);
+    QFETCH(QByteArray, after);
+    QFETCH(QByteArray, expected);
+
+    QByteArray str1 = src;
+    QByteArray str2 = src;
+
+    QCOMPARE(str1.replace(pos, len, after).constData(), expected.constData());
+    QCOMPARE(str2.replace(pos, len, after.data()), expected);
+}
+
+void tst_QByteArray::indexOf_data()
+{
+    QTest::addColumn<QByteArray>("haystack");
+    QTest::addColumn<QByteArray>("needle");
+    QTest::addColumn<int>("startpos");
+    QTest::addColumn<int>("expected");
+
+    QTest::newRow( "1" ) << QByteArray("abc") << QByteArray("a") << 0 << 0;
+    QTest::newRow( "2" ) << QByteArray("abc") << QByteArray("A") << 0 << -1;
+    QTest::newRow( "3" ) << QByteArray("abc") << QByteArray("a") << 1 << -1;
+    QTest::newRow( "4" ) << QByteArray("abc") << QByteArray("A") << 1 << -1;
+    QTest::newRow( "5" ) << QByteArray("abc") << QByteArray("b") << 0 << 1;
+    QTest::newRow( "6" ) << QByteArray("abc") << QByteArray("B") << 0 << -1;
+    QTest::newRow( "7" ) << QByteArray("abc") << QByteArray("b") << 1 << 1;
+    QTest::newRow( "8" ) << QByteArray("abc") << QByteArray("B") << 1 << -1;
+    QTest::newRow( "9" ) << QByteArray("abc") << QByteArray("b") << 2 << -1;
+    QTest::newRow( "10" ) << QByteArray("abc") << QByteArray("c") << 0 << 2;
+    QTest::newRow( "11" ) << QByteArray("abc") << QByteArray("C") << 0 << -1;
+    QTest::newRow( "12" ) << QByteArray("abc") << QByteArray("c") << 1 << 2;
+    QTest::newRow( "13" ) << QByteArray("abc") << QByteArray("C") << 1 << -1;
+    QTest::newRow( "14" ) << QByteArray("abc") << QByteArray("c") << 2 << 2;
+    QTest::newRow( "15" ) << QByteArray("aBc") << QByteArray("bc") << 0 << -1;
+    QTest::newRow( "16" ) << QByteArray("aBc") << QByteArray("Bc") << 0 << 1;
+    QTest::newRow( "17" ) << QByteArray("aBc") << QByteArray("bC") << 0 << -1;
+    QTest::newRow( "18" ) << QByteArray("aBc") << QByteArray("BC") << 0 << -1;
+
+    // task 203692
+    static const char h19[] = {'x', 0x00, 0xe7, 0x25, 0x1c, 0x0a};
+    static const char n19[] = {0x00, 0x00, 0x01, 0x00};
+    QTest::newRow( "19" ) << QByteArray(h19, sizeof(h19))
+                          << QByteArray(n19, sizeof(n19)) << 0 << -1;
+
+    QTest::newRow( "empty" ) << QByteArray("") << QByteArray("x") << 0 << -1;
+    QTest::newRow( "null" ) << QByteArray() << QByteArray("x") << 0 << -1;
+    QTest::newRow( "null-in-null") << QByteArray() << QByteArray() << 0 << 0;
+    QTest::newRow( "empty-in-null") << QByteArray() << QByteArray("") << 0 << 0;
+    QTest::newRow( "null-in-empty") << QByteArray("") << QByteArray() << 0 << 0;
+    QTest::newRow( "empty-in-empty") << QByteArray("") << QByteArray("") << 0 << 0;
+
+    QByteArray veryBigHaystack(500, 'a');
+    veryBigHaystack += 'B';
+    QTest::newRow("BoyerMooreStressTest") << veryBigHaystack << veryBigHaystack << 0 << 0;
+    QTest::newRow("BoyerMooreStressTest2") << veryBigHaystack + 'c' << veryBigHaystack << 0 << 0;
+    QTest::newRow("BoyerMooreStressTest3") << 'c' + veryBigHaystack << veryBigHaystack << 0 << 1;
+    QTest::newRow("BoyerMooreStressTest4") << veryBigHaystack << veryBigHaystack + 'c' << 0 << -1;
+    QTest::newRow("BoyerMooreStressTest5") << veryBigHaystack << 'c' + veryBigHaystack << 0 << -1;
+    QTest::newRow("BoyerMooreStressTest6") << 'd' + veryBigHaystack << 'c' + veryBigHaystack << 0 << -1;
+    QTest::newRow("BoyerMooreStressTest6") << veryBigHaystack + 'c' << 'c' + veryBigHaystack << 0 << -1;
+}
+
+void tst_QByteArray::indexOf()
+{
+    QFETCH( QByteArray, haystack );
+    QFETCH( QByteArray, needle );
+    QFETCH( int, startpos );
+    QFETCH( int, expected );
+
+    bool hasNull = needle.contains('\0');
+
+    QCOMPARE( haystack.indexOf(needle, startpos), expected );
+    if (!hasNull)
+        QCOMPARE( haystack.indexOf(needle.data(), startpos), expected );
+    if (needle.size() == 1)
+        QCOMPARE( haystack.indexOf(needle.at(0), startpos), expected );
+
+    if (startpos == 0) {
+        QCOMPARE( haystack.indexOf(needle), expected );
+        if (!hasNull)
+            QCOMPARE( haystack.indexOf(needle.data()), expected );
+        if (needle.size() == 1)
+            QCOMPARE( haystack.indexOf(needle.at(0)), expected );
+    }
+}
+
+void tst_QByteArray::lastIndexOf_data()
+{
+    QTest::addColumn<QByteArray>("haystack");
+    QTest::addColumn<QByteArray>("needle");
+    QTest::addColumn<int>("startpos");
+    QTest::addColumn<int>("expected");
+
+    QTest::newRow( "1" ) << QByteArray("abc") << QByteArray("a") << 0 << 0;
+    QTest::newRow( "2" ) << QByteArray("abc") << QByteArray("A") << 0 << -1;
+    QTest::newRow( "3" ) << QByteArray("abc") << QByteArray("a") << 1 << 0;
+    QTest::newRow( "4" ) << QByteArray("abc") << QByteArray("A") << 1 << -1;
+    QTest::newRow( "5" ) << QByteArray("abc") << QByteArray("a") << -1 << 0;
+    QTest::newRow( "6" ) << QByteArray("abc") << QByteArray("b") << 0 << -1;
+    QTest::newRow( "7" ) << QByteArray("abc") << QByteArray("B") << 0 << -1;
+    QTest::newRow( "8" ) << QByteArray("abc") << QByteArray("b") << 1 << 1;
+    QTest::newRow( "9" ) << QByteArray("abc") << QByteArray("B") << 1 << -1;
+    QTest::newRow( "10" ) << QByteArray("abc") << QByteArray("b") << 2 << 1;
+    QTest::newRow( "11" ) << QByteArray("abc") << QByteArray("b") << -1 << 1;
+    QTest::newRow( "12" ) << QByteArray("abc") << QByteArray("c") << 0 << -1;
+    QTest::newRow( "13" ) << QByteArray("abc") << QByteArray("C") << 0 << -1;
+    QTest::newRow( "14" ) << QByteArray("abc") << QByteArray("c") << 1 << -1;
+    QTest::newRow( "15" ) << QByteArray("abc") << QByteArray("C") << 1 << -1;
+    QTest::newRow( "16" ) << QByteArray("abc") << QByteArray("c") << 2 << 2;
+    QTest::newRow( "17" ) << QByteArray("abc") << QByteArray("c") << -1 << 2;
+    QTest::newRow( "18" ) << QByteArray("aBc") << QByteArray("bc") << 0 << -1;
+    QTest::newRow( "19" ) << QByteArray("aBc") << QByteArray("Bc") << 0 << -1;
+    QTest::newRow( "20" ) << QByteArray("aBc") << QByteArray("Bc") << 2 << 1;
+    QTest::newRow( "21" ) << QByteArray("aBc") << QByteArray("Bc") << 1 << 1;
+    QTest::newRow( "22" ) << QByteArray("aBc") << QByteArray("Bc") << -1 << 1;
+    QTest::newRow( "23" ) << QByteArray("aBc") << QByteArray("bC") << 0 << -1;
+    QTest::newRow( "24" ) << QByteArray("aBc") << QByteArray("BC") << 0 << -1;
+
+    // task 203692
+    static const char h25[] = {0x00, 0xbc, 0x03, 0x10, 0x0a };
+    static const char n25[] = {0x00, 0x00, 0x01, 0x00};
+    QTest::newRow( "25" ) << QByteArray(h25, sizeof(h25))
+                          << QByteArray(n25, sizeof(n25)) << 0 << -1;
+
+    QTest::newRow( "empty" ) << QByteArray("") << QByteArray("x") << -1 << -1;
+    QTest::newRow( "null" ) << QByteArray() << QByteArray("x") << -1 << -1;
+    QTest::newRow( "null-in-null") << QByteArray() << QByteArray() << -1 << 0;
+    QTest::newRow( "empty-in-null") << QByteArray() << QByteArray("") << -1 << 0;
+    QTest::newRow( "null-in-empty") << QByteArray("") << QByteArray() << -1 << 0;
+    QTest::newRow( "empty-in-empty") << QByteArray("") << QByteArray("") << -1 << 0;
+}
+
+void tst_QByteArray::lastIndexOf()
+{
+    QFETCH( QByteArray, haystack );
+    QFETCH( QByteArray, needle );
+    QFETCH( int, startpos );
+    QFETCH( int, expected );
+
+    bool hasNull = needle.contains('\0');
+
+    QCOMPARE( haystack.lastIndexOf(needle, startpos), expected );
+    if (!hasNull)
+        QCOMPARE( haystack.lastIndexOf(needle.data(), startpos), expected );
+    if (needle.size() == 1)
+	QCOMPARE( haystack.lastIndexOf(needle.at(0), startpos), expected );
+
+    if (startpos == -1) {
+	QCOMPARE( haystack.lastIndexOf(needle), expected );
+        if (!hasNull)
+            QCOMPARE( haystack.lastIndexOf(needle.data()), expected );
+	if (needle.size() == 1)
+	    QCOMPARE( haystack.lastIndexOf(needle.at(0)), expected );
+    }
+}
+
+void tst_QByteArray::number()
+{
+    QCOMPARE(QString(QByteArray::number((quint64) 0)),
+	    QString(QByteArray("0")));
+    QCOMPARE(QString(QByteArray::number(Q_UINT64_C(0xFFFFFFFFFFFFFFFF))),
+	    QString(QByteArray("18446744073709551615")));
+    QCOMPARE(QString(QByteArray::number(Q_INT64_C(0xFFFFFFFFFFFFFFFF))),
+	    QString(QByteArray("-1")));
+    QCOMPARE(QString(QByteArray::number(qint64(0))),
+	    QString(QByteArray("0")));
+    QCOMPARE(QString(QByteArray::number(Q_INT64_C(0x7FFFFFFFFFFFFFFF))),
+	    QString(QByteArray("9223372036854775807")));
+    QCOMPARE(QString(QByteArray::number(Q_INT64_C(0x8000000000000000))),
+	    QString(QByteArray("-9223372036854775808")));
+}
+
+// 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("base 10") << QByteArray("100") << 10 << int(100) << true;
+    QTest::newRow("base 16") << QByteArray("100") << 16 << int(256) << true;
+    QTest::newRow("base 16") << 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") << QByteArray("0x10") << 0 << int(16) << true;
+    QTest::newRow("base 0") << QByteArray("10") << 0 << int(10) << true;
+    QTest::newRow("base 0") << QByteArray("010") << 0 << int(8) << true;
+    QTest::newRow("empty") << QByteArray() << 0 << 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("raw4") << 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 );
+}
+
+Q_DECLARE_METATYPE(qulonglong);
+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).toLatin1() << 10 << LongMaxPlusOne << true;
+    QTest::newRow("default") << 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;
+}
+
+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);
+}
+
+void tst_QByteArray::toULongLong_data()
+{
+    QTest::addColumn<QByteArray>("str");
+    QTest::addColumn<int>("base");
+    QTest::addColumn<qulonglong>("result");
+    QTest::addColumn<bool>("ok");
+
+    QTest::newRow("default") << QByteArray() << 10 << (qulonglong)0 << FALSE;
+    QTest::newRow("out of base bound") << QByteArray("c") << 10 << (qulonglong)0 << 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);
+}
+
+// global function defined in qbytearray.cpp
+void tst_QByteArray::qAllocMore()
+{
+    static const int t[] = {
+        INT_MIN, INT_MIN + 1, -1234567, -66000, -1025,
+        -3, -1, 0, +1, +3, +1025, +66000, +1234567, INT_MAX - 1, INT_MAX,
+        INT_MAX/3
+    };
+    static const int N = sizeof(t)/sizeof(t[0]);
+
+    // make sure qAllocMore() doesn't loop infinitely on any input
+    for (int i = 0; i < N; ++i) {
+        for (int j = 0; j < N; ++j) {
+            ::qAllocMore(t[i], t[j]);
+        }
+    }
+}
+
+void tst_QByteArray::resizeAfterFromRawData()
+{
+    QByteArray buffer("hello world");
+
+    QByteArray array = QByteArray::fromRawData(buffer.constData(), buffer.size());
+    QVERIFY(array.constData() == buffer.constData());
+    array.resize(5);
+    QVERIFY(array.constData() == buffer.constData());
+}
+
+void tst_QByteArray::appendAfterFromRawData()
+{
+    QByteArray arr;
+    {
+        char data[] = "X";
+        arr += QByteArray::fromRawData(data, sizeof(data));
+        data[0] = 'Y';
+    }
+    QVERIFY(arr.at(0) == 'X');
+}
+
+void tst_QByteArray::toFromHex_data()
+{
+    QTest::addColumn<QByteArray>("str");
+    QTest::addColumn<QByteArray>("hex");
+    QTest::addColumn<QByteArray>("hex_alt1");
+
+    QTest::newRow("Qt is great!")
+        << QByteArray("Qt is great!")
+        << QByteArray("517420697320677265617421")
+        << QByteArray("51 74 20 69 73 20 67 72 65 61 74 21");
+
+    QTest::newRow("Qt is so great!")
+        << QByteArray("Qt is so great!")
+        << QByteArray("517420697320736f20677265617421")
+        << QByteArray("51 74 20 69 73 20 73 6f 20 67 72 65 61 74 21");
+
+    QTest::newRow("default-constructed")
+        << QByteArray()
+        << QByteArray()
+        << QByteArray();
+
+    QTest::newRow("empty")
+        << QByteArray("")
+        << QByteArray("")
+        << QByteArray("");
+
+    QTest::newRow("array-of-null")
+        << QByteArray("\0", 1)
+        << QByteArray("00")
+        << QByteArray("0");
+
+    QTest::newRow("no-leading-zero")
+        << QByteArray("\xf")
+        << QByteArray("0f")
+        << QByteArray("f");
+
+    QTest::newRow("single-byte")
+        << QByteArray("\xaf")
+        << QByteArray("af")
+        << QByteArray("xaf");
+
+    QTest::newRow("no-leading-zero")
+        << QByteArray("\xd\xde\xad\xc0\xde")
+        << QByteArray("0ddeadc0de")
+        << QByteArray("ddeadc0de");
+
+    QTest::newRow("garbage")
+        << QByteArray("\xC\xde\xeC\xea\xee\xDe\xee\xee")
+        << QByteArray("0cdeeceaeedeeeee")
+        << QByteArray("Code less. Create more. Deploy everywhere.");
+
+    QTest::newRow("under-defined-1")
+        << QByteArray("\x1\x23")
+        << QByteArray("0123")
+        << QByteArray("x123");
+
+    QTest::newRow("under-defined-2")
+        << QByteArray("\x12\x34")
+        << QByteArray("1234")
+        << QByteArray("x1234");
+}
+
+void tst_QByteArray::toFromHex()
+{
+    QFETCH(QByteArray, str);
+    QFETCH(QByteArray, hex);
+    QFETCH(QByteArray, hex_alt1);
+
+    {
+        const QByteArray th = str.toHex();
+        QCOMPARE(th.size(), hex.size());
+        QCOMPARE(th, hex);
+    }
+
+    {
+        const QByteArray fh = QByteArray::fromHex(hex);
+        QCOMPARE(fh.size(), str.size());
+        QCOMPARE(fh, str);
+    }
+
+    QCOMPARE(QByteArray::fromHex(hex_alt1), str);
+}
+
+void tst_QByteArray::toFromPercentEncoding()
+{
+    QByteArray arr("Qt is great!");
+
+    QByteArray data = arr.toPercentEncoding();
+    QCOMPARE(QString(data), QString("Qt%20is%20great%21"));
+    QCOMPARE(QByteArray::fromPercentEncoding(data), arr);
+
+    data = arr.toPercentEncoding("! ", "Qt");
+    QCOMPARE(QString(data), QString("%51%74 is grea%74!"));
+    QCOMPARE(QByteArray::fromPercentEncoding(data), arr);
+
+    data = arr.toPercentEncoding(QByteArray(), "abcdefghijklmnopqrstuvwxyz", 'Q');
+    QCOMPARE(QString(data), QString("Q51Q74Q20Q69Q73Q20Q67Q72Q65Q61Q74Q21"));
+    QCOMPARE(QByteArray::fromPercentEncoding(data, 'Q'), arr);
+
+    // verify that to/from percent encoding preserves nullity
+    arr = "";
+    QVERIFY(arr.isEmpty());
+    QVERIFY(!arr.isNull());
+    QVERIFY(arr.toPercentEncoding().isEmpty());
+    QVERIFY(!arr.toPercentEncoding().isNull());
+    QVERIFY(QByteArray::fromPercentEncoding("").isEmpty());
+    QVERIFY(!QByteArray::fromPercentEncoding("").isNull());
+
+    arr = QByteArray();
+    QVERIFY(arr.isEmpty());
+    QVERIFY(arr.isNull());
+    QVERIFY(arr.toPercentEncoding().isEmpty());
+    QVERIFY(arr.toPercentEncoding().isNull());
+    QVERIFY(QByteArray::fromPercentEncoding(QByteArray()).isEmpty());
+    QVERIFY(QByteArray::fromPercentEncoding(QByteArray()).isNull());
+}
+
+void tst_QByteArray::compare_data()
+{
+    QTest::addColumn<QByteArray>("str1");
+    QTest::addColumn<QByteArray>("str2");
+    QTest::addColumn<int>("result");
+
+    QTest::newRow("null")      << QByteArray() << QByteArray() << 0;
+    QTest::newRow("null-empty")<< QByteArray() << QByteArray("") << 0;
+    QTest::newRow("empty-null")<< QByteArray("") << QByteArray() << 0;
+    QTest::newRow("null-full") << QByteArray() << QByteArray("abc") << -1;
+    QTest::newRow("full-null") << QByteArray("abc") << QByteArray() << +1;
+    QTest::newRow("empty-full")<< QByteArray("") << QByteArray("abc") << -1;
+    QTest::newRow("full-empty")<< QByteArray("abc") << QByteArray("") << +1;
+    QTest::newRow("rawempty-full") << QByteArray::fromRawData("abc", 0) << QByteArray("abc") << -1;
+    QTest::newRow("full-rawempty") << QByteArray("abc") << QByteArray::fromRawData("abc", 0) << +1;
+
+    QTest::newRow("equal   1") << QByteArray("abc") << QByteArray("abc") << 0;
+    QTest::newRow("equal   2") << QByteArray::fromRawData("abc", 3) << QByteArray("abc") << 0;
+    QTest::newRow("equal   3") << QByteArray::fromRawData("abcdef", 3) << QByteArray("abc") << 0;
+    QTest::newRow("equal   4") << QByteArray("abc") << QByteArray::fromRawData("abc", 3) << 0;
+    QTest::newRow("equal   5") << QByteArray("abc") << QByteArray::fromRawData("abcdef", 3) << 0;
+    QTest::newRow("equal   6") << QByteArray("a\0bc", 4) << QByteArray("a\0bc", 4) << 0;
+    QTest::newRow("equal   7") << QByteArray::fromRawData("a\0bcdef", 4) << QByteArray("a\0bc", 4) << 0;
+    QTest::newRow("equal   8") << QByteArray("a\0bc", 4) << QByteArray::fromRawData("a\0bcdef", 4) << 0;
+
+    QTest::newRow("less    1") << QByteArray("000") << QByteArray("abc") << -1;
+    QTest::newRow("less    2") << QByteArray::fromRawData("00", 3) << QByteArray("abc") << -1;
+    QTest::newRow("less    3") << QByteArray("000") << QByteArray::fromRawData("abc", 3) << -1;
+    QTest::newRow("less    4") << QByteArray("abc", 3) << QByteArray("abc", 4) << -1;
+    QTest::newRow("less    5") << QByteArray::fromRawData("abc\0", 3) << QByteArray("abc\0", 4) << -1;
+    QTest::newRow("less    6") << QByteArray("a\0bc", 4) << QByteArray("a\0bd", 4) << -1;
+
+    QTest::newRow("greater 1") << QByteArray("abc") << QByteArray("000") << +1;
+    QTest::newRow("greater 2") << QByteArray("abc") << QByteArray::fromRawData("00", 3) << +1;
+    QTest::newRow("greater 3") << QByteArray("abcd") << QByteArray::fromRawData("abcd", 3) << +1;
+    QTest::newRow("greater 4") << QByteArray("a\0bc", 4) << QByteArray("a\0bb", 4) << +1;
+}
+
+void tst_QByteArray::compare()
+{
+    QFETCH(QByteArray, str1);
+    QFETCH(QByteArray, str2);
+    QFETCH(int, result);
+
+    const bool isEqual   = result == 0;
+    const bool isLess    = result < 0;
+    const bool isGreater = result > 0;
+
+    // basic tests:
+    QCOMPARE(str1 == str2, isEqual);
+    QCOMPARE(str1 < str2, isLess);
+    QCOMPARE(str1 > str2, isGreater);
+
+    // composed tests:
+    QCOMPARE(str1 <= str2, isLess || isEqual);
+    QCOMPARE(str1 >= str2, isGreater || isEqual);
+    QCOMPARE(str1 != str2, !isEqual);
+
+    // inverted tests:
+    QCOMPARE(str2 == str1, isEqual);
+    QCOMPARE(str2 < str1, isGreater);
+    QCOMPARE(str2 > str1, isLess);
+
+    // composed, inverted tests:
+    QCOMPARE(str2 <= str1, isGreater || isEqual);
+    QCOMPARE(str2 >= str1, isLess || isEqual);
+    QCOMPARE(str2 != str1, !isEqual);
+}
+
+void tst_QByteArray::compareCharStar_data()
+{
+    QTest::addColumn<QByteArray>("str1");
+    QTest::addColumn<QString>("string2");
+    QTest::addColumn<int>("result");
+
+    QTest::newRow("null-null") << QByteArray() << QString() << 0;
+    QTest::newRow("null-empty") << QByteArray() << "" << 0;
+    QTest::newRow("null-full") << QByteArray() << "abc" << -1;
+    QTest::newRow("empty-null") << QByteArray("") << QString() << 0;
+    QTest::newRow("empty-empty") << QByteArray("") << "" << 0;
+    QTest::newRow("empty-full") << QByteArray("") << "abc" << -1;
+    QTest::newRow("raw-null") << QByteArray::fromRawData("abc", 0) << QString() << 0;
+    QTest::newRow("raw-empty") << QByteArray::fromRawData("abc", 0) << QString("") << 0;
+    QTest::newRow("raw-full") << QByteArray::fromRawData("abc", 0) << "abc" << -1;
+
+    QTest::newRow("full-null") << QByteArray("abc") << QString() << +1;
+    QTest::newRow("full-empty") << QByteArray("abc") << "" << +1;
+
+    QTest::newRow("equal1") << QByteArray("abc") << "abc" << 0;
+    QTest::newRow("equal2") << QByteArray("abcd", 3) << "abc" << 0;
+    QTest::newRow("equal3") << QByteArray::fromRawData("abcd", 3) << "abc" << 0;
+
+    QTest::newRow("less1") << QByteArray("ab") << "abc" << -1;
+    QTest::newRow("less2") << QByteArray("abb") << "abc" << -1;
+    QTest::newRow("less3") << QByteArray::fromRawData("abc", 2) << "abc" << -1;
+    QTest::newRow("less4") << QByteArray("", 1) << "abc" << -1;
+    QTest::newRow("less5") << QByteArray::fromRawData("", 1) << "abc" << -1;
+    QTest::newRow("less6") << QByteArray("a\0bc", 4) << "a.bc" << -1;
+
+    QTest::newRow("greater1") << QByteArray("ac") << "abc" << +1;
+    QTest::newRow("greater2") << QByteArray("abd") << "abc" << +1;
+    QTest::newRow("greater3") << QByteArray("abcd") << "abc" << +1;
+    QTest::newRow("greater4") << QByteArray::fromRawData("abcd", 4) << "abc" << +1;
+}
+
+void tst_QByteArray::compareCharStar()
+{
+    QFETCH(QByteArray, str1);
+    QFETCH(QString, string2);
+    QFETCH(int, result);
+
+    const bool isEqual   = result == 0;
+    const bool isLess    = result < 0;
+    const bool isGreater = result > 0;
+    QByteArray qba = string2.toLatin1();
+    const char *str2 = qba.constData();
+    if (string2.isNull())
+        str2 = 0;
+
+    // basic tests:
+    QCOMPARE(str1 == str2, isEqual);
+    QCOMPARE(str1 < str2, isLess);
+    QCOMPARE(str1 > str2, isGreater);
+
+    // composed tests:
+    QCOMPARE(str1 <= str2, isLess || isEqual);
+    QCOMPARE(str1 >= str2, isGreater || isEqual);
+    QCOMPARE(str1 != str2, !isEqual);
+
+    // inverted tests:
+    QCOMPARE(str2 == str1, isEqual);
+    QCOMPARE(str2 < str1, isGreater);
+    QCOMPARE(str2 > str1, isLess);
+
+    // composed, inverted tests:
+    QCOMPARE(str2 <= str1, isGreater || isEqual);
+    QCOMPARE(str2 >= str1, isLess || isEqual);
+    QCOMPARE(str2 != str1, !isEqual);
+}
+
+void tst_QByteArray::repeatedSignature() const
+{
+    /* repated() should be a const member. */
+    const QByteArray string;
+    string.repeated(3);
+}
+
+void tst_QByteArray::repeated() const
+{
+    QFETCH(QByteArray, string);
+    QFETCH(QByteArray, expected);
+    QFETCH(int, count);
+
+    QCOMPARE(string.repeated(count), expected);
+}
+
+void tst_QByteArray::repeated_data() const
+{
+    QTest::addColumn<QByteArray>("string" );
+    QTest::addColumn<QByteArray>("expected" );
+    QTest::addColumn<int>("count" );
+
+    /* Empty strings. */
+    QTest::newRow("")
+        << QByteArray()
+        << QByteArray()
+        << 0;
+
+    QTest::newRow("")
+        << QByteArray()
+        << QByteArray()
+        << -1004;
+
+    QTest::newRow("")
+        << QByteArray()
+        << QByteArray()
+        << 1;
+
+    QTest::newRow("")
+        << QByteArray()
+        << QByteArray()
+        << 5;
+
+    /* On simple string. */
+    QTest::newRow("")
+        << QByteArray("abc")
+        << QByteArray()
+        << -1004;
+
+    QTest::newRow("")
+        << QByteArray("abc")
+        << QByteArray()
+        << -1;
+
+    QTest::newRow("")
+        << QByteArray("abc")
+        << QByteArray()
+        << 0;
+
+    QTest::newRow("")
+        << QByteArray("abc")
+        << QByteArray("abc")
+        << 1;
+
+    QTest::newRow("")
+        << QByteArray(("abc"))
+        << QByteArray(("abcabc"))
+        << 2;
+
+    QTest::newRow("")
+        << QByteArray(("abc"))
+        << QByteArray(("abcabcabc"))
+        << 3;
+
+    QTest::newRow("")
+        << QByteArray(("abc"))
+        << QByteArray(("abcabcabcabc"))
+        << 4;
+}
+
+void tst_QByteArray::byteRefDetaching() const
+{
+    {
+        QByteArray str = "str";
+        QByteArray copy;
+        copy[0] = 'S';
+
+        QCOMPARE(str, QByteArray("str"));
+    }
+
+    {
+        char buf[] = { 's', 't', 'r' };
+        QByteArray str = QByteArray::fromRawData(buf, 3);
+        str[0] = 'S';
+
+        QCOMPARE(buf[0], char('s'));
+    }
+
+    {
+        static const char buf[] = { 's', 't', 'r' };
+        QByteArray str = QByteArray::fromRawData(buf, 3);
+
+        // this causes a crash in most systems if the detaching doesn't work
+        str[0] = 'S';
+
+        QCOMPARE(buf[0], char('s'));
+    }
+}
+
+const char globalChar = '1';
+
+QTEST_APPLESS_MAIN(tst_QByteArray)
+#include "tst_qbytearray.moc"