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

**

** Copyright (C) 2010 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$

** 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 <qregexp.h>

#include <qtextcodec.h>

#include <qtextstream.h>

#include <qstringlist.h>

#include <qstringmatcher.h>

#include <qbytearraymatcher.h>

#include <qvariant.h>

#include <qlocale.h>

#include <locale.h>

Q_DECLARE_METATYPE(qlonglong)

//TESTED_CLASS=

//TESTED_FILES=

class tst_QString : public QObject

{

    Q_OBJECT

public:

    tst_QString();

    virtual ~tst_QString();

public slots:

    void init();

    void cleanup();

private slots:

    void fromStdString();

    void toStdString();

    void check_QTextIOStream();

    void check_QTextStream();

    void check_QDataStream();

    void fromRawData();

    void endsWith();

    void startsWith();

    void setNum();

    void toDouble_data();

    void toDouble();

    void toFloat();

    void toLong_data();

    void toLong();

    void toULong_data();

    void toULong();

    void toLongLong();

    void toULongLong();

    void toUInt();

    void toInt();

    void toShort();

    void toUShort();

    void replace_qchar_qchar_data();

    void replace_qchar_qchar();

    void replace_qchar_qstring_data();

    void replace_qchar_qstring();

    void replace_uint_uint_data();

    void replace_uint_uint();

    void replace_uint_uint_extra();

    void replace_string_data();

    void replace_string();

    void replace_regexp_data();

    void replace_regexp();

    void remove_uint_uint_data();

    void remove_uint_uint();

    void remove_string_data();

    void remove_string();

    void remove_regexp_data();

    void remove_regexp();

    void prepend();

    void prepend_bytearray_data();

    void prepend_bytearray();

    void append();

    void append_bytearray_data();

    void append_bytearray();

    void operator_pluseq_bytearray_data();

    void operator_pluseq_bytearray();

    void operator_eqeq_nullstring();

    void operator_smaller();

    void insert();

    void simplified_data();

    void simplified();

    void trimmed();

    void toLower();

    void toUpper();

    void rightJustified();

    void leftJustified();

    void mid();

    void right();

    void left();

    void midRef();

    void rightRef();

    void leftRef();

    void stringRef();

    void contains();

    void lastIndexOf_data();

    void lastIndexOf();

    void indexOf_data();

    void indexOf();

    void indexOf2_data();

    void indexOf2();

    void indexOf3_data();

//  void indexOf3();

    void sprintf();

    void copy();

    void fill();

    void truncate();

    void constructor();

    void constructorQByteArray_data();

    void constructorQByteArray();

    void STL();

    void isEmpty();

    void isNull();

    void acc_01();

    void length_data();

    void length();

    void utf8_data();

    void utf8();

    void fromUtf8_data();

    void fromUtf8();

    void nullFromUtf8();

    void fromLocal8Bit_data();

    void fromLocal8Bit();

    void local8Bit_data();

    void local8Bit();

    void fromLatin1Roundtrip_data();

    void fromLatin1Roundtrip();

    void toLatin1Roundtrip_data();

    void toLatin1Roundtrip();

    void fromLatin1();

    void fromAscii();

    void arg();

    void number();

    void arg_fillChar_data();

    void arg_fillChar();

    void capacity_data();

    void capacity();

    void section_data();

    void section();

    void double_conversion_data();

    void double_conversion();

    void integer_conversion_data();

    void integer_conversion();

    void tortureSprintfDouble();

    void toNum();

    void localeAwareCompare_data();

    void localeAwareCompare();

    void split_data();

    void split();

    void split_regexp();

    void fromUtf16_data();

    void fromUtf16();

    void latin1String();

    void nanAndInf();

    void compare_data();

    void compare();

    void resizeAfterFromRawData();

    void resizeAfterReserve();

    void resizeWithNegative() const;

    void truncateWithNegative() const;

    void QCharRefMutableUnicode() const;

    void QCharRefDetaching() const;

    void sprintfZU() const;

    void repeatedSignature() const;

    void repeated() const;

    void repeated_data() const;

    void task262677remove();

};

typedef QList<int> IntList;

Q_DECLARE_METATYPE(QList<QVariant>)

Q_DECLARE_METATYPE(IntList)

// This next bit is needed for the NAN and INF in string -> number conversion tests

#include <float.h>

#include <limits.h>

#include <math.h>

#if defined (Q_WS_WIN)

#   include <windows.h>

// mingw defines NAN and INFINITY to 0/0 and x/0

#   if defined(Q_CC_GNU)

#      undef NAN

#      undef INFINITY

#   else

