/****************************************************************************

**

** 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$

** 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 Technology Preview License Agreement accompanying

** this package.

**

** 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.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@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=

#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 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 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 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);

    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;

    QT_TRY {

        res = ::qUncompress(in);

    } QT_CATCH(const std::bad_alloc &) {

        res = QByteArray();

    }

    QCOMPARE(res, out);

    QT_TRY {

        res = ::qUncompress(in + "blah");

    } QT_CATCH(const std::bad_alloc &) {

        res = QByteArray();

    }

    QCOMPARE(res, 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==");

    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");