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

**

** 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();

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