#      define isnan(d) _isnan(d)

#   endif

#endif

#if defined (Q_OS_MAC) && !defined isnan

#define isnan(d) __isnand(d)

#endif

#if defined (Q_OS_SOLARIS)

#   include <ieeefp.h>

#endif

#if defined (Q_OS_OSF) && (defined(__DECC) || defined(__DECCXX))

#   define INFINITY DBL_INFINITY

#   define NAN DBL_QNAN

#endif

#if defined(Q_OS_IRIX) && defined(Q_CC_GNU)

#   include <ieeefp.h>

#   define isnan(d) isnand(d)

#endif

enum {

    LittleEndian,

    BigEndian

#ifdef Q_BYTE_ORDER

#  if Q_BYTE_ORDER == Q_BIG_ENDIAN

    , ByteOrder = BigEndian

#  elif Q_BYTE_ORDER == Q_LITTLE_ENDIAN

    , ByteOrder = LittleEndian

#  else

#    error "undefined byte order"

#  endif

};

#else

};

static const unsigned int one = 1;

static const bool ByteOrder = ((*((unsigned char *) &one) == 0) ? BigEndian : LittleEndian);

#endif

#if !defined(INFINITY)

static const unsigned char be_inf_bytes[] = { 0x7f, 0xf0, 0, 0, 0, 0, 0,0 };

static const unsigned char le_inf_bytes[] = { 0, 0, 0, 0, 0, 0, 0xf0, 0x7f };

static inline double inf()

{

    if (ByteOrder == BigEndian)

        return *reinterpret_cast<const double *>(be_inf_bytes);

    return *reinterpret_cast<const double *>(le_inf_bytes);

}

#   define INFINITY (::inf())

#endif

#if !defined(NAN)

static const unsigned char be_nan_bytes[] = { 0x7f, 0xf8, 0, 0, 0, 0, 0,0 };

static const unsigned char le_nan_bytes[] = { 0, 0, 0, 0, 0, 0, 0xf8, 0x7f };

static inline double nan()

{

    if (ByteOrder == BigEndian)

        return *reinterpret_cast<const double *>(be_nan_bytes);

    return *reinterpret_cast<const double *>(le_nan_bytes);

}

#   define NAN (::nan())

#endif

tst_QString::tst_QString()

{

    QTextCodec::setCodecForLocale(QTextCodec::codecForName("ISO 8859-1"));

}

tst_QString::~tst_QString()

{

}

void tst_QString::init()

{

}

void tst_QString::cleanup()

{

    QLocale::setDefault(QString("C"));

}

void tst_QString::remove_uint_uint_data()

{

    replace_uint_uint_data();

}

void tst_QString::remove_string_data()

{

    replace_string_data();

}

void tst_QString::remove_regexp_data()

{

    replace_regexp_data();

}

void tst_QString::indexOf3_data()

{

    indexOf2_data();

}

void tst_QString::length_data()

{

    QTest::addColumn<QString>("s1" );

    QTest::addColumn<int>("res" );

    QTest::newRow( "data0" )  << QString("Test") << 4;

    QTest::newRow( "data1" )  << QString("The quick brown fox jumps over the lazy dog") << 43;

    QTest::newRow( "data2" )  << QString() << 0;

    QTest::newRow( "data3" )  << QString("A") << 1;

    QTest::newRow( "data4" )  << QString("AB") << 2;

    QTest::newRow( "data5" )  << QString("AB\n") << 3;

    QTest::newRow( "data6" )  << QString("AB\nC") << 4;

    QTest::newRow( "data7" )  << QString("\n") << 1;

    QTest::newRow( "data8" )  << QString("\nA") << 2;

    QTest::newRow( "data9" )  << QString("\nAB") << 3;

    QTest::newRow( "data10" )  << QString("\nAB\nCDE") << 7;

    QTest::newRow( "data11" )  << QString("shdnftrheid fhgnt gjvnfmd chfugkh bnfhg thgjf vnghturkf chfnguh bjgnfhvygh hnbhgutjfv dhdnjds dcjs d") << 100;

}

void tst_QString::replace_qchar_qchar_data()

