diff options
Diffstat (limited to 'tests/auto/qbytearray/tst_qbytearray.cpp')
| -rw-r--r-- | tests/auto/qbytearray/tst_qbytearray.cpp | 1567 |
1 files changed, 0 insertions, 1567 deletions
diff --git a/tests/auto/qbytearray/tst_qbytearray.cpp b/tests/auto/qbytearray/tst_qbytearray.cpp deleted file mode 100644 index 78b655419e..0000000000 --- a/tests/auto/qbytearray/tst_qbytearray.cpp +++ /dev/null @@ -1,1567 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). -** All rights reserved. -** Contact: Nokia Corporation (qt-info@nokia.com) -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** GNU Lesser General Public License Usage -** 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.1, 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. -** -** Other Usage -** Alternatively, this file may be used in accordance with the terms and -** conditions contained in a signed written agreement between you and Nokia. -** -** -** -** -** -** $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= - -#if defined(Q_OS_SYMBIAN) -#define SRCDIR "" -#endif - -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 swap(); - void qCompress_data(); -#ifndef QT_NO_COMPRESS - void qCompress(); - void qUncompress_data(); - void qUncompress(); - void qCompressionZeroTermination(); -#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 fromBase64_data(); - void fromBase64(); - 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 replaceWithSpecifiedLength(); - 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; - - void reserve(); - - void literals(); -}; - -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", 4) << QByteArray(); - QTest::newRow("0x000000ff") << QByteArray("\x00\x00\x00\xff", 4) << QByteArray(); - QTest::newRow("0x3f000000") << QByteArray("\x3f\x00\x00\x00", 4) << QByteArray(); - QTest::newRow("0x3fffffff") << QByteArray("\x3f\xff\xff\xff", 4) << QByteArray(); - QTest::newRow("0x7fffff00") << QByteArray("\x7f\xff\xff\x00", 4) << QByteArray(); - QTest::newRow("0x7fffffff") << QByteArray("\x7f\xff\xff\xff", 4) << QByteArray(); - QTest::newRow("0x80000000") << QByteArray("\x80\x00\x00\x00", 4) << QByteArray(); - QTest::newRow("0x800000ff") << QByteArray("\x80\x00\x00\xff", 4) << QByteArray(); - QTest::newRow("0xcf000000") << QByteArray("\xcf\x00\x00\x00", 4) << QByteArray(); - QTest::newRow("0xcfffffff") << QByteArray("\xcf\xff\xff\xff", 4) << QByteArray(); - QTest::newRow("0xffffff00") << QByteArray("\xff\xff\xff\x00", 4) << QByteArray(); - QTest::newRow("0xffffffff") << QByteArray("\xff\xff\xff\xff", 4) << QByteArray(); -} - -void tst_QByteArray::qUncompress() -{ - QFETCH(QByteArray, in); - QFETCH(QByteArray, out); - -#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); -#elif defined Q_OS_QNX - QSKIP("Corrupt data causes this test to lock up on QNX", SkipAll); -#endif - - QByteArray res; - res = ::qUncompress(in); - QCOMPARE(res, out); - - res = ::qUncompress(in + "blah"); - QCOMPARE(res, out); -} - -void tst_QByteArray::qCompressionZeroTermination() -{ - QString s = "Hello, I'm a string."; - QByteArray ba = ::qUncompress(::qCompress(s.toLocal8Bit())); - QVERIFY((int) *(ba.data() + ba.size()) == 0); -} - -#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::swap() -{ - QByteArray b1 = "b1", b2 = "b2"; - b1.swap(b2); - QCOMPARE(b1, QByteArray("b2")); - QCOMPARE(b2, QByteArray("b1")); -} - -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=="); - - 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="); -} - - -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); -} - -//different from the previous test as the input are invalid -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"); - - QByteArray ba; - ba.resize(256); - for (int i = 0; i < 256; ++i) - ba[i] = i; - QTest::newRow("f") << ba << QByteArray("AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Nj\n" - "c4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1u\n" - "b3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpa\n" - "anqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd\n" - "3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w== "); - - - 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"); - -} - - -void tst_QByteArray::fromBase64() -{ - QFETCH(QByteArray, rawdata); - QFETCH(QByteArray, base64); - - QByteArray arr = QByteArray::fromBase64(base64); - QCOMPARE(arr, rawdata); -} - -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 necessary - 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")); - QCOMPARE(ba.prepend("\0 ", 2), QByteArray::fromRawData("\0 321foo", 8)); -} - -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")); - QCOMPARE(ba.append("\0"), QByteArray("foo123")); - QCOMPARE(ba.append("\0", 1), QByteArray::fromRawData("foo123\0", 7)); - QCOMPARE(ba.size(), 7); -} - -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); - - ba = "ab"; - QCOMPARE(ba.insert(1, "\0X\0", 3), QByteArray::fromRawData("a\0X\0b", 5)); - QCOMPARE(ba.size(), 5); -} - -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::replaceWithSpecifiedLength() -{ - const char after[] = "zxc\0vbnmqwert"; - int lenAfter = 6; - QByteArray ba("abcdefghjk"); - ba.replace(0,2,after,lenAfter); - - const char _expected[] = "zxc\0vbcdefghjk"; - QByteArray expected(_expected,sizeof(_expected)-1); - QCOMPARE(ba,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, (char)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") << QByteArray(veryBigHaystack + 'c') << QByteArray(veryBigHaystack) << 0 << 0; - QTest::newRow("BoyerMooreStressTest3") << QByteArray('c' + veryBigHaystack) << QByteArray(veryBigHaystack) << 0 << 1; - QTest::newRow("BoyerMooreStressTest4") << QByteArray(veryBigHaystack) << QByteArray(veryBigHaystack + 'c') << 0 << -1; - QTest::newRow("BoyerMooreStressTest5") << QByteArray(veryBigHaystack) << QByteArray('c' + veryBigHaystack) << 0 << -1; - QTest::newRow("BoyerMooreStressTest6") << QByteArray('d' + veryBigHaystack) << QByteArray('c' + veryBigHaystack) << 0 << -1; - QTest::newRow("BoyerMooreStressTest6") << QByteArray(veryBigHaystack + 'c') << QByteArray('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, (char)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); -*/ - QByteArray 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')); - } -} - -void tst_QByteArray::reserve() -{ - int capacity = 100; - QByteArray qba; - qba.reserve(capacity); - QVERIFY(qba.capacity() == capacity); - char *data = qba.data(); - - for (int i = 0; i < capacity; i++) { - qba.resize(i); - QVERIFY(capacity == qba.capacity()); - QVERIFY(data == qba.data()); - } -} - -void tst_QByteArray::literals() -{ -#if defined(Q_COMPILER_LAMBDA) || defined(Q_CC_GNU) - QByteArray str(QByteArrayLiteral("abcd")); - - QVERIFY(str.length() == 4); - QVERIFY(str == "abcd"); - QVERIFY(str.data_ptr()->ref == -1); - QVERIFY(str.data_ptr()->offset == 0); - - const char *s = str.constData(); - QByteArray str2 = str; - QVERIFY(str2.constData() == s); - - // detach on non const access - QVERIFY(str.data() != s); - - QVERIFY(str2.constData() == s); - QVERIFY(str2.data() != s); - -#else - QSKIP("Only tested on c++0x compliant compiler or gcc", SkipAll); -#endif -} - -const char globalChar = '1'; - -QTEST_APPLESS_MAIN(tst_QByteArray) -#include "tst_qbytearray.moc" |