{

    QTest::addColumn<QString>("src" );

    QTest::addColumn<QChar>("before" );

    QTest::addColumn<QChar>("after" );

    QTest::addColumn<int>("cs" );

    QTest::addColumn<QString>("expected" );

    QTest::newRow( "1" ) << QString("foo") << QChar('o') << QChar('a')

                      << int(Qt::CaseSensitive) << QString("faa");

    QTest::newRow( "2" ) << QString("foo") << QChar('o') << QChar('a')

                      << int(Qt::CaseInsensitive) << QString("faa");

    QTest::newRow( "3" ) << QString("foo") << QChar('O') << QChar('a')

                      << int(Qt::CaseSensitive) << QString("foo");

    QTest::newRow( "4" ) << QString("foo") << QChar('O') << QChar('a')

                      << int(Qt::CaseInsensitive) << QString("faa");

    QTest::newRow( "5" ) << QString("ababABAB") << QChar('a') << QChar(' ')

                      << int(Qt::CaseSensitive) << QString(" b bABAB");

    QTest::newRow( "6" ) << QString("ababABAB") << QChar('a') << QChar(' ')

                      << int(Qt::CaseInsensitive) << QString(" b b B B");

    QTest::newRow( "7" ) << QString("ababABAB") << QChar() << QChar(' ')

                      << int(Qt::CaseInsensitive) << QString("ababABAB");

}

void tst_QString::replace_qchar_qchar()

{

    QFETCH(QString, src);

    QFETCH(QChar, before);

    QFETCH(QChar, after);

    QFETCH(int, cs);

    QFETCH(QString, expected);

    QCOMPARE(src.replace(before, after, Qt::CaseSensitivity(cs)), expected);

}

void tst_QString::replace_qchar_qstring_data()

{

    QTest::addColumn<QString>("src" );

    QTest::addColumn<QChar>("before" );

    QTest::addColumn<QString>("after" );

    QTest::addColumn<int>("cs" );

    QTest::addColumn<QString>("expected" );

    QTest::newRow( "1" ) << QString("foo") << QChar('o') << QString("aA")

                      << int(Qt::CaseSensitive) << QString("faAaA");

    QTest::newRow( "2" ) << QString("foo") << QChar('o') << QString("aA")

                      << int(Qt::CaseInsensitive) << QString("faAaA");

    QTest::newRow( "3" ) << QString("foo") << QChar('O') << QString("aA")

                      << int(Qt::CaseSensitive) << QString("foo");

    QTest::newRow( "4" ) << QString("foo") << QChar('O') << QString("aA")

                      << int(Qt::CaseInsensitive) << QString("faAaA");

    QTest::newRow( "5" ) << QString("ababABAB") << QChar('a') << QString("  ")

                      << int(Qt::CaseSensitive) << QString("  b  bABAB");

    QTest::newRow( "6" ) << QString("ababABAB") << QChar('a') << QString("  ")

                      << int(Qt::CaseInsensitive) << QString("  b  b  B  B");

    QTest::newRow( "7" ) << QString("ababABAB") << QChar() << QString("  ")

                      << int(Qt::CaseInsensitive) << QString("ababABAB");

    QTest::newRow( "8" ) << QString("ababABAB") << QChar() << QString()

                      << int(Qt::CaseInsensitive) << QString("ababABAB");

}

void tst_QString::replace_qchar_qstring()

{

    QFETCH(QString, src);

    QFETCH(QChar, before);

    QFETCH(QString, after);

    QFETCH(int, cs);

    QFETCH(QString, expected);

    QCOMPARE(src.replace(before, after, Qt::CaseSensitivity(cs)), expected);

}

void tst_QString::replace_uint_uint_data()

{

    QTest::addColumn<QString>("string" );

    QTest::addColumn<int>("index" );

    QTest::addColumn<int>("len" );

    QTest::addColumn<QString>("after" );

    QTest::addColumn<QString>("result" );

    QTest::newRow( "rem00" ) << QString("-<>ABCABCABCABC>") << 0 << 3 << QString("") << QString("ABCABCABCABC>");

    QTest::newRow( "rem01" ) << QString("ABCABCABCABC>") << 1 << 4 << QString("") << QString("ACABCABC>");

    QTest::newRow( "rem04" ) << QString("ACABCABC>") << 8 << 4 << QString("") << QString("ACABCABC");

    QTest::newRow( "rem05" ) << QString("ACABCABC") << 7 << 1 << QString("") << QString("ACABCAB");

    QTest::newRow( "rem06" ) << QString("ACABCAB") << 4 << 0 << QString("") << QString("ACABCAB");

    QTest::newRow( "rep00" ) << QString("ACABCAB") << 4 << 0 << QString("X") << QString("ACABXCAB");

    QTest::newRow( "rep01" ) << QString("ACABXCAB") << 4 << 1 << QString("Y") << QString("ACABYCAB");

    QTest::newRow( "rep02" ) << QString("ACABYCAB") << 4 << 1 << QString("") << QString("ACABCAB");

    QTest::newRow( "rep03" ) << QString("ACABCAB") << 0 << 9999 << QString("XX") << QString("XX");

    QTest::newRow( "rep04" ) << QString("XX") << 0 << 9999 << QString("") << QString("");

    QTest::newRow( "rep05" ) << QString("ACABCAB") << 0 << 2 << QString("XX") << QString("XXABCAB");

    QTest::newRow( "rep06" ) << QString("ACABCAB") << 1 << 2 << QString("XX") << QString("AXXBCAB");

    QTest::newRow( "rep07" ) << QString("ACABCAB") << 2 << 2 << QString("XX") << QString("ACXXCAB");

    QTest::newRow( "rep08" ) << QString("ACABCAB") << 3 << 2 << QString("XX") << QString("ACAXXAB");

    QTest::newRow( "rep09" ) << QString("ACABCAB") << 4 << 2 << QString("XX") << QString("ACABXXB");

    QTest::newRow( "rep10" ) << QString("ACABCAB") << 5 << 2 << QString("XX") << QString("ACABCXX");

    QTest::newRow( "rep10" ) << QString("ACABCAB") << 6 << 2 << QString("XX") << QString("ACABCAXX");

    QTest::newRow( "rep12" ) << QString() << 0 << 10 << QString("X") << QString("X");

    QTest::newRow( "rep13" ) << QString("short") << 0 << 10 << QString("X") << QString("X");

    QTest::newRow( "rep14" ) << QString() << 0 << 10 << QString("XX") << QString("XX");

    QTest::newRow( "rep15" ) << QString("short") << 0 << 10 << QString("XX") << QString("XX");

}

void tst_QString::replace_string_data()

{

    QTest::addColumn<QString>("string" );

    QTest::addColumn<QString>("before" );

    QTest::addColumn<QString>("after" );

    QTest::addColumn<QString>("result" );

    QTest::addColumn<bool>("bcs" );

    QTest::newRow( "rem00" ) << QString("") << QString("") << QString("") << QString("") << true;

    QTest::newRow( "rem01" ) << QString("A") << QString("") << QString("") << QString("A") << true;

    QTest::newRow( "rem02" ) << QString("A") << QString("A") << QString("") << QString("") << true;

    QTest::newRow( "rem03" ) << QString("A") << QString("B") << QString("") << QString("A") << true;

    QTest::newRow( "rem04" ) << QString("AA") << QString("A") << QString("") << QString("") << true;

    QTest::newRow( "rem05" ) << QString("AB") << QString("A") << QString("") << QString("B") << true;

    QTest::newRow( "rem06" ) << QString("AB") << QString("B") << QString("") << QString("A") << true;

    QTest::newRow( "rem07" ) << QString("AB") << QString("C") << QString("") << QString("AB") << true;

    QTest::newRow( "rem08" ) << QString("ABA") << QString("A") << QString("") << QString("B") << true;

    QTest::newRow( "rem09" ) << QString("ABA") << QString("B") << QString("") << QString("AA") << true;

    QTest::newRow( "rem10" ) << QString("ABA") << QString("C") << QString("") << QString("ABA") << true;

    QTest::newRow( "rem11" ) << QString("banana") << QString("an") << QString("") << QString("ba") << true;

    QTest::newRow( "rem12" ) << QString("") << QString("A") << QString("") << QString("") << true;

    QTest::newRow( "rem13" ) << QString("") << QString("A") << QString() << QString("") << true;

    QTest::newRow( "rem14" ) << QString() << QString("A") << QString("") << QString() << true;

    QTest::newRow( "rem15" ) << QString() << QString("A") << QString() << QString() << true;

    QTest::newRow( "rem16" ) << QString() << QString("") << QString("") << QString("") << true;

    QTest::newRow( "rem17" ) << QString("") << QString() << QString("") << QString("") << true;

    QTest::newRow( "rem18" ) << QString("a") << QString("a") << QString("") << QString("") << false;

    QTest::newRow( "rem19" ) << QString("A") << QString("A") << QString("") << QString("") << false;

    QTest::newRow( "rem20" ) << QString("a") << QString("A") << QString("") << QString("") << false;

    QTest::newRow( "rem21" ) << QString("A") << QString("a") << QString("") << QString("") << false;

    QTest::newRow( "rem22" ) << QString("Alpha beta") << QString("a") << QString("") << QString("lph bet") << false;

    QTest::newRow( "rep00" ) << QString("ABC") << QString("B") << QString("-") << QString("A-C") << true;

    QTest::newRow( "rep01" ) << QString("$()*+.?[\\]^{|}") << QString("$()*+.?[\\]^{|}") << QString("X") << QString("X") << true;

    QTest::newRow( "rep02" ) << QString("ABCDEF") << QString("") << QString("X") << QString("XAXBXCXDXEXFX") << true;

    QTest::newRow( "rep03" ) << QString("") << QString("") << QString("X") << QString("X") << true;

    QTest::newRow( "rep04" ) << QString("a") << QString("a") << QString("b") << QString("b") << false;

    QTest::newRow( "rep05" ) << QString("A") << QString("A") << QString("b") << QString("b") << false;

    QTest::newRow( "rep06" ) << QString("a") << QString("A") << QString("b") << QString("b") << false;

    QTest::newRow( "rep07" ) << QString("A") << QString("a") << QString("b") << QString("b") << false;

    QTest::newRow( "rep08" ) << QString("a") << QString("a") << QString("a") << QString("a") << false;

    QTest::newRow( "rep09" ) << QString("A") << QString("A") << QString("a") << QString("a") << false;

    QTest::newRow( "rep10" ) << QString("a") << QString("A") << QString("a") << QString("a") << false;

    QTest::newRow( "rep11" ) << QString("A") << QString("a") << QString("a") << QString("a") << false;

    QTest::newRow( "rep12" ) << QString("Alpha beta") << QString("a") << QString("o") << QString("olpho beto") << false;

    QTest::newRow( "rep13" ) << QString() << QString("") << QString("A") << QString("A") << true;

    QTest::newRow( "rep14" ) << QString("") << QString() << QString("A") << QString("A") << true;

    QTest::newRow( "rep15" ) << QString("fooxbarxbazxblub") << QString("x") << QString("yz") << QString("fooyzbaryzbazyzblub") << true;

    QTest::newRow( "rep16" ) << QString("fooxbarxbazxblub") << QString("x") << QString("z") << QString("foozbarzbazzblub") << true;

    QTest::newRow( "rep17" ) << QString("fooxybarxybazxyblub") << QString("xy") << QString("z") << QString("foozbarzbazzblub") << true;

}

void tst_QString::replace_regexp_data()

{

    QTest::addColumn<QString>("string" );

    QTest::addColumn<QString>("regexp" );

    QTest::addColumn<QString>("after" );

    QTest::addColumn<QString>("result" );

    QTest::newRow( "rem00" ) << QString("alpha") << QString("a+") << QString("") << QString("lph");

    QTest::newRow( "rem01" ) << QString("banana") << QString("^.a") << QString("") << QString("nana");

    QTest::newRow( "rem02" ) << QString("") << QString("^.a") << QString("") << QString("");

    QTest::newRow( "rem03" ) << QString("") << QString("^.a") << QString() << QString("");

    QTest::newRow( "rem04" ) << QString() << QString("^.a") << QString("") << QString();

    QTest::newRow( "rem05" ) << QString() << QString("^.a") << QString() << QString();

    QTest::newRow( "rep00" ) << QString("A <i>bon mot</i>.") << QString("<i>([^<]*)</i>") << QString("\\emph{\\1}") << QString("A \\emph{bon mot}.");

    QTest::newRow( "rep01" ) << QString("banana") << QString("^.a()") << QString("\\1") << QString("nana");

    QTest::newRow( "rep02" ) << QString("banana") << QString("(ba)") << QString("\\1X\\1") << QString("baXbanana");

    QTest::newRow( "rep03" ) << QString("banana") << QString("(ba)(na)na") << QString("\\2X\\1") << QString("naXba");

    QTest::newRow("backref00") << QString("\\1\\2\\3\\4\\5\\6\\7\\8\\9\\A\\10\\11") << QString("\\\\[34]")

                               << QString("X") << QString("\\1\\2XX\\5\\6\\7\\8\\9\\A\\10\\11");

    QTest::newRow("backref01") << QString("foo") << QString("[fo]") << QString("\\1") << QString("\\1\\1\\1");

    QTest::newRow("backref02") << QString("foo") << QString("([fo])") << QString("(\\1)") << QString("(f)(o)(o)");

    QTest::newRow("backref03") << QString("foo") << QString("([fo])") << QString("\\2") << QString("\\2\\2\\2");

    QTest::newRow("backref04") << QString("foo") << QString("([fo])") << QString("\\10") << QString("f0o0o0");

    QTest::newRow("backref05") << QString("foo") << QString("([fo])") << QString("\\11") << QString("f1o1o1");

    QTest::newRow("backref06") << QString("foo") << QString("([fo])") << QString("\\19") << QString("f9o9o9");

    QTest::newRow("backref07") << QString("foo") << QString("(f)(o+)")