AuroraMiddleware/qt5base-lts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
6bd691dc54
qt5base-lts/tests/auto/qstring/tst_qstring.cpp
Jyri Tahtela f9f395c28b Update licenseheader text in source files for qtbase Qt module 
Updated version of LGPL and FDL licenseheaders.
Apply release phase licenseheaders for all source files.

Reviewed-by: Trust Me
2011-05-24 12:34:08 +03:00

5114 lines
182 KiB
C++
Raw Blame History

/****************************************************************************
**
** 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 <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=
#define CREATE_REF(string) \
const QString padded = QString::fromLatin1(" %1 ").arg(string); \
QStringRef ref = padded.midRef(1, padded.size() - 2);
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 setRawData();
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 swap();
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 count();
void lastIndexOf_data();
void lastIndexOf();
void indexOf_data();
void indexOf();
void indexOf2_data();
void indexOf2();
void indexOf3_data();
// void indexOf3();
void sprintf();
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 stringRef_toLatin1Roundtrip_data();
void stringRef_toLatin1Roundtrip();
void stringRef_utf8_data();
void stringRef_utf8();
void stringRef_local8Bit_data();
void stringRef_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();
void QTBUG10404_compareRef();
void QTBUG9281_arg_locale();
void toUpperLower_icu();
};
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+)")
<< QString("\\2\\1\\10\\20\\11\\22\\19\\29\\3")
<< QString("ooff0oo0f1oo2f9oo9\\3");
QTest::newRow("backref08") << QString("abc") << QString("(((((((((((((([abc]))))))))))))))")
<< QString("{\\14}") << QString("{a}{b}{c}");
QTest::newRow("backref09") << QString("abcdefghijklmn")
<< QString("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)")
<< QString("\\19\\18\\17\\16\\15\\14\\13\\12\\11\\10"
"\\9\\90\\8\\80\\7\\70\\6\\60\\5\\50\\4\\40\\3\\30\\2\\20\\1")
<< QString("a9a8a7a6a5nmlkjii0hh0gg0ff0ee0dd0cc0bb0a");
QTest::newRow("backref10") << QString("abc") << QString("((((((((((((((abc))))))))))))))")
<< QString("\\0\\01\\011") << QString("\\0\\01\\011");
}
void tst_QString::utf8_data()
{
QString str;
QTest::addColumn<QByteArray>("utf8" );
QTest::addColumn<QString>("res" );
QTest::newRow( "str0" ) << QByteArray("abcdefgh")
<< QString("abcdefgh");
QTest::newRow( "str1" ) << QByteArray("\303\266\303\244\303\274\303\226\303\204\303\234\303\270\303\246\303\245\303\230\303\206\303\205")
<< QString("\366\344\374\326\304\334\370\346\345\330\306\305") ;
str += QChar( 0x05e9 );
str += QChar( 0x05d3 );
str += QChar( 0x05d2 );
QTest::newRow( "str2" ) << QByteArray("\327\251\327\223\327\222")
<< str;
str = QChar( 0x20ac );
str += " some text";
QTest::newRow( "str3" ) << QByteArray("\342\202\254 some text")
<< str;
str = "Old Italic: ";
str += QChar(0xd800);
str += QChar(0xdf00);
str += QChar(0xd800);
str += QChar(0xdf01);
str += QChar(0xd800);
str += QChar(0xdf02);
str += QChar(0xd800);
str += QChar(0xdf03);
str += QChar(0xd800);
str += QChar(0xdf04);
QTest::newRow("surrogate") << QByteArray("Old Italic: \360\220\214\200\360\220\214\201\360\220\214\202\360\220\214\203\360\220\214\204") << str;
}
void tst_QString::length()
{
QFETCH( QString, s1 );
QTEST( (int)s1.length(), "res" );
}
#include <qfile.h>
void tst_QString::acc_01()
{
QString a;
QString b; //b(10);
QString bb; //bb((int)0);
QString c("String C");
QChar tmp[10];
tmp[0] = 'S';
tmp[1] = 't';
tmp[2] = 'r';
tmp[3] = 'i';
tmp[4] = 'n';
tmp[5] = 'g';
tmp[6] = ' ';
tmp[7] = 'D';
tmp[8] = 'X';
tmp[9] = '\0';
QString d(tmp,8);
QString ca(a);
QString cb(b);
QString cc(c);
QString n;
QString e("String E");
QString f;
f = e;
f[7]='F';
QCOMPARE(e,(QString)"String E");
char text[]="String f";
f = text;
text[7]='!';
QCOMPARE(f,(QString)"String f");
f[7]='F';
QCOMPARE(text[7],'!');
a="";
a[0]='A';
QCOMPARE(a,(QString)"A");
QCOMPARE(a.length(),1);
a[1]='B';
QCOMPARE(a,(QString)"AB");
QCOMPARE(a.length(),2);
a[2]='C';
QCOMPARE(a,(QString)"ABC");
QCOMPARE(a.length(),3);
a = QString();
QVERIFY(a.isNull());
a[0]='A';
QCOMPARE(a,(QString)"A");
QCOMPARE(a.length(),1);
a[1]='B';
QCOMPARE(a,(QString)"AB");
QCOMPARE(a.length(),2);
a[2]='C';
QCOMPARE(a,(QString)"ABC");
QCOMPARE(a.length(),3);
a="123";
b="456";
a[0]=a[1];
QCOMPARE(a,(QString)"223");
a[1]=b[1];
QCOMPARE(b,(QString)"456");
QCOMPARE(a,(QString)"253");
char t[]="TEXT";
a="A";
a=t;
QCOMPARE(a,(QString)"TEXT");
QCOMPARE(a,(QString)t);
a[0]='X';
QCOMPARE(a,(QString)"XEXT");
QCOMPARE(t[0],'T');
t[0]='Z';
QCOMPARE(a,(QString)"XEXT");
a="ABC";
QCOMPARE(char(a.toLatin1()[1]),'B');
QCOMPARE(strcmp(a.toLatin1(),((QString)"ABC").toLatin1()),0);
QCOMPARE(a+="DEF",(QString)"ABCDEF");
QCOMPARE(a+='G',(QString)"ABCDEFG");
QCOMPARE(a+=((const char*)(0)),(QString)"ABCDEFG");
// non-member operators
a="ABC";
b="ABC";
c="ACB";
d="ABCD";
QVERIFY(a==b);
QVERIFY(!(a==d));
QVERIFY(!(a!=b));
QVERIFY(a!=d);
QVERIFY(!(a<b));
QVERIFY(a<c);
QVERIFY(a<d);
QVERIFY(!(d<a));
QVERIFY(!(c<a));
QVERIFY(a<=b);
QVERIFY(a<=d);
QVERIFY(a<=c);
QVERIFY(!(c<=a));
QVERIFY(!(d<=a));
QCOMPARE(QString(a+b),(QString)"ABCABC");
QCOMPARE(QString(a+"XXXX"),(QString)"ABCXXXX");
QCOMPARE(QString(a+'X'),(QString)"ABCX");
QCOMPARE(QString("XXXX"+a),(QString)"XXXXABC");
QCOMPARE(QString('X'+a),(QString)"XABC");
a = (const char*)0;
QVERIFY(a.isNull());
QVERIFY(*a.toLatin1().constData() == '\0');
{
#if defined(Q_OS_WINCE)
int argc = 0;
QCoreApplication app(argc, 0);
#endif
QFile f("COMPARE.txt");
f.open(QIODevice::ReadOnly);
QTextStream ts( &f );
ts.setCodec(QTextCodec::codecForName("UTF-16"));
ts << "Abc";
}
}
void tst_QString::isNull()
{
QString a;
QVERIFY(a.isNull());
const char *zero = 0;
a.sprintf( zero );
QVERIFY(!a.isNull());
}
void tst_QString::isEmpty()
{
QString a;
QVERIFY(a.isEmpty());
QString c("Not empty");
QVERIFY(!c.isEmpty());
}
void tst_QString::constructor()
{
QString a;
QString b; //b(10);
QString c("String C");
QChar tmp[10];
tmp[0] = 'S';
tmp[1] = 't';
tmp[2] = 'r';
tmp[3] = 'i';
tmp[4] = 'n';
tmp[5] = 'g';
tmp[6] = ' ';
tmp[7] = 'D';
tmp[8] = 'X';
tmp[9] = '\0';
QString d(tmp,8);
QString ca(a);
QString cb(b);
QString cc(c);
QCOMPARE(a,ca);
QVERIFY(a.isNull());
QVERIFY(a == (QString)"");
QCOMPARE(b,cb);
QCOMPARE(c,cc);
QCOMPARE(d,(QString)"String D");
QString nullStr;
QVERIFY( nullStr.isNull() );
QVERIFY( nullStr.isEmpty() );
QString empty("");
QVERIFY( !empty.isNull() );
QVERIFY( empty.isEmpty() );
}
void tst_QString::constructorQByteArray_data()
{
QTest::addColumn<QByteArray>("src" );
QTest::addColumn<QString>("expected" );
QByteArray ba( 4, 0 );
ba[0] = 'C';
ba[1] = 'O';
ba[2] = 'M';
ba[3] = 'P';
QTest::newRow( "1" ) << ba << QString("COMP");
QByteArray ba1( 7, 0 );
ba1[0] = 'a';
ba1[1] = 'b';
ba1[2] = 'c';
ba1[3] = '\0';
ba1[4] = 'd';
ba1[5] = 'e';
ba1[6] = 'f';
QTest::newRow( "2" ) << ba1 << QString("abc");
QTest::newRow( "3" ) << QByteArray::fromRawData("abcd", 3) << QString("abc");
}
void tst_QString::constructorQByteArray()
{
QFETCH(QByteArray, src);
QFETCH(QString, expected);
QString str1(src);
QCOMPARE(str1.length(), expected.length());
QCOMPARE( str1, expected );
QTextCodec::setCodecForCStrings( QTextCodec::codecForMib(4) ); // Latin 1
QString strBA(src);
QTextCodec::setCodecForCStrings( 0 );
QCOMPARE( strBA, expected );
}
void tst_QString::STL()
{
#ifdef Q_CC_HPACC
QSKIP("This test crashes on HP-UX with aCC", SkipSingle);
#endif
#ifndef QT_NO_STL
#ifndef QT_NO_CAST_TO_ASCII
QString qt( "QString" );
std::string stdstr( "QString" );
QString stlqt;
// constructor
stlqt = QString( stdstr );
QCOMPARE( stlqt, qt );
// assignment
stlqt = stdstr;
QCOMPARE( stlqt, qt );
std::string stdstr2 = stlqt;
QCOMPARE( stdstr2, stdstr );
// prepend
stlqt = QString();
stlqt.prepend( stdstr );
QCOMPARE( stlqt, qt );
// append
stlqt = QString();
stlqt.append( stdstr );
QCOMPARE( stlqt, qt );
// pathologics (null-strings not supported by many STLs, so test only empty strings)
stdstr = std::string();
stlqt = stdstr;
QVERIFY( stlqt.isEmpty() );
std::string stdstr3 = stlqt;
QVERIFY( !stdstr3.length() );
#endif
//skip test if glibc is not compiled with wide character support
#if (defined Q_CC_GNU && !defined _GLIBCPP_USE_WCHAR_T) || defined QT_NO_STL_WCHAR
QSKIP( "Not tested without wide character support", SkipAll);
#else
const wchar_t arr[] = {'h', 'e', 'l', 'l', 'o', 0};
QStdWString stlStr = arr;
QString s = QString::fromStdWString(stlStr);
QCOMPARE(s, QString::fromLatin1("hello"));
QCOMPARE(stlStr, s.toStdWString());
#endif
#else
QSKIP( "Not tested without STL support", SkipAll);
#endif
}
void tst_QString::truncate()
{
QString e("String E");
e.truncate(4);
QCOMPARE(e,(QString)"Stri");
e = "String E";
e.truncate(0);
QCOMPARE(e,(QString)"");
QVERIFY(e.isEmpty());
QVERIFY(!e.isNull());
}
void tst_QString::fill()
{
QString e;
e.fill('e',1);
QCOMPARE(e,(QString)"e");
QString f;
f.fill('f',3);
QCOMPARE(f,(QString)"fff");
f.fill('F');
QCOMPARE(f,(QString)"FFF");
}
void tst_QString::sprintf()
{
QString a;
a.sprintf("COMPARE");
QCOMPARE(a,(QString)"COMPARE");
a.sprintf("%%%d",1);
QCOMPARE(a,(QString)"%1");
QCOMPARE(a.sprintf("X%dY",2),(QString)"X2Y");
QCOMPARE(a.sprintf("X%9iY", 50000 ),(QString)"X 50000Y");
QCOMPARE(a.sprintf("X%-9sY","hello"),(QString)"Xhello Y");
QCOMPARE(a.sprintf("X%-9iY", 50000 ),(QString)"X50000 Y");
QCOMPARE(a.sprintf("%lf", 1.23), QString("1.230000"));
QCOMPARE(a.sprintf("%lf", 1.23456789), QString("1.234568"));
QCOMPARE(a.sprintf("%p", (void *)0xbfffd350), QString("0xbfffd350"));
QCOMPARE(a.sprintf("%p", (void *)0), QString("0x0"));
int i = 6;
long l = -2;
float f = 4.023f;
QString S1;
S1.sprintf("%d %ld %f",i,l,f);
QCOMPARE(S1,QString("6 -2 4.023000"));
double d = -514.25683;
S1.sprintf("%f",d);
QCOMPARE(S1, QString("-514.256830"));
QCOMPARE(a.sprintf("%.3s", "Hello" ),(QString)"Hel");
QCOMPARE(a.sprintf("%10.3s", "Hello" ),(QString)" Hel");
QCOMPARE(a.sprintf("%.10s", "Hello" ),(QString)"Hello");
QCOMPARE(a.sprintf("%10.10s", "Hello" ),(QString)" Hello");
QCOMPARE(a.sprintf("%-10.10s", "Hello" ),(QString)"Hello ");
QCOMPARE(a.sprintf("%-10.3s", "Hello" ),(QString)"Hel ");
QCOMPARE(a.sprintf("%-5.5s", "Hello" ),(QString)"Hello");
// Check utf8 conversion for %s
QCOMPARE(a.sprintf("%s", "\303\266\303\244\303\274\303\226\303\204\303\234\303\270\303\246\303\245\303\230\303\206\303\205"), QString("\366\344\374\326\304\334\370\346\345\330\306\305"));
// Check codecForCStrings is used to read non-modifier sequences in the format string
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
QCOMPARE(a.sprintf("\303\251\303\250\303\240 %s", "\303\251\303\250\303\240"), QString("\303\251\303\250\303\240 \303\251\303\250\303\240"));
QTextCodec::setCodecForCStrings(0);
int n1;
a.sprintf("%s%n%s", "hello", &n1, "goodbye");
QCOMPARE(n1, 5);
QCOMPARE(a, QString("hellogoodbye"));
qlonglong n2;
a.sprintf("%s%s%lln%s", "foo", "bar", &n2, "whiz");
QCOMPARE((int)n2, 6);
QCOMPARE(a, QString("foobarwhiz"));
}
/*
indexOf() and indexOf02() test QString::indexOf(),
QString::lastIndexOf(), and their QByteArray equivalents.
lastIndexOf() tests QString::lastIndexOf() more in depth, but it
should probably be rewritten to use a data table.
*/
void tst_QString::indexOf_data()
{
QTest::addColumn<QString>("haystack" );
QTest::addColumn<QString>("needle" );
QTest::addColumn<int>("startpos" );
QTest::addColumn<bool>("bcs" );
QTest::addColumn<int>("resultpos" );
QTest::newRow( "data0" ) << QString("abc") << QString("a") << 0 << true << 0;
QTest::newRow( "data1" ) << QString("abc") << QString("a") << 0 << false << 0;
QTest::newRow( "data2" ) << QString("abc") << QString("A") << 0 << true << -1;
QTest::newRow( "data3" ) << QString("abc") << QString("A") << 0 << false << 0;
QTest::newRow( "data4" ) << QString("abc") << QString("a") << 1 << true << -1;
QTest::newRow( "data5" ) << QString("abc") << QString("a") << 1 << false << -1;
QTest::newRow( "data6" ) << QString("abc") << QString("A") << 1 << true << -1;
QTest::newRow( "data7" ) << QString("abc") << QString("A") << 1 << false << -1;
QTest::newRow( "data8" ) << QString("abc") << QString("b") << 0 << true << 1;
QTest::newRow( "data9" ) << QString("abc") << QString("b") << 0 << false << 1;
QTest::newRow( "data10" ) << QString("abc") << QString("B") << 0 << true << -1;
QTest::newRow( "data11" ) << QString("abc") << QString("B") << 0 << false << 1;
QTest::newRow( "data12" ) << QString("abc") << QString("b") << 1 << true << 1;
QTest::newRow( "data13" ) << QString("abc") << QString("b") << 1 << false << 1;
QTest::newRow( "data14" ) << QString("abc") << QString("B") << 1 << true << -1;
QTest::newRow( "data15" ) << QString("abc") << QString("B") << 1 << false << 1;
QTest::newRow( "data16" ) << QString("abc") << QString("b") << 2 << true << -1;
QTest::newRow( "data17" ) << QString("abc") << QString("b") << 2 << false << -1;
QTest::newRow( "data20" ) << QString("ABC") << QString("A") << 0 << true << 0;
QTest::newRow( "data21" ) << QString("ABC") << QString("A") << 0 << false << 0;
QTest::newRow( "data22" ) << QString("ABC") << QString("a") << 0 << true << -1;
QTest::newRow( "data23" ) << QString("ABC") << QString("a") << 0 << false << 0;
QTest::newRow( "data24" ) << QString("ABC") << QString("A") << 1 << true << -1;
QTest::newRow( "data25" ) << QString("ABC") << QString("A") << 1 << false << -1;
QTest::newRow( "data26" ) << QString("ABC") << QString("a") << 1 << true << -1;
QTest::newRow( "data27" ) << QString("ABC") << QString("a") << 1 << false << -1;
QTest::newRow( "data28" ) << QString("ABC") << QString("B") << 0 << true << 1;
QTest::newRow( "data29" ) << QString("ABC") << QString("B") << 0 << false << 1;
QTest::newRow( "data30" ) << QString("ABC") << QString("b") << 0 << true << -1;
QTest::newRow( "data31" ) << QString("ABC") << QString("b") << 0 << false << 1;
QTest::newRow( "data32" ) << QString("ABC") << QString("B") << 1 << true << 1;
QTest::newRow( "data33" ) << QString("ABC") << QString("B") << 1 << false << 1;
QTest::newRow( "data34" ) << QString("ABC") << QString("b") << 1 << true << -1;
QTest::newRow( "data35" ) << QString("ABC") << QString("b") << 1 << false << 1;
QTest::newRow( "data36" ) << QString("ABC") << QString("B") << 2 << true << -1;
QTest::newRow( "data37" ) << QString("ABC") << QString("B") << 2 << false << -1;
QTest::newRow( "data40" ) << QString("aBc") << QString("bc") << 0 << true << -1;
QTest::newRow( "data41" ) << QString("aBc") << QString("Bc") << 0 << true << 1;
QTest::newRow( "data42" ) << QString("aBc") << QString("bC") << 0 << true << -1;
QTest::newRow( "data43" ) << QString("aBc") << QString("BC") << 0 << true << -1;
QTest::newRow( "data44" ) << QString("aBc") << QString("bc") << 0 << false << 1;
QTest::newRow( "data45" ) << QString("aBc") << QString("Bc") << 0 << false << 1;
QTest::newRow( "data46" ) << QString("aBc") << QString("bC") << 0 << false << 1;
QTest::newRow( "data47" ) << QString("aBc") << QString("BC") << 0 << false << 1;
QTest::newRow( "data48" ) << QString("AbC") << QString("bc") << 0 << true << -1;
QTest::newRow( "data49" ) << QString("AbC") << QString("Bc") << 0 << true << -1;
QTest::newRow( "data50" ) << QString("AbC") << QString("bC") << 0 << true << 1;
QTest::newRow( "data51" ) << QString("AbC") << QString("BC") << 0 << true << -1;
QTest::newRow( "data52" ) << QString("AbC") << QString("bc") << 0 << false << 1;
QTest::newRow( "data53" ) << QString("AbC") << QString("Bc") << 0 << false << 1;
QTest::newRow( "data54" ) << QString("AbC") << QString("bC") << 0 << false << 1;
QTest::newRow( "data55" ) << QString("AbC") << QString("BC") << 0 << false << 1;
QTest::newRow( "data56" ) << QString("AbC") << QString("BC") << 1 << false << 1;
QTest::newRow( "data57" ) << QString("AbC") << QString("BC") << 2 << false << -1;
#if 0
QTest::newRow( "null-in-null") << QString() << QString() << 0 << false << 0;
QTest::newRow( "empty-in-null") << QString() << QString("") << 0 << false << 0;
QTest::newRow( "null-in-empty") << QString("") << QString() << 0 << false << 0;
QTest::newRow( "empty-in-empty") << QString("") << QString("") << 0 << false << 0;
#endif
QString s1 = "abc";
s1 += QChar(0xb5);
QString s2;
s2 += QChar(0x3bc);
QTest::newRow( "data58" ) << s1 << s2 << 0 << false << 3;
s2.prepend("C");
QTest::newRow( "data59" ) << s1 << s2 << 0 << false << 2;
QString veryBigHaystack(500, 'a');
veryBigHaystack += 'B';
QTest::newRow("BoyerMooreStressTest") << veryBigHaystack << veryBigHaystack << 0 << true << 0;
QTest::newRow("BoyerMooreStressTest2") << QString(veryBigHaystack + 'c') << veryBigHaystack << 0 << true << 0;
QTest::newRow("BoyerMooreStressTest3") << QString('c' + veryBigHaystack) << veryBigHaystack << 0 << true << 1;
QTest::newRow("BoyerMooreStressTest4") << veryBigHaystack << QString(veryBigHaystack + 'c') << 0 << true << -1;
QTest::newRow("BoyerMooreStressTest5") << veryBigHaystack << QString('c' + veryBigHaystack) << 0 << true << -1;
QTest::newRow("BoyerMooreStressTest6") << QString('d' + veryBigHaystack) << QString('c' + veryBigHaystack) << 0 << true << -1;
QTest::newRow("BoyerMooreStressTest6") << QString(veryBigHaystack + 'c') << QString('c' + veryBigHaystack) << 0 << true << -1;
QTest::newRow("BoyerMooreInsensitiveStressTest") << veryBigHaystack << veryBigHaystack << 0 << false << 0;
}
void tst_QString::indexOf()
{
QFETCH( QString, haystack );
QFETCH( QString, needle );
QFETCH( int, startpos );
QFETCH( bool, bcs );
QFETCH( int, resultpos );
CREATE_REF(needle);
Qt::CaseSensitivity cs = bcs ? Qt::CaseSensitive : Qt::CaseInsensitive;
bool needleIsLatin = (QString::fromLatin1(needle.toLatin1()) == needle);
QCOMPARE( haystack.indexOf(needle, startpos, cs), resultpos );
QCOMPARE( haystack.indexOf(ref, startpos, cs), resultpos );
if (needleIsLatin) {
QCOMPARE( haystack.indexOf(needle.toLatin1(), startpos, cs), resultpos );
QCOMPARE( haystack.indexOf(needle.toLatin1().data(), startpos, cs), resultpos );
}
{
QRegExp rx1 = QRegExp(QRegExp::escape(needle), cs);
QRegExp rx2 = QRegExp(needle, cs, QRegExp::FixedString);
QCOMPARE( haystack.indexOf(rx1, startpos), resultpos );
QCOMPARE( haystack.indexOf(rx2, startpos), resultpos );
// these QRegExp must have been modified
QVERIFY( resultpos == -1 || rx1.matchedLength() > 0);
QVERIFY( resultpos == -1 || rx2.matchedLength() > 0);
}
{
const QRegExp rx1 = QRegExp(QRegExp::escape(needle), cs);
const QRegExp rx2 = QRegExp(needle, cs, QRegExp::FixedString);
QCOMPARE( haystack.indexOf(rx1, startpos), resultpos );
QCOMPARE( haystack.indexOf(rx2, startpos), resultpos );
// our QRegExp mustn't have been modified
QCOMPARE( rx1.matchedLength(), -1 );
QCOMPARE( rx2.matchedLength(), -1 );
}
if (cs == Qt::CaseSensitive) {
QCOMPARE( haystack.indexOf(needle, startpos), resultpos );
QCOMPARE( haystack.indexOf(ref, startpos), resultpos );
if (needleIsLatin) {
QCOMPARE( haystack.indexOf(needle.toLatin1(), startpos), resultpos );
QCOMPARE( haystack.indexOf(needle.toLatin1().data(), startpos), resultpos );
}
if (startpos == 0) {
QCOMPARE( haystack.indexOf(needle), resultpos );
QCOMPARE( haystack.indexOf(ref), resultpos );
if (needleIsLatin) {
QCOMPARE( haystack.indexOf(needle.toLatin1()), resultpos );
QCOMPARE( haystack.indexOf(needle.toLatin1().data()), resultpos );
}
}
}
if (needle.size() == 1) {
QCOMPARE(haystack.indexOf(needle.at(0), startpos, cs), resultpos);
QCOMPARE(haystack.indexOf(ref.at(0), startpos, cs), resultpos);
}
}
void tst_QString::indexOf2_data()
{
QTest::addColumn<QString>("haystack" );
QTest::addColumn<QString>("needle" );
QTest::addColumn<int>("resultpos" );
QTest::newRow( "data0" ) << QString() << QString() << 0;
QTest::newRow( "data1" ) << QString() << QString("") << 0;
QTest::newRow( "data2" ) << QString("") << QString() << 0;
QTest::newRow( "data3" ) << QString("") << QString("") << 0;
QTest::newRow( "data4" ) << QString() << QString("a") << -1;
QTest::newRow( "data5" ) << QString() << QString("abcdefg") << -1;
QTest::newRow( "data6" ) << QString("") << QString("a") << -1;
QTest::newRow( "data7" ) << QString("") << QString("abcdefg") << -1;
QTest::newRow( "data8" ) << QString("a") << QString() << 0;
QTest::newRow( "data9" ) << QString("a") << QString("") << 0;
QTest::newRow( "data10" ) << QString("a") << QString("a") << 0;
QTest::newRow( "data11" ) << QString("a") << QString("b") << -1;
QTest::newRow( "data12" ) << QString("a") << QString("abcdefg") << -1;
QTest::newRow( "data13" ) << QString("ab") << QString() << 0;
QTest::newRow( "data14" ) << QString("ab") << QString("") << 0;
QTest::newRow( "data15" ) << QString("ab") << QString("a") << 0;
QTest::newRow( "data16" ) << QString("ab") << QString("b") << 1;
QTest::newRow( "data17" ) << QString("ab") << QString("ab") << 0;
QTest::newRow( "data18" ) << QString("ab") << QString("bc") << -1;
QTest::newRow( "data19" ) << QString("ab") << QString("abcdefg") << -1;
QTest::newRow( "data30" ) << QString("abc") << QString("a") << 0;
QTest::newRow( "data31" ) << QString("abc") << QString("b") << 1;
QTest::newRow( "data32" ) << QString("abc") << QString("c") << 2;
QTest::newRow( "data33" ) << QString("abc") << QString("d") << -1;
QTest::newRow( "data34" ) << QString("abc") << QString("ab") << 0;
QTest::newRow( "data35" ) << QString("abc") << QString("bc") << 1;
QTest::newRow( "data36" ) << QString("abc") << QString("cd") << -1;
QTest::newRow( "data37" ) << QString("abc") << QString("ac") << -1;
// sizeof(whale) > 32
QString whale = "a5zby6cx7dw8evf9ug0th1si2rj3qkp4lomn";
QString minnow = "zby";
QTest::newRow( "data40" ) << whale << minnow << 2;
QTest::newRow( "data41" ) << QString(whale + whale) << minnow << 2;
QTest::newRow( "data42" ) << QString(minnow + whale) << minnow << 0;
QTest::newRow( "data43" ) << whale << whale << 0;
QTest::newRow( "data44" ) << QString(whale + whale) << whale << 0;
QTest::newRow( "data45" ) << whale << QString(whale + whale) << -1;
QTest::newRow( "data46" ) << QString(whale + whale) << QString(whale + whale) << 0;
QTest::newRow( "data47" ) << QString(whale + whale) << QString(whale + minnow) << -1;
QTest::newRow( "data48" ) << QString(minnow + whale) << whale << (int)minnow.length();
}
void tst_QString::indexOf2()
{
QFETCH( QString, haystack );
QFETCH( QString, needle );
QFETCH( int, resultpos );
CREATE_REF(needle);
QByteArray chaystack = haystack.toLatin1();
QByteArray cneedle = needle.toLatin1();
int got;
QCOMPARE( haystack.indexOf(needle, 0, Qt::CaseSensitive), resultpos );
QCOMPARE( haystack.indexOf(ref, 0, Qt::CaseSensitive), resultpos );
QCOMPARE( QStringMatcher(needle, Qt::CaseSensitive).indexIn(haystack, 0), resultpos );
QCOMPARE( haystack.indexOf(needle, 0, Qt::CaseInsensitive), resultpos );
QCOMPARE( haystack.indexOf(ref, 0, Qt::CaseInsensitive), resultpos );
QCOMPARE( QStringMatcher(needle, Qt::CaseInsensitive).indexIn(haystack, 0), resultpos );
if ( needle.length() > 0 ) {
got = haystack.lastIndexOf( needle, -1, Qt::CaseSensitive );
QVERIFY( got == resultpos || (resultpos >= 0 && got >= resultpos) );
got = haystack.lastIndexOf( needle, -1, Qt::CaseInsensitive );
QVERIFY( got == resultpos || (resultpos >= 0 && got >= resultpos) );
}
QCOMPARE( chaystack.indexOf(cneedle, 0), resultpos );
QCOMPARE( QByteArrayMatcher(cneedle).indexIn(chaystack, 0), resultpos );
if ( cneedle.length() > 0 ) {
got = chaystack.lastIndexOf(cneedle, -1);
QVERIFY( got == resultpos || (resultpos >= 0 && got >= resultpos) );
}
}
void tst_QString::lastIndexOf_data()
{
QTest::addColumn<QString>("haystack" );
QTest::addColumn<QString>("needle" );
QTest::addColumn<int>("from" );
QTest::addColumn<int>("expected" );
QTest::addColumn<bool>("caseSensitive" );
QString a = "ABCDEFGHIEfGEFG";
QTest::newRow("-1") << a << "G" << a.size() - 1 << 14 << true;
QTest::newRow("1") << a << "G" << - 1 << 14 << true;
QTest::newRow("2") << a << "G" << -3 << 11 << true;
QTest::newRow("3") << a << "G" << -5 << 6 << true;
QTest::newRow("4") << a << "G" << 14 << 14 << true;
QTest::newRow("5") << a << "G" << 13 << 11 << true;
QTest::newRow("6") << a << "B" << a.size() - 1 << 1 << true;
QTest::newRow("6") << a << "B" << - 1 << 1 << true;
QTest::newRow("7") << a << "B" << 1 << 1 << true;
QTest::newRow("8") << a << "B" << 0 << -1 << true;
QTest::newRow("9") << a << "G" << -1 << a.size()-1 << true;
QTest::newRow("10") << a << "G" << a.size()-1 << a.size()-1 << true;
QTest::newRow("11") << a << "G" << a.size() << -1 << true;
QTest::newRow("12") << a << "A" << 0 << 0 << true;
QTest::newRow("13") << a << "A" << -1*a.size() << 0 << true;
QTest::newRow("15") << a << "efg" << 0 << -1 << false;
QTest::newRow("16") << a << "efg" << a.size() << -1 << false;
QTest::newRow("17") << a << "efg" << -1 * a.size() << -1 << false;
QTest::newRow("19") << a << "efg" << a.size() - 1 << 12 << false;
QTest::newRow("20") << a << "efg" << 12 << 12 << false;
QTest::newRow("21") << a << "efg" << -12 << -1 << false;
QTest::newRow("22") << a << "efg" << 11 << 9 << false;
QTest::newRow("24") << "" << "asdf" << -1 << -1 << false;
QTest::newRow("25") << "asd" << "asdf" << -1 << -1 << false;
QTest::newRow("26") << "" << QString() << -1 << -1 << false;
QTest::newRow("27") << a << "" << a.size() << a.size() << false;
QTest::newRow("28") << a << "" << a.size() + 10 << -1 << false;
}
void tst_QString::lastIndexOf()
{
QFETCH(QString, haystack);
QFETCH(QString, needle);
QFETCH(int, from);
QFETCH(int, expected);
QFETCH(bool, caseSensitive);
CREATE_REF(needle);
Qt::CaseSensitivity cs = (caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive);
QCOMPARE(haystack.lastIndexOf(needle, from, cs), expected);
QCOMPARE(haystack.lastIndexOf(ref, from, cs), expected);
QCOMPARE(haystack.lastIndexOf(needle.toLatin1(), from, cs), expected);
QCOMPARE(haystack.lastIndexOf(needle.toLatin1().data(), from, cs), expected);
if (from >= -1 && from < haystack.size()) {
// unfortunately, QString and QRegExp don't have the same out of bound semantics
// I think QString is wrong -- See file log for contact information.
{
QRegExp rx1 = QRegExp(QRegExp::escape(needle), cs);
QRegExp rx2 = QRegExp(needle, cs, QRegExp::FixedString);
QCOMPARE(haystack.lastIndexOf(rx1, from), expected);
QCOMPARE(haystack.lastIndexOf(rx2, from), expected);
// our QRegExp mustn't have been modified
QVERIFY(expected == -1 || rx1.matchedLength() > 0);
QVERIFY(expected == -1 || rx2.matchedLength() > 0);
}
{
const QRegExp rx1 = QRegExp(QRegExp::escape(needle), cs);
const QRegExp rx2 = QRegExp(needle, cs, QRegExp::FixedString);
QCOMPARE(haystack.lastIndexOf(rx1, from), expected);
QCOMPARE(haystack.lastIndexOf(rx2, from), expected);
// our QRegExp mustn't have been modified
QCOMPARE(rx1.matchedLength(), -1);
QCOMPARE(rx2.matchedLength(), -1);
}
}
if (cs == Qt::CaseSensitive) {
QCOMPARE(haystack.lastIndexOf(needle, from), expected);
QCOMPARE(haystack.lastIndexOf(ref, from), expected);
QCOMPARE(haystack.lastIndexOf(needle.toLatin1(), from), expected);
QCOMPARE(haystack.lastIndexOf(needle.toLatin1().data(), from), expected);
if (from == -1) {
QCOMPARE(haystack.lastIndexOf(needle), expected);
QCOMPARE(haystack.lastIndexOf(ref), expected);
QCOMPARE(haystack.lastIndexOf(needle.toLatin1()), expected);
QCOMPARE(haystack.lastIndexOf(needle.toLatin1().data()), expected);
}
}
if (needle.size() == 1) {
QCOMPARE(haystack.lastIndexOf(needle.at(0), from), expected);
QCOMPARE(haystack.lastIndexOf(ref.at(0), from), expected);
}
}
void tst_QString::count()
{
QString a;
a="ABCDEFGHIEfGEFG"; // 15 chars
QCOMPARE(a.count('A'),1);
QCOMPARE(a.count('Z'),0);
QCOMPARE(a.count('E'),3);
QCOMPARE(a.count('F'),2);
QCOMPARE(a.count('F',Qt::CaseInsensitive),3);
QCOMPARE(a.count("FG"),2);
QCOMPARE(a.count("FG",Qt::CaseInsensitive),3);
QCOMPARE(a.count( QString(), Qt::CaseInsensitive), 16);
QCOMPARE(a.count( "", Qt::CaseInsensitive), 16);
QCOMPARE(a.count(QRegExp("[FG][HI]")),1);
QCOMPARE(a.count(QRegExp("[G][HE]")),2);
CREATE_REF(QLatin1String("FG"));
QCOMPARE(a.count(ref),2);
QCOMPARE(a.count(ref,Qt::CaseInsensitive),3);
QCOMPARE(a.count( QStringRef(), Qt::CaseInsensitive), 16);
QStringRef emptyRef(&a, 0, 0);
QCOMPARE(a.count( emptyRef, Qt::CaseInsensitive), 16);
}
void tst_QString::contains()
{
QString a;
a="ABCDEFGHIEfGEFG"; // 15 chars
QVERIFY(a.contains('A'));
QVERIFY(!a.contains('Z'));
QVERIFY(a.contains('E'));
QVERIFY(a.contains('F'));
QVERIFY(a.contains('F',Qt::CaseInsensitive));
QVERIFY(a.contains("FG"));
QVERIFY(a.contains("FG",Qt::CaseInsensitive));
QVERIFY(a.contains( QString(), Qt::CaseInsensitive));
QVERIFY(a.contains( "", Qt::CaseInsensitive));
QVERIFY(a.contains(QRegExp("[FG][HI]")));
QVERIFY(a.contains(QRegExp("[G][HE]")));
CREATE_REF(QLatin1String("FG"));
QVERIFY(a.contains(ref));
QVERIFY(a.contains(ref, Qt::CaseInsensitive));
QVERIFY(a.contains( QStringRef(), Qt::CaseInsensitive));
QStringRef emptyRef(&a, 0, 0);
QVERIFY(a.contains(emptyRef, Qt::CaseInsensitive));
}
void tst_QString::left()
{
QString a;
a="ABCDEFGHIEfGEFG"; // 15 chars
QCOMPARE(a.left(3),(QString)"ABC");
QVERIFY(!a.left(0).isNull());
QCOMPARE(a.left(0),(QString)"");
QString n;
QVERIFY(n.left(3).isNull());
QVERIFY(n.left(0).isNull());
QVERIFY(n.left(0).isNull());
QString l = "Left";
QCOMPARE(l.left(-1), l);
QCOMPARE(l.left(100), l);
}
void tst_QString::leftRef()
{
QString a;
a="ABCDEFGHIEfGEFG"; // 15 chars
QCOMPARE(a.leftRef(3).toString(),(QString)"ABC");
QVERIFY(a.leftRef(0).toString().isEmpty());
QCOMPARE(a.leftRef(0).toString(),(QString)"");
QString n;
QVERIFY(n.leftRef(3).toString().isEmpty());
QVERIFY(n.leftRef(0).toString().isEmpty());
QVERIFY(n.leftRef(0).toString().isEmpty());
QString l = "Left";
QCOMPARE(l.leftRef(-1).toString(), l);
QCOMPARE(l.leftRef(100).toString(), l);
}
void tst_QString::right()
{
QString a;
a="ABCDEFGHIEfGEFG"; // 15 chars
QCOMPARE(a.right(3),(QString)"EFG");
QCOMPARE(a.right(0),(QString)"");
QString n;
QVERIFY(n.right(3).isNull());
QVERIFY(n.right(0).isNull());
QString r = "Right";
QCOMPARE(r.right(-1), r);
QCOMPARE(r.right(100), r);
}
void tst_QString::rightRef()
{
QString a;
a="ABCDEFGHIEfGEFG"; // 15 chars
QCOMPARE(a.rightRef(3).toString(),(QString)"EFG");
QCOMPARE(a.rightRef(0).toString(),(QString)"");
QString n;
QVERIFY(n.rightRef(3).toString().isEmpty());
QVERIFY(n.rightRef(0).toString().isEmpty());
QString r = "Right";
QCOMPARE(r.rightRef(-1).toString(), r);
QCOMPARE(r.rightRef(100).toString(), r);
}
void tst_QString::mid()
{
QString a;
a="ABCDEFGHIEfGEFG"; // 15 chars
QCOMPARE(a.mid(3,3),(QString)"DEF");
QCOMPARE(a.mid(0,0),(QString)"");
QVERIFY(a.mid(9999).isNull());
QVERIFY(a.mid(9999,1).isNull());
QString n;
QVERIFY(n.mid(3,3).isNull());
QVERIFY(n.mid(0,0).isNull());
QVERIFY(n.mid(9999,0).isNull());
QVERIFY(n.mid(9999,1).isNull());
QString x = "Nine pineapples";
QCOMPARE(x.mid(5, 4), QString("pine"));
QCOMPARE(x.mid(5), QString("pineapples"));
}
void tst_QString::midRef()
{
QString a;
a="ABCDEFGHIEfGEFG"; // 15 chars
QCOMPARE(a.midRef(3,3).toString(),(QString)"DEF");
QCOMPARE(a.midRef(0,0).toString(),(QString)"");
QVERIFY(a.midRef(9999).toString().isEmpty());
QVERIFY(a.midRef(9999,1).toString().isEmpty());
QString n;
QVERIFY(n.midRef(3,3).toString().isEmpty());
QVERIFY(n.midRef(0,0).toString().isEmpty());
QVERIFY(n.midRef(9999,0).toString().isEmpty());
QVERIFY(n.midRef(9999,1).toString().isEmpty());
QString x = "Nine pineapples";
QCOMPARE(x.midRef(5, 4).toString(), QString("pine"));
QCOMPARE(x.midRef(5).toString(), QString("pineapples"));
}
void tst_QString::stringRef()
{
QString a;
a="ABCDEFGHIEfGEFG"; // 15 chars
QVERIFY(QStringRef(&a, 0, 0) == (QString)"");
QVERIFY(QStringRef(&a, 3, 3) == (QString)"DEF");
QVERIFY(QStringRef(&a, 3, 3) == QLatin1String("DEF"));
QVERIFY(QStringRef(&a, 3, 3) == "DEF");
QVERIFY((QString)"DEF" == QStringRef(&a, 3, 3));
QVERIFY(QLatin1String("DEF") == QStringRef(&a, 3, 3));
QVERIFY("DEF" == QStringRef(&a, 3, 3));
QVERIFY(QStringRef(&a, 3, 3) != (QString)"DE");
QVERIFY(QStringRef(&a, 3, 3) != QLatin1String("DE"));
QVERIFY(QStringRef(&a, 3, 3) != "DE");
QVERIFY((QString)"DE" != QStringRef(&a, 3, 3));
QVERIFY(QLatin1String("DE") != QStringRef(&a, 3, 3));
QVERIFY("DE" != QStringRef(&a, 3, 3));
QString s_alpha("alpha");
QString s_beta("beta");
QStringRef alpha(&s_alpha);
QStringRef beta(&s_beta);
QVERIFY(alpha < beta);
QVERIFY(alpha <= beta);
QVERIFY(alpha <= alpha);
QVERIFY(beta > alpha);
QVERIFY(beta >= alpha);
QVERIFY(beta >= beta);
QString s_alpha2("alpha");
QMap<QStringRef, QString> map;
map.insert(alpha, "alpha");
map.insert(beta, "beta");
QVERIFY(alpha == map.value(QStringRef(&s_alpha2)));
QHash<QStringRef, QString> hash;
hash.insert(alpha, "alpha");
hash.insert(beta, "beta");
QVERIFY(alpha == hash.value(QStringRef(&s_alpha2)));
}
void tst_QString::leftJustified()
{
QString a;
a="ABC";
QCOMPARE(a.leftJustified(5,'-'),(QString)"ABC--");
QCOMPARE(a.leftJustified(4,'-'),(QString)"ABC-");
QCOMPARE(a.leftJustified(4),(QString)"ABC ");
QCOMPARE(a.leftJustified(3),(QString)"ABC");
QCOMPARE(a.leftJustified(2),(QString)"ABC");
QCOMPARE(a.leftJustified(1),(QString)"ABC");
QCOMPARE(a.leftJustified(0),(QString)"ABC");
QString n;
QVERIFY(!n.leftJustified(3).isNull());
QCOMPARE(a.leftJustified(4,' ',true),(QString)"ABC ");
QCOMPARE(a.leftJustified(3,' ',true),(QString)"ABC");
QCOMPARE(a.leftJustified(2,' ',true),(QString)"AB");
QCOMPARE(a.leftJustified(1,' ',true),(QString)"A");
QCOMPARE(a.leftJustified(0,' ',true),(QString)"");
}
void tst_QString::rightJustified()
{
QString a;
a="ABC";
QCOMPARE(a.rightJustified(5,'-'),(QString)"--ABC");
QCOMPARE(a.rightJustified(4,'-'),(QString)"-ABC");
QCOMPARE(a.rightJustified(4),(QString)" ABC");
QCOMPARE(a.rightJustified(3),(QString)"ABC");
QCOMPARE(a.rightJustified(2),(QString)"ABC");
QCOMPARE(a.rightJustified(1),(QString)"ABC");
QCOMPARE(a.rightJustified(0),(QString)"ABC");
QString n;
QVERIFY(!n.rightJustified(3).isNull());
QCOMPARE(a.rightJustified(4,'-',true),(QString)"-ABC");
QCOMPARE(a.rightJustified(4,' ',true),(QString)" ABC");
QCOMPARE(a.rightJustified(3,' ',true),(QString)"ABC");
QCOMPARE(a.rightJustified(2,' ',true),(QString)"AB");
QCOMPARE(a.rightJustified(1,' ',true),(QString)"A");
QCOMPARE(a.rightJustified(0,' ',true),(QString)"");
QCOMPARE(a,(QString)"ABC");
}
void tst_QString::toUpper()
{
QCOMPARE( QString().toUpper(), QString() );
QCOMPARE( QString("").toUpper(), QString("") );
QCOMPARE( QString("text").toUpper(), QString("TEXT") );
QCOMPARE( QString("Text").toUpper(), QString("TEXT") );
QCOMPARE( QString("tExt").toUpper(), QString("TEXT") );
QCOMPARE( QString("teXt").toUpper(), QString("TEXT") );
QCOMPARE( QString("texT").toUpper(), QString("TEXT") );
QCOMPARE( QString("TExt").toUpper(), QString("TEXT") );
QCOMPARE( QString("teXT").toUpper(), QString("TEXT") );
QCOMPARE( QString("tEXt").toUpper(), QString("TEXT") );
QCOMPARE( QString("tExT").toUpper(), QString("TEXT") );
QCOMPARE( QString("TEXT").toUpper(), QString("TEXT") );
QCOMPARE( QString("@ABYZ[").toUpper(), QString("@ABYZ["));
QCOMPARE( QString("@abyz[").toUpper(), QString("@ABYZ["));
QCOMPARE( QString("`ABYZ{").toUpper(), QString("`ABYZ{"));
QCOMPARE( QString("`abyz{").toUpper(), QString("`ABYZ{"));
QCOMPARE( QString(1, QChar(0xdf)).toUpper(), QString("SS"));
QString lower;
lower += QChar(QChar::highSurrogate(0x10428));
lower += QChar(QChar::lowSurrogate(0x10428));
QString upper;
upper += QChar(QChar::highSurrogate(0x10400));
upper += QChar(QChar::lowSurrogate(0x10400));
QCOMPARE( lower.toUpper(), upper);
#ifdef QT_USE_ICU
// test doesn't work with ICU support, since QChar is unaware of any locale
QEXPECT_FAIL("", "test doesn't work with ICU support, since QChar is unaware of any locale", Continue);
QVERIFY(false);
#else
for (int i = 0; i < 65536; ++i) {
QString str(1, QChar(i));
QString upper = str.toUpper();
QVERIFY(upper.length() >= 1);
if (upper.length() == 1)
QVERIFY(upper == QString(1, QChar(i).toUpper()));
}
#endif
}
void tst_QString::toLower()
{
QCOMPARE( QString().toLower(), QString() );
QCOMPARE( QString("").toLower(), QString("") );
QCOMPARE( QString("text").toLower(), QString("text") );
QCOMPARE( QString("Text").toLower(), QString("text") );
QCOMPARE( QString("tExt").toLower(), QString("text") );
QCOMPARE( QString("teXt").toLower(), QString("text") );
QCOMPARE( QString("texT").toLower(), QString("text") );
QCOMPARE( QString("TExt").toLower(), QString("text") );
QCOMPARE( QString("teXT").toLower(), QString("text") );
QCOMPARE( QString("tEXt").toLower(), QString("text") );
QCOMPARE( QString("tExT").toLower(), QString("text") );
QCOMPARE( QString("TEXT").toLower(), QString("text") );
QCOMPARE( QString("@ABYZ[").toLower(), QString("@abyz["));
QCOMPARE( QString("@abyz[").toLower(), QString("@abyz["));
QCOMPARE( QString("`ABYZ{").toLower(), QString("`abyz{"));
QCOMPARE( QString("`abyz{").toLower(), QString("`abyz{"));
QCOMPARE( QString(1, QChar(0x130)).toLower(), QString(QString(1, QChar(0x69)) + QChar(0x307)));
QString lower;
lower += QChar(QChar::highSurrogate(0x10428));
lower += QChar(QChar::lowSurrogate(0x10428));
QString upper;
upper += QChar(QChar::highSurrogate(0x10400));
upper += QChar(QChar::lowSurrogate(0x10400));
QCOMPARE( upper.toLower(), lower);
#ifdef QT_USE_ICU
// test doesn't work with ICU support, since QChar is unaware of any locale
QEXPECT_FAIL("", "test doesn't work with ICU support, since QChar is unaware of any locale", Continue);
QVERIFY(false);
#else
for (int i = 0; i < 65536; ++i) {
QString str(1, QChar(i));
QString lower = str.toLower();
QVERIFY(lower.length() >= 1);
if (lower.length() == 1)
QVERIFY(str.toLower() == QString(1, QChar(i).toLower()));
}
#endif
}
void tst_QString::trimmed()
{
QString a;
a="Text";
QCOMPARE(a,(QString)"Text");
QCOMPARE(a.trimmed(),(QString)"Text");
QCOMPARE(a,(QString)"Text");
a=" ";
QCOMPARE(a.trimmed(),(QString)"");
QCOMPARE(a,(QString)" ");
a=" a ";
QCOMPARE(a.trimmed(),(QString)"a");
}
void tst_QString::simplified_data()
{
QTest::addColumn<QString>("full" );
QTest::addColumn<QString>("simple" );
QTest::newRow("null") << QString() << QString();
QTest::newRow("empty") << "" << "";
QTest::newRow("one char") << "a" << "a";
QTest::newRow("one word") << "foo" << "foo";
QTest::newRow("chars trivial") << "a b" << "a b";
QTest::newRow("words trivial") << "foo bar" << "foo bar";
QTest::newRow("allspace") << " \t\v " << "";
QTest::newRow("char trailing") << "a " << "a";
QTest::newRow("char trailing tab") << "a\t" << "a";
QTest::newRow("char multitrailing") << "a " << "a";
QTest::newRow("char multitrailing tab") << "a \t" << "a";
QTest::newRow("char leading") << " a" << "a";
QTest::newRow("char leading tab") << "\ta" << "a";
QTest::newRow("char multileading") << " a" << "a";
QTest::newRow("char multileading tab") << "\t a" << "a";
QTest::newRow("chars apart") << "a b" << "a b";
QTest::newRow("words apart") << "foo bar" << "foo bar";
QTest::newRow("enclosed word") << " foo \t " << "foo";
QTest::newRow("enclosed chars apart") << " a b " << "a b";
QTest::newRow("enclosed words apart") << " foo bar " << "foo bar";
QTest::newRow("chars apart posttab") << "a \tb" << "a b";
QTest::newRow("chars apart pretab") << "a\t b" << "a b";
QTest::newRow("many words") << " just some random\ttext here" << "just some random text here";
}
void tst_QString::simplified()
{
QFETCH(QString, full);
QFETCH(QString, simple);
QString result = full.simplified();
if (simple.isNull()) {
QVERIFY2(result.isNull(), qPrintable("'" + full + "' did not yield null: " + result));
} else if (simple.isEmpty()) {
QVERIFY2(result.isEmpty() && !result.isNull(), qPrintable("'" + full + "' did not yield empty: " + result));
} else {
QCOMPARE(result, simple);
if (full == simple)
QVERIFY(result.isSharedWith(full));
}
}
void tst_QString::insert()
{
QString a;
a = "Ys";
QCOMPARE(a.insert(1,'e'), QString("Yes"));
QCOMPARE(a.insert(3,'!'), QString("Yes!"));
QCOMPARE(a.insert(5,'?'), QString("Yes! ?"));
a = "ABC";
QCOMPARE(a.insert(5,"DEF"), QString("ABC DEF"));
a = "ABC";
QCOMPARE(a.insert(2, QString()), QString("ABC"));
QCOMPARE(a.insert(0,"ABC"), QString("ABCABC"));
QCOMPARE(a, QString("ABCABC"));
QCOMPARE(a.insert(0,a), QString("ABCABCABCABC"));
QCOMPARE(a, QString("ABCABCABCABC"));
QCOMPARE(a.insert(0,'<'), QString("<ABCABCABCABC"));
QCOMPARE(a.insert(1,'>'), QString("<>ABCABCABCABC"));
a = "Meal";
QCOMPARE(a.insert(1, QLatin1String("ontr")), QString("Montreal"));
QCOMPARE(a.insert(4, ""), QString("Montreal"));
QCOMPARE(a.insert(3, QLatin1String("")), QString("Montreal"));
QCOMPARE(a.insert(3, QLatin1String(0)), QString("Montreal"));
QCOMPARE(a.insert(3, static_cast<const char *>(0)), QString("Montreal"));
QCOMPARE(a.insert(0, QLatin1String("a")), QString("aMontreal"));
}
void tst_QString::append()
{
QString a;
a = "<>ABCABCABCABC";
QCOMPARE(a.append(">"),(QString)"<>ABCABCABCABC>");
#if 0
#if !defined(QT_NO_STL)
/*
The std::string support is fairly trivial in itself. The major
problem is whether it compiles or not, because of the way
different compilers choose an overload based on the type of the
argument. If it compiles, we're happy.
*/
std::string stroustrup;
a.append( stroustrup );
a += stroustrup;
#endif
#endif
}
void tst_QString::append_bytearray_data()
{
QTest::addColumn<QString>("str" );
QTest::addColumn<QByteArray>("ba" );
QTest::addColumn<QString>("res" );
QByteArray ba( 5, 0 );
ba[0] = 'a';
ba[1] = 'b';
ba[2] = 'c';
ba[3] = 'd';
#if 0
ba[4] = 0;
for ( int i=0; i<2; i++ ) {
// i == 0: the byte array is exactly strlen+1
// i == 1: the byte array is larger than strlen+1
QTest::newRow( QString("nullTerminated_%1_0").arg(i) ) << QString() << ba << QString("abcd");
QTest::newRow( QString("nullTerminated_%1_1").arg(i) ) << QString("") << ba << QString("abcd");
QTest::newRow( QString("nullTerminated_%1_2").arg(i) ) << QString("foobar ") << ba << QString("foobar abcd");
ba.resize( 8 );
}
#endif
// no 0 termination
ba.resize( 4 );
QTest::newRow( "notTerminated_0" ) << QString() << ba << QString("abcd");
QTest::newRow( "notTerminated_1" ) << QString("") << ba << QString("abcd");
QTest::newRow( "notTerminated_2" ) << QString("foobar ") << ba << QString("foobar abcd");
// byte array with only a 0
ba.resize( 1 );
ba[0] = 0;
QByteArray ba2("foobar ");
ba2.append('\0');
QTest::newRow( "emptyString" ) << QString("foobar ") << ba << QString(ba2);
// empty byte array
ba.resize( 0 );
QTest::newRow( "emptyByteArray" ) << QString("foobar ") << ba << QString("foobar ");
}
void tst_QString::append_bytearray()
{
{
QFETCH( QString, str );
QFETCH( QByteArray, ba );
str.append( ba );
QTEST( str, "res" );
}
{
QFETCH( QString, str );
QFETCH( QByteArray, ba );
QTextCodec::setCodecForCStrings( QTextCodec::codecForMib(4) ); // Latin 1
str.append( ba );
QTextCodec::setCodecForCStrings( 0 );
QTEST( str, "res" );
}
}
void tst_QString::operator_pluseq_bytearray_data()
{
append_bytearray_data();
}
void tst_QString::operator_pluseq_bytearray()
{
{
QFETCH( QString, str );
QFETCH( QByteArray, ba );
str += ba;
QTEST( str, "res" );
}
{
QFETCH( QString, str );
QFETCH( QByteArray, ba );
QTextCodec::setCodecForCStrings( QTextCodec::codecForMib(4) ); // Latin 1
str += ba;
QTextCodec::setCodecForCStrings( 0 );
QTEST( str, "res" );
}
}
void tst_QString::swap()
{
QString s1, s2;
s1 = "s1";
s2 = "s2";
s1.swap(s2);
QCOMPARE(s1,QLatin1String("s2"));
QCOMPARE(s2,QLatin1String("s1"));
}
void tst_QString::prepend()
{
QString a;
a = "<>ABCABCABCABC>";
QCOMPARE(a.prepend("-"),(QString)"-<>ABCABCABCABC>");
#if 0
#if !defined(QT_NO_STL)
std::string stroustrup;
a.prepend( stroustrup );
#endif
#endif
}
void tst_QString::prepend_bytearray_data()
{
QTest::addColumn<QString>("str" );
QTest::addColumn<QByteArray>("ba" );
QTest::addColumn<QString>("res" );
QByteArray ba( 5, 0 );
ba[0] = 'a';
ba[1] = 'b';
ba[2] = 'c';
ba[3] = 'd';
#if 0
ba[4] = 0;
for ( int i=0; i<2; i++ ) {
// i == 0: the byte array is exactly strlen+1
// i == 1: the byte array is larger than strlen+1
QTest::newRow( QString("nullTerminated_%1_0").arg(i) ) << QString() << ba << QString("abcd");
QTest::newRow( QString("nullTerminated_%1_1").arg(i) ) << QString("") << ba << QString("abcd");
QTest::newRow( QString("nullTerminated_%1_2").arg(i) ) << QString(" foobar") << ba << QString("abcd foobar");
ba.resize( 8 );
}
// no 0 termination
ba.resize( 4 );
QTest::newRow( "notTerminated_0" ) << QString() << ba << QString("abcd");
QTest::newRow( "notTerminated_1" ) << QString("") << ba << QString("abcd");
QTest::newRow( "notTerminated_2" ) << QString(" foobar") << ba << QString("abcd foobar");
#endif
// byte array with only a 0
ba.resize( 1 );
ba[0] = 0;
QTest::newRow( "emptyString" ) << QString("foobar ") << ba << QString("foobar ");
// empty byte array
ba.resize( 0 );
QTest::newRow( "emptyByteArray" ) << QString(" foobar") << ba << QString(" foobar");
}
void tst_QString::prepend_bytearray()
{
{
QFETCH( QString, str );
QFETCH( QByteArray, ba );
str.prepend( ba );
QFETCH( QString, res );
QCOMPARE( str, res );
}
{
QFETCH( QString, str );
QFETCH( QByteArray, ba );
QTextCodec::setCodecForCStrings( QTextCodec::codecForMib(4) ); // Latin 1
str.prepend( ba );
QTextCodec::setCodecForCStrings( 0 );
QTEST( str, "res" );
}
}
void tst_QString::replace_uint_uint()
{
QFETCH( QString, string );
QFETCH( int, index );
QFETCH( int, len );
QFETCH( QString, after );
QString s1 = string;
s1.replace( (uint) index, (int) len, after );
QTEST( s1, "result" );
QString s2 = string;
s2.replace( (uint) index, (uint) len, after.unicode(), after.length() );
QTEST( s2, "result" );
if ( after.length() == 1 ) {
QString s3 = string;
s3.replace( (uint) index, (uint) len, QChar(after[0]) );
QTEST( s3, "result" );
QString s4 = string;
s4.replace( (uint) index, (uint) len, QChar(after[0]).toLatin1() );
QTEST( s4, "result" );
}
}
void tst_QString::replace_uint_uint_extra()
{
/*
This test is designed to be extremely slow if QString::replace() doesn't optimize the case
len == after.size().
*/
QString str("dsfkljfdsjklsdjsfjklfsdjkldfjslkjsdfkllkjdsfjklsfdkjsdflkjlsdfjklsdfkjldsflkjsddlkj");
for (int j = 1; j < 12; ++j)
str += str;
QString str2("aaaaaaaaaaaaaaaaaaaa");
for (int i = 0; i < 2000000; ++i) {
str.replace(10, 20, str2);
}
/*
Make sure that replacing with itself works.
*/
QString copy(str);
copy.detach();
str.replace(0, str.length(), str);
QVERIFY(copy == str);
/*
Make sure that replacing a part of oneself with itself works.
*/
QString str3("abcdefghij");
str3.replace(0, 1, str3);
QCOMPARE(str3, QString("abcdefghijbcdefghij"));
QString str4("abcdefghij");
str4.replace(1, 3, str4);
QCOMPARE(str4, QString("aabcdefghijefghij"));
QString str5("abcdefghij");
str5.replace(8, 10, str5);
QCOMPARE(str5, QString("abcdefghabcdefghij"));
}
void tst_QString::replace_string()
{
QFETCH( QString, string );
QFETCH( QString, before );
QFETCH( QString, after );
QFETCH( bool, bcs );
Qt::CaseSensitivity cs = bcs ? Qt::CaseSensitive : Qt::CaseInsensitive;
if ( before.length() == 1 ) {
QChar ch = before.at( 0 );
QString s1 = string;
s1.replace( ch, after, cs );
QTEST( s1, "result" );
if ( QChar(ch.toLatin1()) == ch ) {
QString s2 = string;
s2.replace( ch.toLatin1(), after, cs );
QTEST( s2, "result" );
}
}
QString s3 = string;
s3.replace( before, after, cs );
QTEST( s3, "result" );
QString s4 = string;
s4.replace( QRegExp(QRegExp::escape(before), cs), after );
QTEST( s4, "result" );
QString s5 = string;
s5.replace(QRegExp(before, cs, QRegExp::FixedString), after);
QTEST( s5, "result" );
}
void tst_QString::replace_regexp()
{
QFETCH( QString, string );
QFETCH( QString, regexp );
QFETCH( QString, after );
QString s2 = string;
s2.replace( QRegExp(regexp), after );
QTEST( s2, "result" );
}
void tst_QString::remove_uint_uint()
{
QFETCH( QString, string );
QFETCH( int, index );
QFETCH( int, len );
QFETCH( QString, after );
if ( after.length() == 0 ) {
QString s1 = string;
s1.remove( (uint) index, (uint) len );
QTEST( s1, "result" );
} else
QCOMPARE( 0, 0 ); // shut QtTest
}
void tst_QString::remove_string()
{
QFETCH( QString, string );
QFETCH( QString, before );
QFETCH( QString, after );
QFETCH( bool, bcs );
Qt::CaseSensitivity cs = bcs ? Qt::CaseSensitive : Qt::CaseInsensitive;
if ( after.length() == 0 ) {
if ( before.length() == 1 && cs ) {
QChar ch = before.at( 0 );
QString s1 = string;
s1.remove( ch );
QTEST( s1, "result" );
if ( QChar(ch.toLatin1()) == ch ) {
QString s2 = string;
s2.remove( ch );
QTEST( s2, "result" );
}
}
QString s3 = string;
s3.remove( before, cs );
QTEST( s3, "result" );
QString s4 = string;
s4.replace( QRegExp(QRegExp::escape(before), cs), after );
QTEST( s4, "result" );
QString s5 = string;
s5.replace( QRegExp(before, cs, QRegExp::FixedString), after );
QTEST( s5, "result" );
} else {
QCOMPARE( 0, 0 ); // shut QtTest
}
}
void tst_QString::remove_regexp()
{
QFETCH( QString, string );
QFETCH( QString, regexp );
QFETCH( QString, after );
if ( after.length() == 0 ) {
string.remove( QRegExp(regexp) );
QTEST( string, "result" );
} else {
QCOMPARE( 0, 0 ); // shut QtTest
}
}
void tst_QString::toNum()
{
#if defined (Q_WS_WIN) && defined (Q_CC_MSVC)
#define TEST_TO_INT(num, func) \
a = #num; \
QVERIFY2(a.func(&ok) == num ## i64 && ok, "Failed: num=" #num ", func=" #func);
#else
#define TEST_TO_INT(num, func) \
a = #num; \
QVERIFY2(a.func(&ok) == num ## LL && ok, "Failed: num=" #num ", func=" #func);
#endif
QString a;
bool ok = false;
TEST_TO_INT(0, toInt)
TEST_TO_INT(-1, toInt)
TEST_TO_INT(1, toInt)
TEST_TO_INT(2147483647, toInt)
TEST_TO_INT(-2147483648, toInt)
TEST_TO_INT(0, toShort)
TEST_TO_INT(-1, toShort)
TEST_TO_INT(1, toShort)
TEST_TO_INT(32767, toShort)
TEST_TO_INT(-32768, toShort)
TEST_TO_INT(0, toLong)
TEST_TO_INT(-1, toLong)
TEST_TO_INT(1, toLong)
TEST_TO_INT(2147483647, toLong)
TEST_TO_INT(-2147483648, toLong)
TEST_TO_INT(0, toLongLong)
TEST_TO_INT(-1, toLongLong)
TEST_TO_INT(1, toLongLong)
TEST_TO_INT(9223372036854775807, toLongLong)
TEST_TO_INT(-9223372036854775807, toLongLong)
#undef TEST_TO_INT
#if defined (Q_WS_WIN) && defined (Q_CC_MSVC)
#define TEST_TO_UINT(num, func) \
a = #num; \
QVERIFY2(a.func(&ok) == num ## i64 && ok, "Failed: num=" #num ", func=" #func);
#else
#define TEST_TO_UINT(num, func) \
a = #num; \
QVERIFY2(a.func(&ok) == num ## ULL && ok, "Failed: num=" #num ", func=" #func);
#endif
TEST_TO_UINT(0, toUInt)
TEST_TO_UINT(1, toUInt)
TEST_TO_UINT(4294967295, toUInt)
TEST_TO_UINT(0, toUShort)
TEST_TO_UINT(1, toUShort)
TEST_TO_UINT(65535, toUShort)
TEST_TO_UINT(0, toULong)
TEST_TO_UINT(1, toULong)
TEST_TO_UINT(4294967295, toULong)
TEST_TO_UINT(0, toULongLong)
TEST_TO_UINT(1, toULongLong)
TEST_TO_UINT(18446744073709551615, toULongLong)
#undef TEST_TO_UINT
#define TEST_BASE(str, base, num) \
a = str; \
QVERIFY2(a.toInt(&ok, base) == num && ok, "Failed: str=" #str " base= "#base " num=" #num ", func=toInt"); \
QVERIFY2(a.toUInt(&ok, base) == num && ok, "Failed: str=" #str " base= "#base " num=" #num ", func=toUInt"); \
QVERIFY2(a.toShort(&ok, base) == num && ok, "Failed: str=" #str " base= "#base " num=" #num ", func=toShort"); \
QVERIFY2(a.toUShort(&ok, base) == num && ok, "Failed: str=" #str " base= "#base " num=" #num ", func=toUShort"); \
QVERIFY2(a.toLong(&ok, base) == num && ok, "Failed: str=" #str " base= "#base " num=" #num ", func=toLong"); \
QVERIFY2(a.toULong(&ok, base) == num && ok, "Failed: str=" #str " base= "#base " num=" #num ", func=toULong"); \
QVERIFY2(a.toLongLong(&ok, base) == num && ok, "Failed: str=" #str " base= "#base " num=" #num ", func=toLongLong"); \
QVERIFY2(a.toULongLong(&ok, base) == num && ok, "Failed: str=" #str " base= "#base " num=" #num ", func=toULongLong");
TEST_BASE("FF", 16, 255)
TEST_BASE("0xFF", 16, 255)
TEST_BASE("77", 8, 63)
TEST_BASE("077", 8, 63)
TEST_BASE("0xFF", 0, 255)
TEST_BASE("077", 0, 63)
TEST_BASE("255", 0, 255)
TEST_BASE(" FF", 16, 255)
TEST_BASE(" 0xFF", 16, 255)
TEST_BASE(" 77", 8, 63)
TEST_BASE(" 077", 8, 63)
TEST_BASE(" 0xFF", 0, 255)
TEST_BASE(" 077", 0, 63)
TEST_BASE(" 255", 0, 255)
TEST_BASE("\tFF\t", 16, 255)
TEST_BASE("\t0xFF ", 16, 255)
TEST_BASE(" 77 ", 8, 63)
TEST_BASE("77 ", 8, 63)
#undef TEST_BASE
#define TEST_NEG_BASE(str, base, num) \
a = str; \
QVERIFY2(a.toInt(&ok, base) == num && ok, "Failed: str=" #str " base= "#base " num=" #num ", func=toInt"); \
QVERIFY2(a.toShort(&ok, base) == num && ok, "Failed: str=" #str " base= "#base " num=" #num ", func=toShort"); \
QVERIFY2(a.toLong(&ok, base) == num && ok, "Failed: str=" #str " base= "#base " num=" #num ", func=toLong"); \
QVERIFY2(a.toLongLong(&ok, base) == num && ok, "Failed: str=" #str " base= "#base " num=" #num ", func=toLongLong");
TEST_NEG_BASE("-FE", 16, -254)
TEST_NEG_BASE("-0xFE", 16, -254)
TEST_NEG_BASE("-77", 8, -63)
TEST_NEG_BASE("-077", 8, -63)
TEST_NEG_BASE("-0xFE", 0, -254)
TEST_NEG_BASE("-077", 0, -63)
TEST_NEG_BASE("-254", 0, -254)
#undef TEST_NEG_BASE
#define TEST_DOUBLE(num, str) \
a = str; \
QCOMPARE(a.toDouble(&ok), num); \
QVERIFY(ok);
TEST_DOUBLE(1.2345, "1.2345")
TEST_DOUBLE(12.345, "1.2345e+01")
TEST_DOUBLE(12.345, "1.2345E+01")
TEST_DOUBLE(12345.6, "12345.6")
#undef TEST_DOUBLE
#define TEST_BAD(str, func) \
a = str; \
a.func(&ok); \
QVERIFY2(!ok, "Failed: str=" #str " func=" #func);
TEST_BAD("32768", toShort)
TEST_BAD("-32769", toShort)
TEST_BAD("65536", toUShort)
TEST_BAD("2147483648", toInt)
TEST_BAD("-2147483649", toInt)
TEST_BAD("4294967296", toUInt)
if (sizeof(long) == 4) {
TEST_BAD("2147483648", toLong)
TEST_BAD("-2147483649", toLong)
TEST_BAD("4294967296", toULong)
}
TEST_BAD("9223372036854775808", toLongLong)
TEST_BAD("-9223372036854775809", toLongLong)
TEST_BAD("18446744073709551616", toULongLong)
TEST_BAD("-1", toUShort)
TEST_BAD("-1", toUInt)
TEST_BAD("-1", toULong)
TEST_BAD("-1", toULongLong)
#undef TEST_BAD
#define TEST_BAD_ALL(str) \
a = str; \
a.toShort(&ok); \
QVERIFY2(!ok, "Failed: str=" #str); \
a.toUShort(&ok); \
QVERIFY2(!ok, "Failed: str=" #str); \
a.toInt(&ok); \
QVERIFY2(!ok, "Failed: str=" #str); \
a.toUInt(&ok); \
QVERIFY2(!ok, "Failed: str=" #str); \
a.toLong(&ok); \
QVERIFY2(!ok, "Failed: str=" #str); \
a.toULong(&ok); \
QVERIFY2(!ok, "Failed: str=" #str); \
a.toLongLong(&ok); \
QVERIFY2(!ok, "Failed: str=" #str); \
a.toULongLong(&ok); \
QVERIFY2(!ok, "Failed: str=" #str); \
a.toFloat(&ok); \
QVERIFY2(!ok, "Failed: str=" #str); \
a.toDouble(&ok); \
QVERIFY2(!ok, "Failed: str=" #str);
TEST_BAD_ALL((const char*)0);
TEST_BAD_ALL("");
TEST_BAD_ALL(" ");
TEST_BAD_ALL(".");
TEST_BAD_ALL("-");
TEST_BAD_ALL("hello");
TEST_BAD_ALL("1.2.3");
TEST_BAD_ALL("0x0x0x");
TEST_BAD_ALL("123-^~<");
TEST_BAD_ALL("123ThisIsNotANumber");
#undef TEST_BAD_ALL
a = "FF";
a.toULongLong(&ok, 10);
QVERIFY(!ok);
a = "FF";
a.toULongLong(&ok, 0);
QVERIFY(!ok);
#ifdef QT_NO_FPU
double d = 3.40282346638528e+38; // slightly off FLT_MAX when using hardfloats
#else
double d = 3.4028234663852886e+38; // FLT_MAX
#endif
QString::number(d, 'e', 17).toFloat(&ok);
QVERIFY(ok);
QString::number(d + 1e32, 'e', 17).toFloat(&ok);
QVERIFY(!ok);
QString::number(-d, 'e', 17).toFloat(&ok);
QVERIFY(ok);
QString::number(-d - 1e32, 'e', 17).toFloat(&ok);
QVERIFY(!ok);
QString::number(d + 1e32, 'e', 17).toDouble(&ok);
QVERIFY(ok);
QString::number(-d - 1e32, 'e', 17).toDouble(&ok);
QVERIFY(ok);
}
void tst_QString::toUShort()
{
QString a;
bool ok;
QCOMPARE(a.toUShort(),(ushort)0);
QCOMPARE(a.toUShort(&ok),(ushort)0);
QVERIFY(!ok);
a="";
QCOMPARE(a.toUShort(),(ushort)0);
QCOMPARE(a.toUShort(&ok),(ushort)0);
QVERIFY(!ok);
a="COMPARE";
QCOMPARE(a.toUShort(),(ushort)0);
QCOMPARE(a.toUShort(&ok),(ushort)0);
QVERIFY(!ok);
a="123";
QCOMPARE(a.toUShort(),(ushort)123);
QCOMPARE(a.toUShort(&ok),(ushort)123);
QVERIFY(ok);
a="123A";
QCOMPARE(a.toUShort(),(ushort)0);
QCOMPARE(a.toUShort(&ok),(ushort)0);
QVERIFY(!ok);
a="1234567";
QCOMPARE(a.toUShort(),(ushort)0);
QCOMPARE(a.toUShort(&ok),(ushort)0);
QVERIFY(!ok);
a = "aaa123aaa";
QCOMPARE(a.toUShort(),(ushort)0);
QCOMPARE(a.toUShort(&ok),(ushort)0);
QVERIFY(!ok);
a = "aaa123";
QCOMPARE(a.toUShort(),(ushort)0);
QCOMPARE(a.toUShort(&ok),(ushort)0);
QVERIFY(!ok);
a = "123aaa";
QCOMPARE(a.toUShort(),(ushort)0);
QCOMPARE(a.toUShort(&ok),(ushort)0);
QVERIFY(!ok);
a = "32767";
QCOMPARE(a.toUShort(),(ushort)32767);
QCOMPARE(a.toUShort(&ok),(ushort)32767);
QVERIFY(ok);
a = "-32767";
QCOMPARE(a.toUShort(),(ushort)0);
QCOMPARE(a.toUShort(&ok),(ushort)0);
QVERIFY(!ok);
a = "65535";
QCOMPARE(a.toUShort(),(ushort)65535);
QCOMPARE(a.toUShort(&ok),(ushort)65535);
QVERIFY(ok);
if (sizeof(short) == 2) {
a = "65536";
QCOMPARE(a.toUShort(),(ushort)0);
QCOMPARE(a.toUShort(&ok),(ushort)0);
QVERIFY(!ok);
a = "123456";
QCOMPARE(a.toUShort(),(ushort)0);
QCOMPARE(a.toUShort(&ok),(ushort)0);
QVERIFY(!ok);
}
}
void tst_QString::toShort()
{
QString a;
bool ok;
QCOMPARE(a.toShort(),(short)0);
QCOMPARE(a.toShort(&ok),(short)0);
QVERIFY(!ok);
a="";
QCOMPARE(a.toShort(),(short)0);
QCOMPARE(a.toShort(&ok),(short)0);
QVERIFY(!ok);
a="COMPARE";
QCOMPARE(a.toShort(),(short)0);
QCOMPARE(a.toShort(&ok),(short)0);
QVERIFY(!ok);
a="123";
QCOMPARE(a.toShort(),(short)123);
QCOMPARE(a.toShort(&ok),(short)123);
QVERIFY(ok);
a="123A";
QCOMPARE(a.toShort(),(short)0);
QCOMPARE(a.toShort(&ok),(short)0);
QVERIFY(!ok);
a="1234567";
QCOMPARE(a.toShort(),(short)0);
QCOMPARE(a.toShort(&ok),(short)0);
QVERIFY(!ok);
a = "aaa123aaa";
QCOMPARE(a.toShort(),(short)0);
QCOMPARE(a.toShort(&ok),(short)0);
QVERIFY(!ok);
a = "aaa123";
QCOMPARE(a.toShort(),(short)0);
QCOMPARE(a.toShort(&ok),(short)0);
QVERIFY(!ok);
a = "123aaa";
QCOMPARE(a.toShort(),(short)0);
QCOMPARE(a.toShort(&ok),(short)0);
QVERIFY(!ok);
a = "32767";
QCOMPARE(a.toShort(),(short)32767);
QCOMPARE(a.toShort(&ok),(short)32767);
QVERIFY(ok);
a = "-32767";
QCOMPARE(a.toShort(),(short)-32767);
QCOMPARE(a.toShort(&ok),(short)-32767);
QVERIFY(ok);
a = "-32768";
QCOMPARE(a.toShort(),(short)-32768);
QCOMPARE(a.toShort(&ok),(short)-32768);
QVERIFY(ok);
if (sizeof(short) == 2) {
a = "32768";
QCOMPARE(a.toShort(),(short)0);
QCOMPARE(a.toShort(&ok),(short)0);
QVERIFY(!ok);
a = "-32769";
QCOMPARE(a.toShort(),(short)0);
QCOMPARE(a.toShort(&ok),(short)0);
QVERIFY(!ok);
}
}
void tst_QString::toInt()
{
QString a;
bool ok;
QCOMPARE(a.toInt(),0);
QCOMPARE(a.toInt(&ok),0);
QVERIFY(!ok);
a = "";
QCOMPARE(a.toInt(),0);
QCOMPARE(a.toInt(&ok),0);
QVERIFY(!ok);
a="COMPARE";
QCOMPARE(a.toInt(),0);
QCOMPARE(a.toInt(&ok),0);
QVERIFY(!ok);
a="123";
QCOMPARE(a.toInt(),123);
QCOMPARE(a.toInt(&ok),123);
QVERIFY(ok);
a="123A";
QCOMPARE(a.toInt(),0);
QCOMPARE(a.toInt(&ok),0);
QVERIFY(!ok);
a="1234567";
QCOMPARE(a.toInt(),1234567);
QCOMPARE(a.toInt(&ok),1234567);
QVERIFY(ok);
a="12345678901234";
QCOMPARE(a.toInt(),0);
QCOMPARE(a.toInt(&ok),0);
QVERIFY(!ok);
a="3234567890";
QCOMPARE(a.toInt(),0);
QCOMPARE(a.toInt(&ok),0);
QVERIFY(!ok);
a = "aaa12345aaa";
QCOMPARE(a.toInt(),0);
QCOMPARE(a.toInt(&ok),0);
QVERIFY(!ok);
a = "aaa12345";
QCOMPARE(a.toInt(),0);
QCOMPARE(a.toInt(&ok),0);
QVERIFY(!ok);
a = "12345aaa";
QCOMPARE(a.toInt(),0);
QCOMPARE(a.toInt(&ok),0);
QVERIFY(!ok);
a = "2147483647"; // 2**31 - 1
QCOMPARE(a.toInt(),2147483647);
QCOMPARE(a.toInt(&ok),2147483647);
QVERIFY(ok);
if (sizeof(int) == 4) {
a = "-2147483647"; // -(2**31 - 1)
QCOMPARE(a.toInt(),-2147483647);
QCOMPARE(a.toInt(&ok),-2147483647);
QVERIFY(ok);
a = "2147483648"; // 2**31
QCOMPARE(a.toInt(),0);
QCOMPARE(a.toInt(&ok),0);
QVERIFY(!ok);
a = "-2147483648"; // -2**31
QCOMPARE(a.toInt(),-2147483647 - 1);
QCOMPARE(a.toInt(&ok),-2147483647 - 1);
QVERIFY(ok);
a = "2147483649"; // 2**31 + 1
QCOMPARE(a.toInt(),0);
QCOMPARE(a.toInt(&ok),0);
QVERIFY(!ok);
}
}
void tst_QString::toUInt()
{
bool ok;
QString a;
a="3234567890";
QCOMPARE(a.toUInt(&ok),3234567890u);
QVERIFY(ok);
a = "-50";
QCOMPARE(a.toUInt(),0u);
QCOMPARE(a.toUInt(&ok),0u);
QVERIFY(!ok);
a = "4294967295"; // 2**32 - 1
QCOMPARE(a.toUInt(),4294967295u);
QCOMPARE(a.toUInt(&ok),4294967295u);
QVERIFY(ok);
if (sizeof(int) == 4) {
a = "4294967296"; // 2**32
QCOMPARE(a.toUInt(),0u);
QCOMPARE(a.toUInt(&ok),0u);
QVERIFY(!ok);
}
}
///////////////////////////// to*Long //////////////////////////////////////
void tst_QString::toULong_data()
{
QTest::addColumn<QString>("str" );
QTest::addColumn<int>("base" );
QTest::addColumn<ulong>("result" );
QTest::addColumn<bool>("ok" );
QTest::newRow( "default" ) << QString() << 10 << 0UL << false;
QTest::newRow( "empty" ) << QString("") << 10 << 0UL << false;
QTest::newRow( "ulong1" ) << QString("3234567890") << 10 << 3234567890UL << true;
QTest::newRow( "ulong2" ) << QString("fFFfFfFf") << 16 << 0xFFFFFFFFUL << true;
}
void tst_QString::toULong()
{
QFETCH( QString, 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_QString::toLong_data()
{
QTest::addColumn<QString>("str" );
QTest::addColumn<int>("base" );
QTest::addColumn<long>("result" );
QTest::addColumn<bool>("ok" );
QTest::newRow( "default" ) << QString() << 10 << 0L << false;
QTest::newRow( "empty" ) << QString("") << 10 << 0L << false;
QTest::newRow( "normal" ) << QString("7fFFfFFf") << 16 << 0x7fFFfFFfL << true;
QTest::newRow( "long_max" ) << QString("2147483647") << 10 << 2147483647L << true;
if (sizeof(long) == 4) {
QTest::newRow( "long_max+1" ) << QString("2147483648") << 10 << 0L << false;
QTest::newRow( "long_min-1" ) << QString("-80000001") << 16 << 0L << false;
}
QTest::newRow( "negative" ) << QString("-7fffffff") << 16 << -0x7fffffffL << true;
// QTest::newRow( "long_min" ) << QString("-80000000") << 16 << 0x80000000uL << true;
}
void tst_QString::toLong()
{
QFETCH( QString, str );
QFETCH( int, base );
QFETCH( long, result );
QFETCH( bool, ok );
bool b;
QCOMPARE( str.toLong( 0, base ), result );
QCOMPARE( str.toLong( &b, base ), result );
QCOMPARE( b, ok );
}
////////////////////////// to*LongLong //////////////////////////////////////
void tst_QString::toULongLong()
{
QString str;
bool ok;
str = "18446744073709551615"; // ULLONG_MAX
QCOMPARE( str.toULongLong( 0 ), Q_UINT64_C(18446744073709551615) );
QCOMPARE( str.toULongLong( &ok ), Q_UINT64_C(18446744073709551615) );
QVERIFY( ok );
str = "18446744073709551616"; // ULLONG_MAX + 1
QCOMPARE( str.toULongLong( 0 ), Q_UINT64_C(0) );
QCOMPARE( str.toULongLong( &ok ), Q_UINT64_C(0) );
QVERIFY( !ok );
str = "-150";
QCOMPARE( str.toULongLong( 0 ), Q_UINT64_C(0) );
QCOMPARE( str.toULongLong( &ok ), Q_UINT64_C(0) );
QVERIFY( !ok );
}
void tst_QString::toLongLong()
{
QString str;
bool ok;
str = "9223372036854775807"; // LLONG_MAX
QCOMPARE( str.toLongLong( 0 ), Q_INT64_C(9223372036854775807) );
QCOMPARE( str.toLongLong( &ok ), Q_INT64_C(9223372036854775807) );
QVERIFY( ok );
str = "-9223372036854775808"; // LLONG_MIN
QCOMPARE( str.toLongLong( 0 ),
-Q_INT64_C(9223372036854775807) - Q_INT64_C(1) );
QCOMPARE( str.toLongLong( &ok ),
-Q_INT64_C(9223372036854775807) - Q_INT64_C(1) );
QVERIFY( ok );
str = "aaaa9223372036854775807aaaa";
QCOMPARE( str.toLongLong( 0 ), Q_INT64_C(0) );
QCOMPARE( str.toLongLong( &ok ), Q_INT64_C(0) );
QVERIFY( !ok );
str = "9223372036854775807aaaa";
QCOMPARE( str.toLongLong( 0 ), Q_INT64_C(0) );
QCOMPARE( str.toLongLong( &ok ), Q_INT64_C(0) );
QVERIFY( !ok );
str = "aaaa9223372036854775807";
QCOMPARE( str.toLongLong( 0 ), Q_INT64_C(0) );
QCOMPARE( str.toLongLong( &ok ), Q_INT64_C(0) );
QVERIFY( !ok );
static char digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for (int i = 0; i < 36; ++i) {
for (int j = 0; j < 36; ++j) {
for (int k = 0; k < 36; ++k) {
QString str;
str += QChar(digits[i]);
str += QChar(digits[j]);
str += QChar(digits[k]);
qlonglong value = (((i * 36) + j) * 36) + k;
QVERIFY(str.toLongLong(0, 36) == value);
}
}
}
}
////////////////////////////////////////////////////////////////////////////
void tst_QString::toFloat()
{
QString a;
bool ok;
a="0.000000000931322574615478515625";
QCOMPARE(a.toFloat(&ok),(float)(0.000000000931322574615478515625));
QVERIFY(ok);
}
void tst_QString::toDouble_data()
{
QTest::addColumn<QString>("str" );
QTest::addColumn<double>("result" );
QTest::addColumn<bool>("result_ok" );
QTest::newRow( "ok00" ) << QString("0.000000000931322574615478515625") << 0.000000000931322574615478515625 << true;
QTest::newRow( "ok01" ) << QString(" 123.45") << 123.45 << true;
QTest::newRow( "ok02" ) << QString("0.1e10") << 0.1e10 << true;
QTest::newRow( "ok03" ) << QString("0.1e-10") << 0.1e-10 << true;
QTest::newRow( "ok04" ) << QString("1e10") << 1.0e10 << true;
QTest::newRow( "ok05" ) << QString("1e+10") << 1.0e10 << true;
QTest::newRow( "ok06" ) << QString("1e-10") << 1.0e-10 << true;
QTest::newRow( "ok07" ) << QString(" 1e10") << 1.0e10 << true;
QTest::newRow( "ok08" ) << QString(" 1e+10") << 1.0e10 << true;
QTest::newRow( "ok09" ) << QString(" 1e-10") << 1.0e-10 << true;
QTest::newRow( "ok10" ) << QString("1.") << 1.0 << true;
QTest::newRow( "ok11" ) << QString(".1") << 0.1 << true;
QTest::newRow( "wrong00" ) << QString("123.45 ") << 123.45 << true;
QTest::newRow( "wrong01" ) << QString(" 123.45 ") << 123.45 << true;
QTest::newRow( "wrong02" ) << QString("aa123.45aa") << 0.0 << false;
QTest::newRow( "wrong03" ) << QString("123.45aa") << 0.0 << false;
QTest::newRow( "wrong04" ) << QString("123erf") << 0.0 << false;
QTest::newRow( "wrong05" ) << QString("abc") << 0.0 << false;
QTest::newRow( "wrong06" ) << QString() << 0.0 << false;
QTest::newRow( "wrong07" ) << QString("") << 0.0 << false;
}
void tst_QString::toDouble()
{
QFETCH( QString, str );
QFETCH( bool, result_ok );
bool ok;
double d = str.toDouble( &ok );
if ( result_ok ) {
QTEST( d, "result" );
QVERIFY( ok );
} else {
QVERIFY( !ok );
}
}
void tst_QString::setNum()
{
QString a;
QCOMPARE(a.setNum(123),(QString)"123");
QCOMPARE(a.setNum(-123),(QString)"-123");
QCOMPARE(a.setNum(0x123,16),(QString)"123");
QCOMPARE(a.setNum((short)123),(QString)"123");
QCOMPARE(a.setNum(123L),(QString)"123");
QCOMPARE(a.setNum(123UL),(QString)"123");
QCOMPARE(a.setNum(2147483647L), QString("2147483647")); // 32 bit LONG_MAX
QCOMPARE(a.setNum(-2147483647L), QString("-2147483647")); // LONG_MIN + 1
QCOMPARE(a.setNum(-2147483647L-1L), QString("-2147483648")); // LONG_MIN
QCOMPARE(a.setNum(1.23), QString("1.23"));
QCOMPARE(a.setNum(1.234567), QString("1.23457"));
#if defined(LONG_MAX) && defined(LLONG_MAX) && LONG_MAX == LLONG_MAX
// LONG_MAX and LONG_MIN on 64 bit systems
QCOMPARE(a.setNum(9223372036854775807L), QString("9223372036854775807"));
QCOMPARE(a.setNum(-9223372036854775807L-1L), QString("-9223372036854775808"));
QCOMPARE(a.setNum(18446744073709551615UL), QString("18446744073709551615"));
#endif
QCOMPARE(a.setNum(Q_INT64_C(123)), QString("123"));
// 2^40 == 1099511627776
QCOMPARE(a.setNum(Q_INT64_C(-1099511627776)), QString("-1099511627776"));
QCOMPARE(a.setNum(Q_UINT64_C(1099511627776)), QString("1099511627776"));
QCOMPARE(a.setNum(Q_INT64_C(9223372036854775807)), // LLONG_MAX
QString("9223372036854775807"));
QCOMPARE(a.setNum(-Q_INT64_C(9223372036854775807) - Q_INT64_C(1)),
QString("-9223372036854775808"));
QCOMPARE(a.setNum(Q_UINT64_C(18446744073709551615)), // ULLONG_MAX
QString("18446744073709551615"));
QCOMPARE(a.setNum(0.000000000931322574615478515625),QString("9.31323e-10"));
// QCOMPARE(a.setNum(0.000000000931322574615478515625,'g',30),(QString)"9.31322574615478515625e-010");
// QCOMPARE(a.setNum(0.000000000931322574615478515625,'f',30),(QString)"0.00000000093132257461547852");
}
void tst_QString::startsWith()
{
QString a;
a = "AB";
QVERIFY( a.startsWith("A") );
QVERIFY( a.startsWith("AB") );
QVERIFY( !a.startsWith("C") );
QVERIFY( !a.startsWith("ABCDEF") );
QVERIFY( a.startsWith("") );
QVERIFY( a.startsWith(QString::null) );
QVERIFY( a.startsWith('A') );
QVERIFY( a.startsWith(QLatin1Char('A')) );
QVERIFY( a.startsWith(QChar('A')) );
QVERIFY( !a.startsWith('C') );
QVERIFY( !a.startsWith(QChar()) );
QVERIFY( !a.startsWith(QLatin1Char(0)) );
QVERIFY( a.startsWith(QLatin1String("A")) );
QVERIFY( a.startsWith(QLatin1String("AB")) );
QVERIFY( !a.startsWith(QLatin1String("C")) );
QVERIFY( !a.startsWith(QLatin1String("ABCDEF")) );
QVERIFY( a.startsWith(QLatin1String("")) );
QVERIFY( a.startsWith(QLatin1String(0)) );
QVERIFY( a.startsWith("A", Qt::CaseSensitive) );
QVERIFY( a.startsWith("A", Qt::CaseInsensitive) );
QVERIFY( !a.startsWith("a", Qt::CaseSensitive) );
QVERIFY( a.startsWith("a", Qt::CaseInsensitive) );
QVERIFY( !a.startsWith("aB", Qt::CaseSensitive) );
QVERIFY( a.startsWith("aB", Qt::CaseInsensitive) );
QVERIFY( !a.startsWith("C", Qt::CaseSensitive) );
QVERIFY( !a.startsWith("C", Qt::CaseInsensitive) );
QVERIFY( !a.startsWith("c", Qt::CaseSensitive) );
QVERIFY( !a.startsWith("c", Qt::CaseInsensitive) );
QVERIFY( !a.startsWith("abcdef", Qt::CaseInsensitive) );
QVERIFY( a.startsWith("", Qt::CaseInsensitive) );
QVERIFY( a.startsWith(QString::null, Qt::CaseInsensitive) );
QVERIFY( a.startsWith('a', Qt::CaseInsensitive) );
QVERIFY( a.startsWith('A', Qt::CaseInsensitive) );
QVERIFY( a.startsWith(QLatin1Char('a'), Qt::CaseInsensitive) );
QVERIFY( a.startsWith(QChar('a'), Qt::CaseInsensitive) );
QVERIFY( !a.startsWith('c', Qt::CaseInsensitive) );
QVERIFY( !a.startsWith(QChar(), Qt::CaseInsensitive) );
QVERIFY( !a.startsWith(QLatin1Char(0), Qt::CaseInsensitive) );
QVERIFY( a.startsWith(QLatin1String("A"), Qt::CaseSensitive) );
QVERIFY( a.startsWith(QLatin1String("A"), Qt::CaseInsensitive) );
QVERIFY( !a.startsWith(QLatin1String("a"), Qt::CaseSensitive) );
QVERIFY( a.startsWith(QLatin1String("a"), Qt::CaseInsensitive) );
QVERIFY( !a.startsWith(QLatin1String("aB"), Qt::CaseSensitive) );
QVERIFY( a.startsWith(QLatin1String("aB"), Qt::CaseInsensitive) );
QVERIFY( !a.startsWith(QLatin1String("C"), Qt::CaseSensitive) );
QVERIFY( !a.startsWith(QLatin1String("C"), Qt::CaseInsensitive) );
QVERIFY( !a.startsWith(QLatin1String("c"), Qt::CaseSensitive) );
QVERIFY( !a.startsWith(QLatin1String("c"), Qt::CaseInsensitive) );
QVERIFY( !a.startsWith(QLatin1String("abcdef"), Qt::CaseInsensitive) );
QVERIFY( a.startsWith(QLatin1String(""), Qt::CaseInsensitive) );
QVERIFY( a.startsWith(QLatin1String(0), Qt::CaseInsensitive) );
QVERIFY( a.startsWith('A', Qt::CaseSensitive) );
QVERIFY( a.startsWith(QLatin1Char('A'), Qt::CaseSensitive) );
QVERIFY( a.startsWith(QChar('A'), Qt::CaseSensitive) );
QVERIFY( !a.startsWith('a', Qt::CaseSensitive) );
QVERIFY( !a.startsWith(QChar(), Qt::CaseSensitive) );
QVERIFY( !a.startsWith(QLatin1Char(0), Qt::CaseSensitive) );
#define TEST_REF_STARTS_WITH(string, yes) { CREATE_REF(string); QCOMPARE(a.startsWith(ref), yes); }
TEST_REF_STARTS_WITH("A", true);
TEST_REF_STARTS_WITH("AB", true);
TEST_REF_STARTS_WITH("C", false);
TEST_REF_STARTS_WITH("ABCDEF", false);
#undef TEST_REF_STARTS_WITH
a = "";
QVERIFY( a.startsWith("") );
QVERIFY( a.startsWith(QString::null) );
QVERIFY( !a.startsWith("ABC") );
QVERIFY( a.startsWith(QLatin1String("")) );
QVERIFY( a.startsWith(QLatin1String(0)) );
QVERIFY( !a.startsWith(QLatin1String("ABC")) );
QVERIFY( !a.startsWith(QLatin1Char(0)) );
QVERIFY( !a.startsWith(QLatin1Char('x')) );
QVERIFY( !a.startsWith(QChar()) );
a = QString::null;
QVERIFY( !a.startsWith("") );
QVERIFY( a.startsWith(QString::null) );
QVERIFY( !a.startsWith("ABC") );
QVERIFY( !a.startsWith(QLatin1String("")) );
QVERIFY( a.startsWith(QLatin1String(0)) );
QVERIFY( !a.startsWith(QLatin1String("ABC")) );
QVERIFY( !a.startsWith(QLatin1Char(0)) );
QVERIFY( !a.startsWith(QLatin1Char('x')) );
QVERIFY( !a.startsWith(QChar()) );
}
void tst_QString::endsWith()
{
QString a;
a = "AB";
QVERIFY( a.endsWith("B") );
QVERIFY( a.endsWith("AB") );
QVERIFY( !a.endsWith("C") );
QVERIFY( !a.endsWith("ABCDEF") );
QVERIFY( a.endsWith("") );
QVERIFY( a.endsWith(QString::null) );
QVERIFY( a.endsWith('B') );
QVERIFY( a.endsWith(QLatin1Char('B')) );
QVERIFY( a.endsWith(QChar('B')) );
QVERIFY( !a.endsWith('C') );
QVERIFY( !a.endsWith(QChar()) );
QVERIFY( !a.endsWith(QLatin1Char(0)) );
QVERIFY( a.endsWith(QLatin1String("B")) );
QVERIFY( a.endsWith(QLatin1String("AB")) );
QVERIFY( !a.endsWith(QLatin1String("C")) );
QVERIFY( !a.endsWith(QLatin1String("ABCDEF")) );
QVERIFY( a.endsWith(QLatin1String("")) );
QVERIFY( a.endsWith(QLatin1String(0)) );
QVERIFY( a.endsWith("B", Qt::CaseSensitive) );
QVERIFY( a.endsWith("B", Qt::CaseInsensitive) );
QVERIFY( !a.endsWith("b", Qt::CaseSensitive) );
QVERIFY( a.endsWith("b", Qt::CaseInsensitive) );
QVERIFY( !a.endsWith("aB", Qt::CaseSensitive) );
QVERIFY( a.endsWith("aB", Qt::CaseInsensitive) );
QVERIFY( !a.endsWith("C", Qt::CaseSensitive) );
QVERIFY( !a.endsWith("C", Qt::CaseInsensitive) );
QVERIFY( !a.endsWith("c", Qt::CaseSensitive) );
QVERIFY( !a.endsWith("c", Qt::CaseInsensitive) );
QVERIFY( !a.endsWith("abcdef", Qt::CaseInsensitive) );
QVERIFY( a.endsWith("", Qt::CaseInsensitive) );
QVERIFY( a.endsWith(QString::null, Qt::CaseInsensitive) );
QVERIFY( a.endsWith('b', Qt::CaseInsensitive) );
QVERIFY( a.endsWith('B', Qt::CaseInsensitive) );
QVERIFY( a.endsWith(QLatin1Char('b'), Qt::CaseInsensitive) );
QVERIFY( a.endsWith(QChar('b'), Qt::CaseInsensitive) );
QVERIFY( !a.endsWith('c', Qt::CaseInsensitive) );
QVERIFY( !a.endsWith(QChar(), Qt::CaseInsensitive) );
QVERIFY( !a.endsWith(QLatin1Char(0), Qt::CaseInsensitive) );
QVERIFY( a.endsWith(QLatin1String("B"), Qt::CaseSensitive) );
QVERIFY( a.endsWith(QLatin1String("B"), Qt::CaseInsensitive) );
QVERIFY( !a.endsWith(QLatin1String("b"), Qt::CaseSensitive) );
QVERIFY( a.endsWith(QLatin1String("b"), Qt::CaseInsensitive) );
QVERIFY( !a.endsWith(QLatin1String("aB"), Qt::CaseSensitive) );
QVERIFY( a.endsWith(QLatin1String("aB"), Qt::CaseInsensitive) );
QVERIFY( !a.endsWith(QLatin1String("C"), Qt::CaseSensitive) );
QVERIFY( !a.endsWith(QLatin1String("C"), Qt::CaseInsensitive) );
QVERIFY( !a.endsWith(QLatin1String("c"), Qt::CaseSensitive) );
QVERIFY( !a.endsWith(QLatin1String("c"), Qt::CaseInsensitive) );
QVERIFY( !a.endsWith(QLatin1String("abcdef"), Qt::CaseInsensitive) );
QVERIFY( a.endsWith(QLatin1String(""), Qt::CaseInsensitive) );
QVERIFY( a.endsWith(QLatin1String(0), Qt::CaseInsensitive) );
QVERIFY( a.endsWith('B', Qt::CaseSensitive) );
QVERIFY( a.endsWith(QLatin1Char('B'), Qt::CaseSensitive) );
QVERIFY( a.endsWith(QChar('B'), Qt::CaseSensitive) );
QVERIFY( !a.endsWith('b', Qt::CaseSensitive) );
QVERIFY( !a.endsWith(QChar(), Qt::CaseSensitive) );
QVERIFY( !a.endsWith(QLatin1Char(0), Qt::CaseSensitive) );
#define TEST_REF_ENDS_WITH(string, yes) { CREATE_REF(string); QCOMPARE(a.endsWith(ref), yes); }
TEST_REF_ENDS_WITH(QLatin1String("B"), true);
TEST_REF_ENDS_WITH(QLatin1String("AB"), true);
TEST_REF_ENDS_WITH(QLatin1String("C"), false);
TEST_REF_ENDS_WITH(QLatin1String("ABCDEF"), false);
TEST_REF_ENDS_WITH(QLatin1String(""), true);
TEST_REF_ENDS_WITH(QLatin1String(0), true);
#undef TEST_REF_STARTS_WITH
a = "";
QVERIFY( a.endsWith("") );
QVERIFY( a.endsWith(QString::null) );
QVERIFY( !a.endsWith("ABC") );
QVERIFY( !a.endsWith(QLatin1Char(0)) );
QVERIFY( !a.endsWith(QLatin1Char('x')) );
QVERIFY( !a.endsWith(QChar()) );
QVERIFY( a.endsWith(QLatin1String("")) );
QVERIFY( a.endsWith(QLatin1String(0)) );
QVERIFY( !a.endsWith(QLatin1String("ABC")) );
a = QString::null;
QVERIFY( !a.endsWith("") );
QVERIFY( a.endsWith(QString::null) );
QVERIFY( !a.endsWith("ABC") );
QVERIFY( !a.endsWith(QLatin1String("")) );
QVERIFY( a.endsWith(QLatin1String(0)) );
QVERIFY( !a.endsWith(QLatin1String("ABC")) );
QVERIFY( !a.endsWith(QLatin1Char(0)) );
QVERIFY( !a.endsWith(QLatin1Char('x')) );
QVERIFY( !a.endsWith(QChar()) );
}
void tst_QString::check_QDataStream()
{
QString a;
QByteArray ar;
{
QDataStream out(&ar,QIODevice::WriteOnly);
out << QString("COMPARE Text");
}
{
QDataStream in(&ar,QIODevice::ReadOnly);
in >> a;
QCOMPARE(a,(QString)"COMPARE Text");
}
}
void tst_QString::check_QTextStream()
{
QString a;
QByteArray ar;
{
QTextStream out(&ar,QIODevice::WriteOnly);
out << QString("This is COMPARE Text");
}
{
QTextStream in(&ar,QIODevice::ReadOnly);
in >> a;
QCOMPARE(a,(QString)"This");
}
}
void tst_QString::check_QTextIOStream()
{
QString a;
{
a="";
QTextStream ts(&a);
ts << "pi \261= " << 3.125;
QCOMPARE(a,(QString)"pi \261= 3.125");
}
{
a="123 456";
int x,y;
QTextStream(&a) >> x >> y;
QCOMPARE(x,123);
QCOMPARE(y,456);
}
}
void tst_QString::fromRawData()
{
const QChar ptr[] = { 0x1234, 0x0000 };
QString cstr = QString::fromRawData(ptr, 1);
QVERIFY(cstr.isDetached());
QVERIFY(cstr.constData() == ptr);
QVERIFY(cstr == QString(ptr, 1));
cstr.squeeze();
QVERIFY(cstr.constData() == ptr);
cstr.detach();
QVERIFY(cstr.size() == 1);
QVERIFY(cstr.capacity() == 1);
QVERIFY(cstr.constData() != ptr);
QVERIFY(cstr.constData()[0] == QChar(0x1234));
QVERIFY(cstr.constData()[1] == QChar(0x0000));
}
void tst_QString::setRawData()
{
const QChar ptr[] = { 0x1234, 0x0000 };
const QChar ptr2[] = { 0x4321, 0x0000 };
QString cstr;
// This just tests the fromRawData() fallback
QVERIFY(!cstr.isDetached());
cstr.setRawData(ptr, 1);
QVERIFY(cstr.isDetached());
QVERIFY(cstr.constData() == ptr);
QVERIFY(cstr == QString(ptr, 1));
// This actually tests the recycling of the shared data object
QString::DataPtr csd = cstr.data_ptr();
cstr.setRawData(ptr2, 1);
QVERIFY(cstr.isDetached());
QVERIFY(cstr.constData() == ptr2);
QVERIFY(cstr == QString(ptr2, 1));
QVERIFY(cstr.data_ptr() == csd);
// This tests the discarding of the shared data object
cstr = "foo";
QVERIFY(cstr.isDetached());
QVERIFY(cstr.constData() != ptr2);
// Another test of the fallback
csd = cstr.data_ptr();
cstr.setRawData(ptr2, 1);
QVERIFY(cstr.isDetached());
QVERIFY(cstr.constData() == ptr2);
QVERIFY(cstr == QString(ptr2, 1));
QVERIFY(cstr.data_ptr() != csd);
}
void tst_QString::fromStdString()
{
#ifdef Q_CC_HPACC
QSKIP("This test crashes on HP-UX with aCC", SkipSingle);
#endif
#if !defined(QT_NO_STL)
std::string stroustrup = "foo";
QString eng = QString::fromStdString( stroustrup );
QCOMPARE( eng, QString("foo") );
const char cnull[] = "Embedded\0null\0character!";
std::string stdnull( cnull, sizeof(cnull)-1 );
QString qtnull = QString::fromStdString( stdnull );
QCOMPARE( qtnull.size(), int(stdnull.size()) );
#endif
}
void tst_QString::toStdString()
{
#ifdef Q_CC_HPACC
QSKIP("This test crashes on HP-UX with aCC", SkipSingle);
#endif
#if !defined(QT_NO_STL)
QString nord = "foo";
std::string stroustrup1 = nord.toStdString();
QVERIFY( qstrcmp(stroustrup1.c_str(), "foo") == 0 );
// For now, most QString constructors are also broken with respect
// to embedded null characters, had to find one that works...
const QChar qcnull[] = {
'E', 'm', 'b', 'e', 'd', 'd', 'e', 'd', '\0',
'n', 'u', 'l', 'l', '\0',
'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', '!'
};
QString qtnull( qcnull, sizeof(qcnull)/sizeof(QChar) );
std::string stdnull = qtnull.toStdString();
QCOMPARE( int(stdnull.size()), qtnull.size() );
#endif
}
void tst_QString::utf8()
{
QFETCH( QByteArray, utf8 );
QFETCH( QString, res );
QCOMPARE( utf8, QByteArray(res.toUtf8()) );
}
void tst_QString::stringRef_utf8_data()
{
utf8_data();
}
void tst_QString::stringRef_utf8()
{
QFETCH( QByteArray, utf8 );
QFETCH( QString, res );
QStringRef ref(&res, 0, res.length());
QCOMPARE( utf8, QByteArray(ref.toUtf8()) );
}
// copied to tst_QTextCodec::utf8Codec_data()
void tst_QString::fromUtf8_data()
{
QTest::addColumn<QByteArray>("utf8");
QTest::addColumn<QString>("res");
QTest::addColumn<int>("len");
QString str;
QTest::newRow("str0") << QByteArray("abcdefgh") << QString("abcdefgh") << -1;
QTest::newRow("str0-len") << QByteArray("abcdefgh") << QString("abc") << 3;
QTest::newRow("str1") << QByteArray("\303\266\303\244\303\274\303\226\303\204\303\234\303\270\303\246\303\245\303\230\303\206\303\205") << QString("\366\344\374\326\304\334\370\346\345\330\306\305") << -1;
QTest::newRow("str1-len") << QByteArray("\303\266\303\244\303\274\303\226\303\204\303\234\303\270\303\246\303\245\303\230\303\206\303\205") << QString("\366\344\374\326\304") << 10;
str += QChar(0x05e9);
str += QChar(0x05d3);
str += QChar(0x05d2);
QTest::newRow("str2") << QByteArray("\327\251\327\223\327\222") << str << -1;
str = QChar(0x05e9);
QTest::newRow("str2-len") << QByteArray("\327\251\327\223\327\222") << str << 2;
str = QChar(0x20ac);
str += " some text";
QTest::newRow("str3") << QByteArray("\342\202\254 some text") << str << -1;
str = QChar(0x20ac);
str += " some ";
QTest::newRow("str3-len") << QByteArray("\342\202\254 some text") << str << 9;
str = "hello";
str += QChar::ReplacementCharacter;
str += QChar(0x68);
str += QChar::ReplacementCharacter;
str += QChar::ReplacementCharacter;
str += QChar::ReplacementCharacter;
str += QChar::ReplacementCharacter;
str += QChar(0x61);
str += QChar::ReplacementCharacter;
QTest::newRow("invalid utf8") << QByteArray("hello\344h\344\344\366\344a\304") << str << -1;
QTest::newRow("invalid utf8-len") << QByteArray("hello\344h\344\344\366\344a\304") << QString("hello") << 5;
str = "Prohl";
str += QChar::ReplacementCharacter;
str += QChar::ReplacementCharacter;
str += "e";
str += QChar::ReplacementCharacter;
str += " plugin";
str += QChar::ReplacementCharacter;
str += " Netscape";
QTest::newRow("task28417") << QByteArray("Prohl\355\276e\350 plugin\371 Netscape") << str << -1;
QTest::newRow("task28417-len") << QByteArray("Prohl\355\276e\350 plugin\371 Netscape") << QString("") << 0;
QTest::newRow("null-1") << QByteArray() << QString() << -1;
QTest::newRow("null0") << QByteArray() << QString() << 0;
QTest::newRow("null5") << QByteArray() << QString() << 5;
QTest::newRow("empty-1") << QByteArray("\0abcd", 5) << QString() << -1;
QTest::newRow("empty0") << QByteArray() << QString() << 0;
QTest::newRow("empty5") << QByteArray("\0abcd", 5) << QString::fromAscii("\0abcd", 5) << 5;
QTest::newRow("other-1") << QByteArray("ab\0cd", 5) << QString::fromAscii("ab") << -1;
QTest::newRow("other5") << QByteArray("ab\0cd", 5) << QString::fromAscii("ab\0cd", 5) << 5;
str = "Old Italic: ";
str += QChar(0xd800);
str += QChar(0xdf00);
str += QChar(0xd800);
str += QChar(0xdf01);
str += QChar(0xd800);
str += QChar(0xdf02);
str += QChar(0xd800);
str += QChar(0xdf03);
str += QChar(0xd800);
str += QChar(0xdf04);
QTest::newRow("surrogate") << QByteArray("Old Italic: \360\220\214\200\360\220\214\201\360\220\214\202\360\220\214\203\360\220\214\204") << str << -1;
QTest::newRow("surrogate-len") << QByteArray("Old Italic: \360\220\214\200\360\220\214\201\360\220\214\202\360\220\214\203\360\220\214\204") << str.left(16) << 20;
}
void tst_QString::fromUtf8()
{
QFETCH(QByteArray, utf8);
QFETCH(QString, res);
QFETCH(int, len);
QCOMPARE(QString::fromUtf8(utf8.isNull() ? 0 : utf8.data(), len), res);
}
void tst_QString::nullFromUtf8()
{
QString a;
a = QString::fromUtf8(0);
QVERIFY(a.isNull());
QVERIFY(a.isEmpty());
a = QString::fromUtf8("");
QVERIFY(!a.isNull());
QVERIFY(a.isEmpty());
}
void tst_QString::fromLocal8Bit_data()
{
QTest::addColumn<QByteArray>("local8Bit");
QTest::addColumn<int>("len");
QTest::addColumn<QString>("result");
//QTest::newRow("nullString") << QByteArray() << -1 << QString();
//QTest::newRow("emptyString") << QByteArray("") << -1 << QString("");
//QTest::newRow("string") << QByteArray("test") << -1 << QString("test");
//QTest::newRow("stringlen0") << QByteArray("test") << 0 << QString("");
//QTest::newRow("stringlen3") << QByteArray("test") << 3 << QString("tes");
QTest::newRow("stringlen99") << QByteArray("test\0foo", 8) << 8 << QString::fromLatin1("test\0foo", 8);
QByteArray longQByteArray;
QString longQString;
for (int l=0;l<111;l++) {
longQByteArray = longQByteArray + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
longQString += "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
}
//QTest::newRow("longString") << longQByteArray << -1 << longQString;
//QTest::newRow("longStringlen0") << longQByteArray << 0 << QString("");
//QTest::newRow("longStringlen3") << longQByteArray << 3 << QString("aaa");
//QTest::newRow("someNonAlphaChars") << QByteArray("d:/this/is/a/test.h") << -1 << QString("d:/this/is/a/test.h");
//QTest::newRow("null-1") << QByteArray() << -1 << QString();
//QTest::newRow("null0") << QByteArray() << 0 << QString();
//QTest::newRow("null5") << QByteArray() << 5 << QString();
//QTest::newRow("empty-1") << QByteArray("\0abcd", 5) << -1 << QString();
//QTest::newRow("empty0") << QByteArray() << 0 << QString();
//QTest::newRow("empty5") << QByteArray("\0abcd", 5) << 5 << QString::fromAscii("\0abcd", 5);
//QTest::newRow("other-1") << QByteArray("ab\0cd", 5) << -1 << QString::fromAscii("ab");
//QTest::newRow("other5") << QByteArray("ab\0cd", 5) << 5 << QString::fromAscii("ab\0cd", 5);
}
void tst_QString::fromLocal8Bit()
{
QFETCH(QByteArray, local8Bit);
QFETCH(int, len);
QFETCH(QString, result);
QCOMPARE(QString::fromLocal8Bit(local8Bit.isNull() ? 0 : local8Bit.data(), len).length(),
result.length());
QCOMPARE(QString::fromLocal8Bit(local8Bit.isNull() ? 0 : local8Bit.data(), len), result);
}
void tst_QString::local8Bit_data()
{
QTest::addColumn<QString>("local8Bit");
QTest::addColumn<QByteArray>("result");
/*
QString::local8Bit() called on a null QString returns an _empty_
QByteArray.
*/
QTest::newRow("nullString") << QString() << QByteArray("");
QTest::newRow("emptyString") << QString("") << QByteArray("");
QTest::newRow("string") << QString("test") << QByteArray("test");
QByteArray longQByteArray;
QString longQString;
for (int l=0;l<111;l++) {
longQByteArray = longQByteArray + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
longQString += "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
}
QTest::newRow("longString") << longQString << longQByteArray;
QTest::newRow("someNonAlphaChars") << QString("d:/this/is/a/test.h") << QByteArray("d:/this/is/a/test.h");
}
void tst_QString::local8Bit()
{
QFETCH(QString, local8Bit);
QFETCH(QByteArray, result);
QCOMPARE(local8Bit.toLocal8Bit(), QByteArray(result));
}
void tst_QString::stringRef_local8Bit_data()
{
local8Bit_data();
}
void tst_QString::stringRef_local8Bit()
{
QFETCH(QString, local8Bit);
QFETCH(QByteArray, result);
QStringRef ref(&local8Bit, 0, local8Bit.length());
QCOMPARE(ref.toLocal8Bit(), QByteArray(result));
}
void tst_QString::fromLatin1Roundtrip_data()
{
QTest::addColumn<QByteArray>("latin1");
QTest::addColumn<QString>("unicode");
QTest::newRow("null") << QByteArray() << QString();
QTest::newRow("empty") << QByteArray("") << "";
static const ushort unicode1[] = { 'H', 'e', 'l', 'l', 'o', 1, '\r', '\n', 0x7f };
QTest::newRow("ascii-only") << QByteArray("Hello") << QString::fromUtf16(unicode1, 5);
QTest::newRow("ascii+control") << QByteArray("Hello\1\r\n\x7f") << QString::fromUtf16(unicode1, 9);
static const ushort unicode3[] = { 'a', 0, 'z' };
QTest::newRow("ascii+nul") << QByteArray("a\0z", 3) << QString::fromUtf16(unicode3, 3);
static const ushort unicode4[] = { 0x80, 0xc0, 0xff };
QTest::newRow("non-ascii") << QByteArray("\x80\xc0\xff") << QString::fromUtf16(unicode4, 3);
}
void tst_QString::fromLatin1Roundtrip()
{
QFETCH(QByteArray, latin1);
QFETCH(QString, unicode);
// QtTest safety check:
QCOMPARE(latin1.isNull(), unicode.isNull());
QCOMPARE(latin1.isEmpty(), unicode.isEmpty());
QCOMPARE(latin1.length(), unicode.length());
if (!latin1.isEmpty())
while (latin1.length() < 128) {
latin1 += latin1;
unicode += unicode;
}
// fromLatin1
QCOMPARE(QString::fromLatin1(latin1, latin1.length()).length(), unicode.length());
QCOMPARE(QString::fromLatin1(latin1, latin1.length()), unicode);
// and back:
QCOMPARE(unicode.toLatin1().length(), latin1.length());
QCOMPARE(unicode.toLatin1(), latin1);
}
void tst_QString::toLatin1Roundtrip_data()
{
QTest::addColumn<QByteArray>("latin1");
QTest::addColumn<QString>("unicodesrc");
QTest::addColumn<QString>("unicodedst");
QTest::newRow("null") << QByteArray() << QString() << QString();
QTest::newRow("empty") << QByteArray("") << "" << "";
static const ushort unicode1[] = { 'H', 'e', 'l', 'l', 'o', 1, '\r', '\n', 0x7f };
QTest::newRow("ascii-only") << QByteArray("Hello") << QString::fromUtf16(unicode1, 5) << QString::fromUtf16(unicode1, 5);
QTest::newRow("ascii+control") << QByteArray("Hello\1\r\n\x7f") << QString::fromUtf16(unicode1, 9) << QString::fromUtf16(unicode1, 9);
static const ushort unicode3[] = { 'a', 0, 'z' };
QTest::newRow("ascii+nul") << QByteArray("a\0z", 3) << QString::fromUtf16(unicode3, 3) << QString::fromUtf16(unicode3, 3);
static const ushort unicode4[] = { 0x80, 0xc0, 0xff };
QTest::newRow("non-ascii") << QByteArray("\x80\xc0\xff") << QString::fromUtf16(unicode4, 3) << QString::fromUtf16(unicode4, 3);
static const ushort unicodeq[] = { '?', '?', '?', '?', '?' };
const QString questionmarks = QString::fromUtf16(unicodeq, 5);
static const ushort unicode5[] = { 0x100, 0x101, 0x17f, 0x7f00, 0x7f7f };
QTest::newRow("non-latin1a") << QByteArray("?????") << QString::fromUtf16(unicode5, 5) << questionmarks;
static const ushort unicode6[] = { 0x180, 0x1ff, 0x8001, 0x8080, 0xfffc };
QTest::newRow("non-latin1b") << QByteArray("?????") << QString::fromUtf16(unicode6, 5) << questionmarks;
}
void tst_QString::toLatin1Roundtrip()
{
QFETCH(QByteArray, latin1);
QFETCH(QString, unicodesrc);
QFETCH(QString, unicodedst);
// QtTest safety check:
QCOMPARE(latin1.isNull(), unicodesrc.isNull());
QCOMPARE(latin1.isEmpty(), unicodesrc.isEmpty());
QCOMPARE(latin1.length(), unicodesrc.length());
QCOMPARE(latin1.isNull(), unicodedst.isNull());
QCOMPARE(latin1.isEmpty(), unicodedst.isEmpty());
QCOMPARE(latin1.length(), unicodedst.length());
if (!latin1.isEmpty())
while (latin1.length() < 128) {
latin1 += latin1;
unicodesrc += unicodesrc;
unicodedst += unicodedst;
}
// toLatin1
QCOMPARE(unicodesrc.toLatin1().length(), latin1.length());
QCOMPARE(unicodesrc.toLatin1(), latin1);
// and back:
QCOMPARE(QString::fromLatin1(latin1, latin1.length()).length(), unicodedst.length());
QCOMPARE(QString::fromLatin1(latin1, latin1.length()), unicodedst);
}
void tst_QString::stringRef_toLatin1Roundtrip_data()
{
toLatin1Roundtrip_data();
}
void tst_QString::stringRef_toLatin1Roundtrip()
{
QFETCH(QByteArray, latin1);
QFETCH(QString, unicodesrc);
QFETCH(QString, unicodedst);
// QtTest safety check:
QCOMPARE(latin1.isNull(), unicodesrc.isNull());
QCOMPARE(latin1.isEmpty(), unicodesrc.isEmpty());
QCOMPARE(latin1.length(), unicodesrc.length());
QCOMPARE(latin1.isNull(), unicodedst.isNull());
QCOMPARE(latin1.isEmpty(), unicodedst.isEmpty());
QCOMPARE(latin1.length(), unicodedst.length());
if (!latin1.isEmpty())
while (latin1.length() < 128) {
latin1 += latin1;
unicodesrc += unicodesrc;
unicodedst += unicodedst;
}
// toLatin1
QStringRef src(&unicodesrc, 0, unicodesrc.length());
QCOMPARE(src.toLatin1().length(), latin1.length());
QCOMPARE(src.toLatin1(), latin1);
}
void tst_QString::fromLatin1()
{
QString a;
a = QString::fromLatin1( 0 );
QVERIFY( a.isNull() );
QVERIFY( a.isEmpty() );
a = QString::fromLatin1( "" );
QVERIFY( !a.isNull() );
QVERIFY( a.isEmpty() );
a = QString::fromLatin1(0, 0);
QVERIFY(a.isNull());
a = QString::fromLatin1(0, 5);
QVERIFY(a.isNull());
a = QString::fromLatin1("\0abcd", 0);
QVERIFY(!a.isNull());
QVERIFY(a.isEmpty());
a = QString::fromLatin1("\0abcd", 5);
QVERIFY(a.size() == 5);
}
void tst_QString::fromAscii()
{
QString a;
a = QString::fromAscii( 0 );
QVERIFY( a.isNull() );
QVERIFY( a.isEmpty() );
a = QString::fromAscii( "" );
QVERIFY( !a.isNull() );
QVERIFY( a.isEmpty() );
a = QString::fromAscii(0, 0);
QVERIFY(a.isNull());
a = QString::fromAscii(0, 5);
QVERIFY(a.isNull());
a = QString::fromAscii("\0abcd", 0);
QVERIFY(!a.isNull());
QVERIFY(a.isEmpty());
a = QString::fromAscii("\0abcd", 5);
QVERIFY(a.size() == 5);
}
void tst_QString::arg()
{
/*
Warning: If any of these test fails, the warning given by QtTest
is all messed up, because QtTest itself uses QString::arg().
*/
QLocale::setDefault(QString("de_DE"));
QString s4( "[%0]" );
QString s5( "[%1]" );
QString s6( "[%3]" );
QString s7( "[%9]" );
QString s8( "[%0 %1]" );
QString s9( "[%0 %3]" );
QString s10( "[%1 %2 %3]" );
QString s11( "[%9 %3 %0]" );
QString s12( "[%9 %1 %3 %9 %0 %8]" );
QString s13( "%1% %x%c%2 %d%2-%" );
QString s14( "%1%2%3" );
QCOMPARE( s4.arg("foo"), QString("[foo]") );
QCOMPARE( s5.arg("foo"), QString("[foo]") );
QCOMPARE( s6.arg("foo"), QString("[foo]") );
QCOMPARE( s7.arg("foo"), QString("[foo]") );
QCOMPARE( s8.arg("foo"), QString("[foo %1]") );
QCOMPARE( s8.arg("foo").arg("bar"), QString("[foo bar]") );
QCOMPARE( s8.arg("foo", "bar"), QString("[foo bar]") );
QCOMPARE( s9.arg("foo"), QString("[foo %3]") );
QCOMPARE( s9.arg("foo").arg("bar"), QString("[foo bar]") );
QCOMPARE( s9.arg("foo", "bar"), QString("[foo bar]") );
QCOMPARE( s10.arg("foo"), QString("[foo %2 %3]") );
QCOMPARE( s10.arg("foo").arg("bar"), QString("[foo bar %3]") );
QCOMPARE( s10.arg("foo", "bar"), QString("[foo bar %3]") );
QCOMPARE( s10.arg("foo").arg("bar").arg("baz"), QString("[foo bar baz]") );
QCOMPARE( s10.arg("foo", "bar", "baz"), QString("[foo bar baz]") );
QCOMPARE( s11.arg("foo"), QString("[%9 %3 foo]") );
QCOMPARE( s11.arg("foo").arg("bar"), QString("[%9 bar foo]") );
QCOMPARE( s11.arg("foo", "bar"), QString("[%9 bar foo]") );
QCOMPARE( s11.arg("foo").arg("bar").arg("baz"), QString("[baz bar foo]") );
QCOMPARE( s11.arg("foo", "bar", "baz"), QString("[baz bar foo]") );
QCOMPARE( s12.arg("a").arg("b").arg("c").arg("d").arg("e"),
QString("[e b c e a d]") );
QCOMPARE( s12.arg("a", "b", "c", "d").arg("e"), QString("[e b c e a d]") );
QCOMPARE( s12.arg("a").arg("b", "c", "d", "e"), QString("[e b c e a d]") );
QCOMPARE( s13.arg("alpha").arg("beta"),
QString("alpha% %x%cbeta %dbeta-%") );
QCOMPARE( s13.arg("alpha", "beta"), QString("alpha% %x%cbeta %dbeta-%") );
QCOMPARE( s14.arg("a", "b", "c"), QString("abc") );
QCOMPARE( s8.arg("%1").arg("foo"), QString("[foo foo]") );
QCOMPARE( s8.arg("%1", "foo"), QString("[%1 foo]") );
QCOMPARE( s4.arg("foo", 2), QString("[foo]") );
QCOMPARE( s4.arg("foo", -2), QString("[foo]") );
QCOMPARE( s4.arg("foo", 10), QString("[ foo]") );
QCOMPARE( s4.arg("foo", -10), QString("[foo ]") );
QString firstName( "James" );
QString lastName( "Bond" );
QString fullName = QString( "My name is %2, %1 %2" )
.arg( firstName ).arg( lastName );
QCOMPARE( fullName, QString("My name is Bond, James Bond") );
// number overloads
QCOMPARE( s4.arg(0), QString("[0]") );
QCOMPARE( s4.arg(-1), QString("[-1]") );
QCOMPARE( s4.arg(4294967295UL), QString("[4294967295]") ); // ULONG_MAX 32
QCOMPARE( s4.arg(Q_INT64_C(9223372036854775807)), // LLONG_MAX
QString("[9223372036854775807]") );
QCOMPARE( QString().arg(0), QString() );
QCOMPARE( QString("").arg(0), QString("") );
QCOMPARE( QString(" ").arg(0), QString(" ") );
QCOMPARE( QString("%").arg(0), QString("%") );
QCOMPARE( QString("%%").arg(0), QString("%%") );
QCOMPARE( QString("%%%").arg(0), QString("%%%") );
QCOMPARE( QString("%%%1%%%2").arg("foo").arg("bar"), QString("%%foo%%bar") );
QCOMPARE( QString("%1").arg("hello", -10), QString("hello ") );
QCOMPARE( QString("%1").arg("hello", -5), QString("hello") );
QCOMPARE( QString("%1").arg("hello", -2), QString("hello") );
QCOMPARE( QString("%1").arg("hello", 0), QString("hello") );
QCOMPARE( QString("%1").arg("hello", 2), QString("hello") );
QCOMPARE( QString("%1").arg("hello", 5), QString("hello") );
QCOMPARE( QString("%1").arg("hello", 10), QString(" hello") );
QCOMPARE( QString("%1%1").arg("hello"), QString("hellohello") );
QCOMPARE( QString("%2%1").arg("hello"), QString("%2hello") );
QCOMPARE( QString("%1%1").arg(QString::null), QString("") );
QCOMPARE( QString("%2%1").arg(""), QString("%2") );
QCOMPARE( QString("%2 %L1").arg(12345.6789).arg(12345.6789),
QString("12345.7 12.345,7") );
QCOMPARE( QString("%2 %L1").arg(123456789).arg(123456789),
QString("123456789 123.456.789") );
QCOMPARE( QString("%L2 %L1 %3").arg(12345.7).arg(123456789).arg('c'),
QString("123.456.789 12.345,7 c") );
// multi-digit replacement
QString input("%%%L0 %1 %02 %3 %4 %5 %L6 %7 %8 %%% %090 %10 %11 %L12 %14 %L9888 %9999 %%%%%%%L");
input = input.arg("A").arg("B").arg("C")
.arg("D").arg("E").arg("f")
.arg("g").arg("h").arg("i").arg("j")
.arg("k").arg("l").arg("m")
.arg("n").arg("o").arg("p");
QCOMPARE(input, QString("%%A B C D E f g h i %%% j0 k l m n o88 p99 %%%%%%%L"));
QString str("%1 %2 %3 %4 %5 %6 %7 %8 %9 foo %10 %11 bar");
str = str.arg("one", "2", "3", "4", "5", "6", "7", "8", "9");
str = str.arg("ahoy", "there");
QCOMPARE(str, QString("one 2 3 4 5 6 7 8 9 foo ahoy there bar"));
QString str2("%123 %234 %345 %456 %567 %999 %1000 %1230");
str2 = str2.arg("A", "B", "C", "D", "E", "F");
QCOMPARE(str2, QString("A B C D E F %1000 %1230"));
// task 201185
QCOMPARE(QString("%1").arg(-1, 3, 10, QChar('0')), QString("-01"));
QCOMPARE(QString("%1").arg(-100, 3, 10, QChar('0')), QString("-100"));
QCOMPARE(QString("%1").arg(-1, 3, 10, QChar(' ')), QString(" -1"));
QCOMPARE(QString("%1").arg(-100, 3, 10, QChar(' ')), QString("-100"));
QCOMPARE(QString("%1").arg(1U, 3, 10, QChar(' ')), QString(" 1"));
QCOMPARE(QString("%1").arg(1000U, 3, 10, QChar(' ')), QString("1000"));
QCOMPARE(QString("%1").arg(-1, 3, 10, QChar('x')), QString("x-1"));
QCOMPARE(QString("%1").arg(-100, 3, 10, QChar('x')), QString("-100"));
QCOMPARE(QString("%1").arg(1U, 3, 10, QChar('x')), QString("xx1"));
QCOMPARE(QString("%1").arg(1000U, 3, 10, QChar('x')), QString("1000"));
QCOMPARE(QString("%1").arg(-1., 3, 'g', -1, QChar('0')), QString("-01"));
QCOMPARE(QString("%1").arg(-100., 3, 'g', -1, QChar('0')), QString("-100"));
QCOMPARE(QString("%1").arg(-1., 3, 'g', -1, QChar(' ')), QString(" -1"));
QCOMPARE(QString("%1").arg(-100., 3, 'g', -1, QChar(' ')), QString("-100"));
QCOMPARE(QString("%1").arg(1., 3, 'g', -1, QChar('x')), QString("xx1"));
QCOMPARE(QString("%1").arg(1000., 3, 'g', -1, QChar('x')), QString("1000"));
QCOMPARE(QString("%1").arg(-1., 3, 'g', -1, QChar('x')), QString("x-1"));
QCOMPARE(QString("%1").arg(-100., 3, 'g', -1, QChar('x')), QString("-100"));
}
void tst_QString::number()
{
QCOMPARE( QString::number(int(0)), QString("0") );
QCOMPARE( QString::number((unsigned int)(11)), QString("11") );
QCOMPARE( QString::number(-22L), QString("-22") );
QCOMPARE( QString::number(333UL), QString("333") );
QCOMPARE( QString::number(4.4), QString("4.4") );
QCOMPARE( QString::number(Q_INT64_C(-555)), QString("-555") );
QCOMPARE( QString::number(Q_UINT64_C(6666)), QString("6666") );
}
void tst_QString::capacity_data()
{
length_data();
}
void tst_QString::capacity()
{
QFETCH( QString, s1 );
QFETCH( int, res );
QString s2( s1 );
s2.reserve( res );
QVERIFY( (int)s2.capacity() >= res );
QCOMPARE( s2, s1 );
s2.reserve( res * 2 );
QVERIFY( (int)s2.capacity() >= res * 2 );
QCOMPARE( s2, s1 );
s2.squeeze();
QVERIFY( (int)s2.capacity() == res );
QCOMPARE( s2, s1 );
}
void tst_QString::section_data()
{
QTest::addColumn<QString>("wholeString" );
QTest::addColumn<QString>("sep" );
QTest::addColumn<int>("start" );
QTest::addColumn<int>("end" );
QTest::addColumn<int>("flags" );
QTest::addColumn<QString>("sectionString" );
QTest::addColumn<bool>("regexp" );
QTest::newRow( "data0" ) << QString("forename,middlename,surname,phone") << QString(",") << 2 << 2 << int(QString::SectionDefault) << QString("surname") << false;
QTest::newRow( "data1" ) << QString("/usr/local/bin/myapp") << QString("/") << 3 << 4 << int(QString::SectionDefault) << QString("bin/myapp") << false;
QTest::newRow( "data2" ) << QString("/usr/local/bin/myapp") << QString("/") << 3 << 3 << int(QString::SectionSkipEmpty) << QString("myapp") << false;
QTest::newRow( "data3" ) << QString("forename**middlename**surname**phone") << QString("**") << 2 << 2 << int(QString::SectionDefault) << QString("surname") << false;
QTest::newRow( "data4" ) << QString("forename**middlename**surname**phone") << QString("**") << -3 << -2 << int(QString::SectionDefault) << QString("middlename**surname") << false;
QTest::newRow( "task-21749-1" ) << QString("##Datt######wollen######wir######mal######sehen##") << QString("#") << 0 << 0 << int(QString::SectionSkipEmpty) << QString("Datt") << false;
QTest::newRow( "task-21749-2" ) << QString("##Datt######wollen######wir######mal######sehen##") << QString("#") << 1 << 1 << int(QString::SectionSkipEmpty) << QString("wollen") << false;
QTest::newRow( "task-21749-3" ) << QString("##Datt######wollen######wir######mal######sehen##") << QString("#") << 2 << 2 << int(QString::SectionSkipEmpty) << QString("wir") << false;
QTest::newRow( "task-21749-4" ) << QString("##Datt######wollen######wir######mal######sehen##") << QString("#") << 3 << 3 << int(QString::SectionSkipEmpty) << QString("mal") << false;
QTest::newRow( "task-21749-5" ) << QString("##Datt######wollen######wir######mal######sehen##") << QString("#") << 4 << 4 << int(QString::SectionSkipEmpty) << QString("sehen") << false;
// not fixed for 3.1
QTest::newRow( "task-27269" ) << QString("a/b/c/d") << QString("/") << 1 << -1 << int(QString::SectionIncludeLeadingSep | QString::SectionIncludeTrailingSep) << QString("/b/c/d") << false;
QTest::newRow( "task-43641" ) << QString("aoLoboLocolod") << QString("olo") << -1 << -1 << int(QString::SectionCaseInsensitiveSeps) << QString("d") << false;
QTest::newRow( "task-27593" ) << QString("F0") << QString("F") << 0 << 0 << int(QString::SectionSkipEmpty) << QString("0") << false;
QTest::newRow( "foo1" ) << QString("foo;foo;") << QString(";") << 0 << 0
<< int(QString::SectionIncludeLeadingSep) << QString("foo") << false;
QTest::newRow( "foo2" ) << QString("foo;foo;") << QString(";") << 1 << 1
<< int(QString::SectionIncludeLeadingSep) << QString(";foo") << false;
QTest::newRow( "foo3" ) << QString("foo;foo;") << QString(";") << 2 << 2
<< int(QString::SectionIncludeLeadingSep) << QString(";") << false;
QTest::newRow( "foo1rx" ) << QString("foo;foo;") << QString(";") << 0 << 0
<< int(QString::SectionIncludeLeadingSep) << QString("foo") << true;
QTest::newRow( "foo2rx" ) << QString("foo;foo;") << QString(";") << 1 << 1
<< int(QString::SectionIncludeLeadingSep) << QString(";foo") << true;
QTest::newRow( "foo3rx" ) << QString("foo;foo;") << QString(";") << 2 << 2
<< int(QString::SectionIncludeLeadingSep) << QString(";") << true;
QTest::newRow( "qmake_path" ) << QString("/Users/sam/troll/qt4.0/src/corelib/QtCore_debug.xcode/")
<< QString("/") << 0 << -2 << int(QString::SectionDefault)
<< QString("/Users/sam/troll/qt4.0/src/corelib/QtCore_debug.xcode") << false;
QTest::newRow( "qmake_pathrx" ) << QString("/Users/sam/troll/qt4.0/src/corelib/QtCore_debug.xcode/")
<< QString("/") << 0 << -2 << int(QString::SectionDefault)
<< QString("/Users/sam/troll/qt4.0/src/corelib/QtCore_debug.xcode") << true;
QTest::newRow( "task72972" ) << QString("||2|3|||")
<< QString("|") << 0 << 1 << int(QString::SectionIncludeLeadingSep|QString::SectionIncludeTrailingSep)
<< QString("||") << false;
QTest::newRow( "task72972rx" ) << QString("||2|3|||")
<< QString("\\|") << 0 << 1 << int(QString::SectionIncludeLeadingSep|QString::SectionIncludeTrailingSep)
<< QString("||") << true;
QTest::newRow( "task72972-2" ) << QString("|1|2|")
<< QString("|") << 0 << 1 << int(QString::SectionIncludeLeadingSep|QString::SectionIncludeTrailingSep)
<< QString("|1|") << false;
QTest::newRow( "task72972-2rx" ) << QString("|1|2|")
<< QString("\\|") << 0 << 1
<< int(QString::SectionIncludeLeadingSep|QString::SectionIncludeTrailingSep)
<< QString("|1|") << true;
QTest::newRow( "normal1" ) << QString("o1o2o")
<< QString("o") << 0 << 0
<< int(QString::SectionIncludeLeadingSep|QString::SectionIncludeTrailingSep)
<< QString("o") << false;
QTest::newRow( "normal2" ) << QString("o1o2o")
<< QString("o") << 1 << 1
<< int(QString::SectionIncludeLeadingSep|QString::SectionIncludeTrailingSep)
<< QString("o1o") << false;
QTest::newRow( "normal3" ) << QString("o1o2o")
<< QString("o") << 2 << 2
<< int(QString::SectionIncludeLeadingSep|QString::SectionIncludeTrailingSep)
<< QString("o2o") << false;
QTest::newRow( "normal4" ) << QString("o1o2o")
<< QString("o") << 2 << 3
<< int(QString::SectionIncludeLeadingSep|QString::SectionIncludeTrailingSep)
<< QString("o2o") << false;
QTest::newRow( "normal5" ) << QString("o1o2o")
<< QString("o") << 1 << 2
<< int(QString::SectionIncludeLeadingSep|QString::SectionIncludeTrailingSep)
<< QString("o1o2o") << false;
QTest::newRow( "rx1" ) << QString("o1o2o")
<< QString("[a-z]") << 0 << 0
<< int(QString::SectionIncludeLeadingSep|QString::SectionIncludeTrailingSep)
<< QString("o") << true;
QTest::newRow( "rx2" ) << QString("o1o2o")
<< QString("[a-z]") << 1 << 1
<< int(QString::SectionIncludeLeadingSep|QString::SectionIncludeTrailingSep)
<< QString("o1o") << true;
QTest::newRow( "rx3" ) << QString("o1o2o")
<< QString("[a-z]") << 2 << 2
<< int(QString::SectionIncludeLeadingSep|QString::SectionIncludeTrailingSep)
<< QString("o2o") << true;
QTest::newRow( "rx4" ) << QString("o1o2o")
<< QString("[a-z]") << 2 << 3
<< int(QString::SectionIncludeLeadingSep|QString::SectionIncludeTrailingSep)
<< QString("o2o") << true;
QTest::newRow( "rx5" ) << QString("o1o2o")
<< QString("[a-z]") << 1 << 2
<< int(QString::SectionIncludeLeadingSep|QString::SectionIncludeTrailingSep)
<< QString("o1o2o") << true;
QTest::newRow( "task45855-rx" ) << QString("This is a story, a small story")
<< QString("\\b") << 3 << 3
<< int(QString::SectionDefault)
<< QString("is") << true;
QTest::newRow( "task257941-rx" ) << QString("99.0 42.3")
<< QString("\\s*[AaBb]\\s*") << 1 << 1
<< int(QString::SectionIncludeLeadingSep)
<< QString() << true;
}
void tst_QString::section()
{
QFETCH( QString, wholeString );
QFETCH( QString, sep );
QFETCH( int, start );
QFETCH( int, end );
QFETCH( int, flags );
QFETCH( QString, sectionString );
QFETCH( bool, regexp );
if (regexp) {
QCOMPARE( wholeString.section( QRegExp(sep), start, end, QString::SectionFlag(flags) ), sectionString );
} else {
QCOMPARE( wholeString.section( sep, start, end, QString::SectionFlag(flags) ), sectionString );
}
}
void tst_QString::operator_eqeq_nullstring()
{
/* Some of these might not be all that logical but it's the behaviour we've had since 3.0.0
so we should probably stick with it. */
QVERIFY( QString() == "" );
QVERIFY( "" == QString() );
QVERIFY( QString("") == "" );
QVERIFY( "" == QString("") );
QVERIFY( QString().size() == 0 );
QVERIFY( QString("").size() == 0 );
QVERIFY( QString() == QString("") );
QVERIFY( QString("") == QString() );
}
void tst_QString::operator_smaller()
{
QString null;
QString empty("");
QString foo("foo");
QVERIFY( !(null < QString()) );
QVERIFY( !(null > QString()) );
QVERIFY( !(empty < QString("")) );
QVERIFY( !(empty > QString("")) );
QVERIFY( !(null < empty) );
QVERIFY( !(null > empty) );
QVERIFY( null < foo );
QVERIFY( !(null > foo) );
QVERIFY( foo > null );
QVERIFY( !(foo < null) );
QVERIFY( empty < foo );
QVERIFY( !(empty > foo) );
QVERIFY( foo > empty );
QVERIFY( !(foo < empty) );
QVERIFY( !(null < QLatin1String(0)) );
QVERIFY( !(null > QLatin1String(0)) );
QVERIFY( !(null < QLatin1String("")) );
QVERIFY( !(null > QLatin1String("")) );
QVERIFY( !(null < QLatin1String("")) );
QVERIFY( !(null > QLatin1String("")) );
QVERIFY( !(empty < QLatin1String("")) );
QVERIFY( !(empty > QLatin1String("")) );
QVERIFY( !(QLatin1String(0) < null) );
QVERIFY( !(QLatin1String(0) > null) );
QVERIFY( !(QLatin1String("") < null) );
QVERIFY( !(QLatin1String("") > null) );
QVERIFY( !(QLatin1String(0) < empty) );
QVERIFY( !(QLatin1String(0) > empty) );
QVERIFY( !(QLatin1String("") < empty) );
QVERIFY( !(QLatin1String("") > empty) );
QVERIFY( QLatin1String(0) < foo );
QVERIFY( !(QLatin1String(0) > foo) );
QVERIFY( QLatin1String("") < foo );
QVERIFY( !(QLatin1String("") > foo) );
QVERIFY( foo > QLatin1String(0) );
QVERIFY( !(foo < QLatin1String(0)) );
QVERIFY( foo > QLatin1String("") );
QVERIFY( !(foo < QLatin1String("")) );
QVERIFY( QLatin1String(0) == empty);
QVERIFY( QLatin1String(0) == null);
QVERIFY( QLatin1String("") == empty);
QVERIFY( QLatin1String("") == null);
QVERIFY( !(foo < QLatin1String("foo")));
QVERIFY( !(foo > QLatin1String("foo")));
QVERIFY( !(QLatin1String("foo") < foo));
QVERIFY( !(QLatin1String("foo") > foo));
QVERIFY( !(foo < QLatin1String("a")));
QVERIFY( (foo > QLatin1String("a")));
QVERIFY( (QLatin1String("a") < foo));
QVERIFY( !(QLatin1String("a") > foo));
QVERIFY( (foo < QLatin1String("z")));
QVERIFY( !(foo > QLatin1String("z")));
QVERIFY( !(QLatin1String("z") < foo));
QVERIFY( (QLatin1String("z") > foo));
}
void tst_QString::integer_conversion_data()
{
QTest::addColumn<QString>("locale_name");
QTest::addColumn<QString>("num_str");
QTest::addColumn<int>("base");
QTest::addColumn<bool>("good");
QTest::addColumn<qlonglong>("num");
QTest::newRow("C empty 0") << QString("C") << QString("") << 0 << false << (qlonglong)0;
QTest::newRow("C empty 8") << QString("C") << QString("") << 8 << false << (qlonglong)0;
QTest::newRow("C empty 10") << QString("C") << QString("") << 10 << false << (qlonglong)0;
QTest::newRow("C empty 16") << QString("C") << QString("") << 16 << false << (qlonglong)0;
QTest::newRow("C null 0") << QString("C") << QString() << 0 << false << (qlonglong)0;
QTest::newRow("C null 8") << QString("C") << QString() << 8 << false << (qlonglong)0;
QTest::newRow("C null 10") << QString("C") << QString() << 10 << false << (qlonglong)0;
QTest::newRow("C null 16") << QString("C") << QString() << 16 << false << (qlonglong)0;
QTest::newRow("C -0xf 0") << QString("C") << QString(" -0xf") << 0 << true << (qlonglong)-15;
QTest::newRow("C -0xf 0") << QString("C") << QString("-0xf ") << 0 << true << (qlonglong)-15;
QTest::newRow("C \t0xf\t 0") << QString("C") << QString("\t0xf\t") << 0 << true << (qlonglong)15;
QTest::newRow("C -010 0") << QString("C") << QString(" -010") << 0 << true << (qlonglong)-8;
QTest::newRow("C 010 0") << QString("C") << QString("010 ") << 0 << true << (qlonglong)8;
QTest::newRow("C \t-010\t 0") << QString("C") << QString("\t-010\t") << 0 << true << (qlonglong)-8;
QTest::newRow("C 123 10") << QString("C") << QString(" 123") << 10 << true << (qlonglong)123;
QTest::newRow("C 123 10") << QString("C") << QString("123 ") << 10 << true << (qlonglong)123;
QTest::newRow("C \t123\t 10") << QString("C") << QString("\t123\t") << 10 << true << (qlonglong)123;
QTest::newRow("C -0xf 16") << QString("C") << QString(" -0xf") << 16 << true << (qlonglong)-15;
QTest::newRow("C -0xf 16") << QString("C") << QString("-0xf ") << 16 << true << (qlonglong)-15;
QTest::newRow("C \t0xf\t 16") << QString("C") << QString("\t0xf\t") << 16 << true << (qlonglong)15;
QTest::newRow("C -0 0") << QString("C") << QString("-0") << 0 << true << (qlonglong)0;
QTest::newRow("C -0 8") << QString("C") << QString("-0") << 8 << true << (qlonglong)0;
QTest::newRow("C -0 10") << QString("C") << QString("-0") << 10 << true << (qlonglong)0;
QTest::newRow("C -0 16") << QString("C") << QString("-0") << 16 << true << (qlonglong)0;
QTest::newRow("C 1.234 10") << QString("C") << QString("1.234") << 10 << false << (qlonglong)0;
QTest::newRow("C 1,234 10") << QString("C") << QString("1,234") << 10 << false << (qlonglong)0;
QTest::newRow("de_DE 1.234 10") << QString("de_DE") << QString("1.234") << 10 << false << (qlonglong)0;
QTest::newRow("de_DE 1,234 10") << QString("de_DE") << QString("1,234") << 10 << false << (qlonglong)0;
QTest::newRow("C 0x 0") << QString("C") << QString("0x") << 0 << false << (qlonglong)0;
QTest::newRow("C 0x 16") << QString("C") << QString("0x") << 16 << false << (qlonglong)0;
QTest::newRow("C 10 0") << QString("C") << QString("10") << 0 << true << (qlonglong)10;
QTest::newRow("C 010 0") << QString("C") << QString("010") << 0 << true << (qlonglong)8;
QTest::newRow("C 0x10 0") << QString("C") << QString("0x10") << 0 << true << (qlonglong)16;
QTest::newRow("C 10 8") << QString("C") << QString("10") << 8 << true << (qlonglong)8;
QTest::newRow("C 010 8") << QString("C") << QString("010") << 8 << true << (qlonglong)8;
QTest::newRow("C 0x10 8") << QString("C") << QString("0x10") << 8 << false << (qlonglong)0;
QTest::newRow("C 10 10") << QString("C") << QString("10") << 10 << true << (qlonglong)10;
QTest::newRow("C 010 10") << QString("C") << QString("010") << 10 << true << (qlonglong)10;
QTest::newRow("C 0x10 10") << QString("C") << QString("0x10") << 10 << false << (qlonglong)0;
QTest::newRow("C 10 16") << QString("C") << QString("10") << 16 << true << (qlonglong)16;
QTest::newRow("C 010 16") << QString("C") << QString("010") << 16 << true << (qlonglong)16;
QTest::newRow("C 0x10 16") << QString("C") << QString("0x10") << 16 << true << (qlonglong)16;
QTest::newRow("de_DE 10 0") << QString("de_DE") << QString("10") << 0 << true << (qlonglong)10;
QTest::newRow("de_DE 010 0") << QString("de_DE") << QString("010") << 0 << true << (qlonglong)8;
QTest::newRow("de_DE 0x10 0") << QString("de_DE") << QString("0x10") << 0 << true << (qlonglong)16;
QTest::newRow("de_DE 10 8") << QString("de_DE") << QString("10") << 8 << true << (qlonglong)8;
QTest::newRow("de_DE 010 8") << QString("de_DE") << QString("010") << 8 << true << (qlonglong)8;
QTest::newRow("de_DE 0x10 8") << QString("de_DE") << QString("0x10") << 8 << false << (qlonglong)0;
QTest::newRow("de_DE 10 10") << QString("de_DE") << QString("10") << 10 << true << (qlonglong)10;
QTest::newRow("de_DE 010 10") << QString("de_DE") << QString("010") << 10 << true << (qlonglong)10;
QTest::newRow("de_DE 0x10 10") << QString("de_DE") << QString("0x10") << 10 << false << (qlonglong)0;
QTest::newRow("de_DE 10 16") << QString("de_DE") << QString("10") << 16 << true << (qlonglong)16;
QTest::newRow("de_DE 010 16") << QString("de_DE") << QString("010") << 16 << true << (qlonglong)16;
QTest::newRow("de_DE 0x10 16") << QString("de_DE") << QString("0x10") << 16 << true << (qlonglong)16;
QTest::newRow("C -10 0") << QString("C") << QString("-10") << 0 << true << (qlonglong)-10;
QTest::newRow("C -010 0") << QString("C") << QString("-010") << 0 << true << (qlonglong)-8;
QTest::newRow("C -0x10 0") << QString("C") << QString("-0x10") << 0 << true << (qlonglong)-16;
QTest::newRow("C -10 8") << QString("C") << QString("-10") << 8 << true << (qlonglong)-8;
QTest::newRow("C -010 8") << QString("C") << QString("-010") << 8 << true << (qlonglong)-8;
QTest::newRow("C -0x10 8") << QString("C") << QString("-0x10") << 8 << false << (qlonglong)0;
QTest::newRow("C -10 10") << QString("C") << QString("-10") << 10 << true << (qlonglong)-10;
QTest::newRow("C -010 10") << QString("C") << QString("-010") << 10 << true << (qlonglong)-10;
QTest::newRow("C -0x10 10") << QString("C") << QString("-0x10") << 10 << false << (qlonglong)0;
QTest::newRow("C -10 16") << QString("C") << QString("-10") << 16 << true << (qlonglong)-16;
QTest::newRow("C -010 16") << QString("C") << QString("-010") << 16 << true << (qlonglong)-16;
QTest::newRow("C -0x10 16") << QString("C") << QString("-0x10") << 16 << true << (qlonglong)-16;
// Let's try some Arabic
const quint16 arabic_str[] = { 0x0661, 0x0662, 0x0663, 0x0664, 0x0000 }; // "1234"
QTest::newRow("ar_SA 1234 0") << QString("ar_SA") << QString::fromUtf16(arabic_str) << 0 << true << (qlonglong)1234;
QTest::newRow("ar_SA 1234 8") << QString("ar_SA") << QString::fromUtf16(arabic_str) << 8 << true << (qlonglong)668;
QTest::newRow("ar_SA 1234 10") << QString("ar_SA") << QString::fromUtf16(arabic_str) << 10 << true << (qlonglong)1234;
QTest::newRow("ar_SA 1234 16") << QString("ar_SA") << QString::fromUtf16(arabic_str) << 16 << true << (qlonglong)4660;
}
void tst_QString::integer_conversion()
{
QFETCH(QString, locale_name);
QFETCH(QString, num_str);
QFETCH(int, base);
QFETCH(bool, good);
QFETCH(qlonglong, num);
QLocale::setDefault(locale_name);
QCOMPARE(QLocale().name(), locale_name);
bool ok;
qlonglong d = num_str.toLongLong(&ok, base);
QCOMPARE(ok, good);
if (ok) {
QCOMPARE(d, num);
}
QLocale::setDefault(QLocale::C);
}
void tst_QString::double_conversion_data()
{
QTest::addColumn<QString>("locale_name");
QTest::addColumn<QString>("num_str");
QTest::addColumn<bool>("good");
QTest::addColumn<double>("num");
/*
// The good...
QTest::newRow("C 1") << QString("C") << QString("1") << true << 1.0;
QTest::newRow("C 1.0") << QString("C") << QString("1.0") << true << 1.0;
QTest::newRow("C 1.234") << QString("C") << QString("1.234") << true << 1.234;
QTest::newRow("C 1.234e-10") << QString("C") << QString("1.234e-10") << true << 1.234e-10;
QTest::newRow("C 1.234E10") << QString("C") << QString("1.234E10") << true << 1.234e10;
QTest::newRow("C 1e10") << QString("C") << QString("1e10") << true << 1.0e10;
// The bad...
QTest::newRow("C empty") << QString("C") << QString("") << false << 0.0;
QTest::newRow("C null") << QString("C") << QString() << false << 0.0;
QTest::newRow("C .") << QString("C") << QString(".") << false << 0.0;
QTest::newRow("C 1e") << QString("C") << QString("1e") << false << 0.0;
QTest::newRow("C 1,") << QString("C") << QString("1,") << false << 0.0;
QTest::newRow("C 1,0") << QString("C") << QString("1,0") << false << 0.0;
QTest::newRow("C 1,000") << QString("C") << QString("1,000") << false << 0.0;
QTest::newRow("C 1e1.0") << QString("C") << QString("1e1.0") << false << 0.0;
QTest::newRow("C 1e+") << QString("C") << QString("1e+") << false << 0.0;
QTest::newRow("C 1e-") << QString("C") << QString("1e-") << false << 0.0;
// And the ugly...
QTest::newRow("C .1") << QString("C") << QString(".1") << true << 0.1;
QTest::newRow("C -.1") << QString("C") << QString("-.1") << true << -0.1;
QTest::newRow("C 1.") << QString("C") << QString("1.") << true << 1.0;
QTest::newRow("C 1.E10") << QString("C") << QString("1.E10") << true << 1.0e10;
QTest::newRow("C 1e+10") << QString("C") << QString("1e+10") << true << 1.0e+10;
QTest::newRow("de_DE 1") << QString("de_DE") << QString("1") << true << 1.0;
QTest::newRow("de_DE 1.0") << QString("de_DE") << QString("1.0") << true << 1.0;
QTest::newRow("de_DE 1.234") << QString("de_DE") << QString("1.234") << true << 1.234;
QTest::newRow("de_DE 1.234e-10") << QString("de_DE") << QString("1.234e-10") << true << 1.234e-10;
QTest::newRow("de_DE 1.234E10") << QString("de_DE") << QString("1.234E10") << true << 1.234e10;
QTest::newRow("de_DE 1e10") << QString("de_DE") << QString("1e10") << true << 1.0e10;
QTest::newRow("de_DE .1") << QString("de_DE") << QString(".1") << true << 0.1;
QTest::newRow("de_DE -.1") << QString("de_DE") << QString("-.1") << true << -0.1;
QTest::newRow("de_DE 1.") << QString("de_DE") << QString("1.") << true << 1.0;
QTest::newRow("de_DE 1.E10") << QString("de_DE") << QString("1.E10") << true << 1.0e10;
QTest::newRow("de_DE 1e+10") << QString("de_DE") << QString("1e+10") << true << 1.0e+10;
QTest::newRow("de_DE 1,0") << QString("de_DE") << QString("1,0") << true << 1.0;
QTest::newRow("de_DE 1,234") << QString("de_DE") << QString("1,234") << true << 1.234;
QTest::newRow("de_DE 1,234e-10") << QString("de_DE") << QString("1,234e-10") << true << 1.234e-10;
QTest::newRow("de_DE 1,234E10") << QString("de_DE") << QString("1,234E10") << true << 1.234e10;
QTest::newRow("de_DE ,1") << QString("de_DE") << QString(",1") << true << 0.1;
QTest::newRow("de_DE -,1") << QString("de_DE") << QString("-,1") << true << -0.1;
QTest::newRow("de_DE 1,") << QString("de_DE") << QString("1,") << true << 1.0;
QTest::newRow("de_DE 1,E10") << QString("de_DE") << QString("1,E10") << true << 1.0e10;
QTest::newRow("de_DE empty") << QString("de_DE") << QString("") << false << 0.0;
QTest::newRow("de_DE null") << QString("de_DE") << QString() << false << 0.0;
QTest::newRow("de_DE .") << QString("de_DE") << QString(".") << false << 0.0;
QTest::newRow("de_DE 1e") << QString("de_DE") << QString("1e") << false << 0.0;
QTest::newRow("de_DE 1e1.0") << QString("de_DE") << QString("1e1.0") << false << 0.0;
QTest::newRow("de_DE 1e+") << QString("de_DE") << QString("1e+") << false << 0.0;
QTest::newRow("de_DE 1e-") << QString("de_DE") << QString("1e-") << false << 0.0;
QTest::newRow("C 1") << QString("C") << QString(" 1") << true << 1.0;
QTest::newRow("C 1 ") << QString("C") << QString("1 ") << true << 1.0;
QTest::newRow("de_DE 1") << QString("de_DE") << QString(" 1") << true << 1.0;
QTest::newRow("de_DE 1 ") << QString("de_DE") << QString("1 ") << true << 1.0;
*/
// Let's try some Arabic
const quint16 arabic_str[] = { 0x0660, 0x066B, 0x0661, 0x0662,
0x0663, 0x0664, 0x0065, 0x0662,
0x0000 }; // "0.1234e2"
QTest::newRow("ar_SA") << QString("ar_SA") << QString::fromUtf16(arabic_str) << true << 0.1234e2;
}
void tst_QString::double_conversion()
{
#define MY_DOUBLE_EPSILON (2.22045e-16)
QFETCH(QString, locale_name);
QFETCH(QString, num_str);
QFETCH(bool, good);
QFETCH(double, num);
QLocale::setDefault(locale_name);
QCOMPARE(QLocale().name(), locale_name);
bool ok;
double d = num_str.toDouble(&ok);
QCOMPARE(ok, good);
if (ok) {
double diff = d - num;
if (diff < 0)
diff = -diff;
QVERIFY(diff <= MY_DOUBLE_EPSILON);
}
QLocale::setDefault(QLocale::C);
}
#ifndef Q_MOC_RUN
#include "double_data.h"
#endif
void tst_QString::tortureSprintfDouble()
{
const SprintfDoubleData *data = g_sprintf_double_data;
QString s;
for (; data->fmt != 0; ++data) {
double d;
char *buff = (char *)&d;
# ifndef Q_BYTE_ORDER
# error "Q_BYTE_ORDER not defined"
# endif
# ifdef QT_ARMFPA
buff[0] = data->bytes[4];
buff[1] = data->bytes[5];
buff[2] = data->bytes[6];
buff[3] = data->bytes[7];
buff[4] = data->bytes[0];
buff[5] = data->bytes[1];
buff[6] = data->bytes[2];
buff[7] = data->bytes[3];
# elif Q_BYTE_ORDER == Q_LITTLE_ENDIAN
for (uint i = 0; i < 8; ++i)
buff[i] = data->bytes[i];
# else
for (uint i = 0; i < 8; ++i)
buff[7 - i] = data->bytes[i];
# endif
s.sprintf(data->fmt, d);
#ifdef QT_NO_FPU // reduced precision when running with hardfloats in qemu
if (d - 0.1 < 1e12)
QSKIP("clib sprintf doesn't fill with 0's on this platform",
SkipSingle);
QCOMPARE(s.left(16), QString(data->expected).left(16));
#else
QCOMPARE(s, QString(data->expected));
#endif
}
}
#include <locale.h>
void tst_QString::localeAwareCompare_data()
{
#ifdef Q_OS_WIN
QTest::addColumn<ulong>("locale");
#else
QTest::addColumn<QString>("locale");
#endif
QTest::addColumn<QString>("s1");
QTest::addColumn<QString>("s2");
QTest::addColumn<int>("result");
/*
The C locale performs pure byte comparisons for
Latin-1-specific characters (I think). Compare with Swedish
below.
*/
#ifdef Q_OS_WIN // assume c locale to be english
QTest::newRow("c1") << MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT) << QString("\xe5") << QString("\xe4") << 1;
QTest::newRow("c2") << MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT) << QString("\xe4") << QString("\xf6") << -1;
QTest::newRow("c3") << MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT) << QString("\xe5") << QString("\xf6") << -1;
#else
QTest::newRow("c1") << QString("C") << QString("\xe5") << QString("\xe4") << 1;
QTest::newRow("c2") << QString("C") << QString("\xe4") << QString("\xf6") << -1;
QTest::newRow("c3") << QString("C") << QString("\xe5") << QString("\xf6") << -1;
#endif
/*
It's hard to test English, because it's treated differently
on different platforms. For example, on Linux, it uses the
iso14651_t1 template file, which happens to provide good
defaults for Swedish. Mac OS X seems to do a pure bytewise
comparison of Latin-1 values, although I'm not sure. So I
just test digits to make sure that it's not totally broken.
*/
#ifdef Q_OS_WIN
QTest::newRow("english1") << MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT) << QString("5") << QString("4") << 1;
QTest::newRow("english2") << MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT) << QString("4") << QString("6") << -1;
QTest::newRow("english3") << MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT) << QString("5") << QString("6") << -1;
#else
QTest::newRow("english1") << QString("en_US") << QString("5") << QString("4") << 1;
QTest::newRow("english2") << QString("en_US") << QString("4") << QString("6") << -1;
QTest::newRow("english3") << QString("en_US") << QString("5") << QString("6") << -1;
#endif
/*
In Swedish, a with ring above (E5) comes before a with
diaresis (E4), which comes before o diaresis (F6), which
all come after z.
*/
#ifdef Q_OS_MAC
QTest::newRow("swedish1") << QString("sv_SE.ISO8859-1") << QString("\xe5") << QString("\xe4") << -1;
QTest::newRow("swedish2") << QString("sv_SE.ISO8859-1") << QString("\xe4") << QString("\xf6") << -1;
QTest::newRow("swedish3") << QString("sv_SE.ISO8859-1") << QString("\xe5") << QString("\xf6") << -1;
QTest::newRow("swedish4") << QString("sv_SE.ISO8859-1") << QString("z") << QString("\xe5") << -1;
#elif defined(Q_OS_WIN)
QTest::newRow("swedish1") << MAKELCID(MAKELANGID(LANG_SWEDISH, SUBLANG_SWEDISH), SORT_DEFAULT) << QString("\xe5") << QString("\xe4") << -1;
QTest::newRow("swedish2") << MAKELCID(MAKELANGID(LANG_SWEDISH, SUBLANG_SWEDISH), SORT_DEFAULT) << QString("\xe4") << QString("\xf6") << -1;
QTest::newRow("swedish3") << MAKELCID(MAKELANGID(LANG_SWEDISH, SUBLANG_SWEDISH), SORT_DEFAULT) << QString("\xe5") << QString("\xf6") << -1;
QTest::newRow("swedish4") << MAKELCID(MAKELANGID(LANG_SWEDISH, SUBLANG_SWEDISH), SORT_DEFAULT) << QString("z") << QString("\xe5") << -1;
#else
QTest::newRow("swedish1") << QString("sv_SE") << QString("\xe5") << QString("\xe4") << -1;
QTest::newRow("swedish2") << QString("sv_SE") << QString("\xe4") << QString("\xf6") << -1;
QTest::newRow("swedish3") << QString("sv_SE") << QString("\xe5") << QString("\xf6") << -1;
QTest::newRow("swedish4") << QString("sv_SE") << QString("z") << QString("\xe5") << -1;
#endif
#if 0
/*
In Norwegian, ae (E6) comes before o with stroke (D8), which
comes before a with ring above (E5).
*/
QTest::newRow("norwegian1") << QString("no_NO") << QString("\xe6") << QString("\xd8") << -1;
QTest::newRow("norwegian2") << QString("no_NO") << QString("\xd8") << QString("\xe5") << -1;
QTest::newRow("norwegian3") << QString("no_NO") << QString("\xe6") << QString("\xe5") << -1;
#endif
/*
In German, z comes *after* a with diaresis (E4),
which comes before o diaresis (F6).
*/
#ifdef Q_OS_MAC
QTest::newRow("german1") << QString("de_DE.ISO8859-1") << QString("z") << QString("\xe4") << 1;
QTest::newRow("german2") << QString("de_DE.ISO8859-1") << QString("\xe4") << QString("\xf6") << -1;
QTest::newRow("german3") << QString("de_DE.ISO8859-1") << QString("z") << QString("\xf6") << 1;
#elif defined(Q_OS_WIN)
QTest::newRow("german1") << MAKELCID(MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN), SORT_DEFAULT) << QString("z") << QString("\xe4") << 1;
QTest::newRow("german2") << MAKELCID(MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN), SORT_DEFAULT) << QString("\xe4") << QString("\xf6") << -1;
QTest::newRow("german3") << MAKELCID(MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN), SORT_DEFAULT) << QString("z") << QString("\xf6") << 1;
#else
QTest::newRow("german1") << QString("de_DE") << QString("z") << QString("\xe4") << 1;
QTest::newRow("german2") << QString("de_DE") << QString("\xe4") << QString("\xf6") << -1;
QTest::newRow("german3") << QString("de_DE") << QString("z") << QString("\xf6") << 1;
#endif
}
void tst_QString::localeAwareCompare()
{
#ifdef Q_OS_SYMBIAN
QSKIP("QTBUG-16921: There is no way to set up the system locale, so this test is not reliable in Symbian.");
#else
#ifdef Q_OS_WIN
# ifndef Q_OS_WINCE
QSKIP("On others than Win CE, we cannot set the system or user locale.", SkipAll);
# endif
QFETCH(ulong, locale);
#else
QFETCH(QString, locale);
#endif
QFETCH(QString, s1);
QFETCH(QString, s2);
QFETCH(int, result);
QStringRef r1(&s1, 0, s1.length());
QStringRef r2(&s2, 0, s2.length());
#ifdef Q_OS_WIN
# if defined(Q_OS_WINCE)
DWORD oldLcid = GetUserDefaultLCID();
SetUserDefaultLCID(locale);
QCOMPARE(locale, GetUserDefaultLCID());
# else
DWORD oldLcid = GetThreadLocale();
SetThreadLocale(locale);
QCOMPARE(locale, GetThreadLocale());
# endif
#elif defined (Q_WS_MAC)
QSKIP("Setting the locale is not supported on OS X (you can set the C locale, but that won't affect CFStringCompare which is used to compare strings)", SkipAll);
#elif defined(QT_USE_ICU)
QLocale::setDefault(QLocale(locale));
#else
if (!locale.isEmpty()) {
const char *newLocale = setlocale(LC_ALL, locale.toLatin1());
if (!newLocale) {
setlocale(LC_ALL, "");
QSKIP("Please install the proper locale on this machine to test properly", SkipSingle);
return;
}
}
#endif
#ifdef QT_USE_ICU
// ### for c1, ICU disagrees with libc on how to compare
QEXPECT_FAIL("c1", "ICU disagrees with test", Abort);
#endif
int testres = QString::localeAwareCompare(s1, s2);
if (result < 0) {
QVERIFY(testres < 0);
} else if (result > 0) {
QVERIFY(testres > 0);
} else {
QVERIFY(testres == 0);
}
testres = QString::localeAwareCompare(s2, s1);
if (result > 0) {
QVERIFY(testres < 0);
} else if (result < 0) {
QVERIFY(testres > 0);
} else {
QVERIFY(testres == 0);
}
testres = QString::localeAwareCompare(s1, r2);
if (result < 0) {
QVERIFY(testres < 0);
} else if (result > 0) {
QVERIFY(testres > 0);
} else {
QVERIFY(testres == 0);
}
testres = QStringRef::localeAwareCompare(r1, r2);
if (result < 0) {
QVERIFY(testres < 0);
} else if (result > 0) {
QVERIFY(testres > 0);
} else {
QVERIFY(testres == 0);
}
testres = QStringRef::localeAwareCompare(r2, r1);
if (result > 0) {
QVERIFY(testres < 0);
} else if (result < 0) {
QVERIFY(testres > 0);
} else {
QVERIFY(testres == 0);
}
#ifdef Q_OS_WIN
# if defined(Q_OS_WINCE)
SetUserDefaultLCID(oldLcid);
# else
SetThreadLocale(oldLcid);
# endif
#else
if (!locale.isEmpty())
setlocale(LC_ALL, "");
#endif
#endif // Q_OS_SYMBIAN
}
void tst_QString::split_data()
{
QTest::addColumn<QString>("str");
QTest::addColumn<QString>("sep");
QTest::addColumn<QStringList>("result");
QTest::newRow("1") << "a,b,c" << "," << (QStringList() << "a" << "b" << "c");
QTest::newRow("2") << QString("-rw-r--r-- 1 0 0 519240 Jul 9 2002 bigfile")
<< " "
<< (QStringList() << "-rw-r--r--" << "" << "1" << "0" << "" << "0" << ""
<< "519240" << "Jul" << "" << "9" << "" << "2002" << "bigfile");
QTest::newRow("one-empty") << "" << " " << (QStringList() << "");
QTest::newRow("two-empty") << " " << " " << (QStringList() << "" << "");
QTest::newRow("three-empty") << " " << " " << (QStringList() << "" << "" << "");
QTest::newRow("all-empty") << "" << "" << (QStringList() << "" << "");
QTest::newRow("sep-empty") << "abc" << "" << (QStringList() << "" << "a" << "b" << "c" << "");
}
void tst_QString::split()
{
QFETCH(QString, str);
QFETCH(QString, sep);
QFETCH(QStringList, result);
QRegExp rx = QRegExp(QRegExp::escape(sep));
QStringList list;
list = str.split(sep);
QVERIFY(list == result);
list = str.split(rx);
QVERIFY(list == result);
if (sep.size() == 1) {
list = str.split(sep.at(0));
QVERIFY(list == result);
}
list = str.split(sep, QString::KeepEmptyParts);
QVERIFY(list == result);
list = str.split(rx, QString::KeepEmptyParts);
QVERIFY(list == result);
if (sep.size() == 1) {
list = str.split(sep.at(0), QString::KeepEmptyParts);
QVERIFY(list == result);
}
result.removeAll("");
list = str.split(sep, QString::SkipEmptyParts);
QVERIFY(list == result);
list = str.split(rx, QString::SkipEmptyParts);
QVERIFY(list == result);
if (sep.size() == 1) {
list = str.split(sep.at(0), QString::SkipEmptyParts);
QVERIFY(list == result);
}
}
void tst_QString::split_regexp()
{
QString str1 = "Some text\n\twith strange whitespace.";
QStringList list1 = str1.split(QRegExp("\\s+"));
QStringList result1;
result1 << "Some" << "text" << "with" << "strange" << "whitespace.";
QVERIFY(list1 == result1);
list1 = str1.split(QRegExp("\\s"), QString::SkipEmptyParts);
QVERIFY(list1 == result1);
QString str2 = "This time, a normal English sentence.";
QStringList list2 = str2.split(QRegExp("\\W+"));
QStringList result2;
result2 << "This" << "time" << "a" << "normal" << "English" << "sentence" << "";
QVERIFY(list2 == result2);
list2 = str2.split(QRegExp("\\W"), QString::SkipEmptyParts);
result2.removeAll(QString());
QVERIFY(list2 == result2);
QString str3 = "Now: this sentence fragment.";
QStringList list3 = str3.split(QRegExp("\\b"));
QStringList result3;
result3 << "" << "Now" << ": " << "this" << " " << "sentence" << " " << "fragment" << ".";
QVERIFY(list3 == result3);
list3 = str3.split(QRegExp("\\b"), QString::SkipEmptyParts);
result3.removeAll(QString());
QVERIFY(list3 == result3);
}
void tst_QString::fromUtf16_data()
{
QTest::addColumn<QString>("ucs2");
QTest::addColumn<QString>("res");
QTest::addColumn<int>("len");
QTest::newRow("str0") << QString("abcdefgh") << QString("abcdefgh") << -1;
QTest::newRow("str0-len") << QString("abcdefgh") << QString("abc") << 3;
}
void tst_QString::fromUtf16()
{
QFETCH(QString, ucs2);
QFETCH(QString, res);
QFETCH(int, len);
QCOMPARE(QString::fromUtf16(ucs2.utf16(), len), res);
}
void tst_QString::latin1String()
{
QString s("Hello");
QVERIFY(s == QLatin1String("Hello"));
QVERIFY(s != QLatin1String("Hello World"));
QVERIFY(s < QLatin1String("Helloa"));
QVERIFY(!(s > QLatin1String("Helloa")));
QVERIFY(s > QLatin1String("Helln"));
QVERIFY(s > QLatin1String("Hell"));
QVERIFY(!(s < QLatin1String("Helln")));
QVERIFY(!(s < QLatin1String("Hell")));
}
void tst_QString::nanAndInf()
{
bool ok;
double d;
#define CHECK_DOUBLE(str, expected_ok, expected_inf) \
d = QString(str).toDouble(&ok); \
QVERIFY(ok == expected_ok); \
QVERIFY((d == INFINITY) == expected_inf);
CHECK_DOUBLE("inf", true, true)
CHECK_DOUBLE("INF", true, true)
CHECK_DOUBLE("inf ", true, true)
CHECK_DOUBLE("+inf", true, true)
CHECK_DOUBLE("\t +INF", true, true)
CHECK_DOUBLE("\t INF", true, true)
CHECK_DOUBLE("inF ", true, true)
CHECK_DOUBLE("+iNf", true, true)
CHECK_DOUBLE("INFe-10", false, false)
CHECK_DOUBLE("0xINF", false, false)
CHECK_DOUBLE("- INF", false, false)
CHECK_DOUBLE("+ INF", false, false)
CHECK_DOUBLE("-- INF", false, false)
CHECK_DOUBLE("inf0", false, false)
CHECK_DOUBLE("--INF", false, false)
CHECK_DOUBLE("++INF", false, false)
CHECK_DOUBLE("INF++", false, false)
CHECK_DOUBLE("INF--", false, false)
CHECK_DOUBLE("INF +", false, false)
CHECK_DOUBLE("INF -", false, false)
CHECK_DOUBLE("0INF", false, false)
#undef CHECK_INF
#define CHECK_NAN(str, expected_ok, expected_nan) \
d = QString(str).toDouble(&ok); \
QVERIFY(ok == expected_ok); \
QVERIFY((bool)isnan(d) == expected_nan); \
CHECK_NAN("nan", true, true)
CHECK_NAN("NAN", true, true)
CHECK_NAN("nan ", true, true)
CHECK_NAN("\t NAN", true, true)
CHECK_NAN("\t NAN ", true, true)
#ifndef QT_QLOCALE_USES_FCVT //In case we use glibc this tests will fail
CHECK_NAN("-nan", false, false)
CHECK_NAN("+NAN", false, false)
#endif
CHECK_NAN("NaN", true, true)
CHECK_NAN("nAn", true, true)
CHECK_NAN("NANe-10", false, false)
CHECK_NAN("0xNAN", false, false)
CHECK_NAN("0NAN", false, false)
#undef CHECK_NAN
d = QString("-INF").toDouble(&ok);
QVERIFY(ok);
QVERIFY(d == -INFINITY);
long l;
l = QString("INF").toLong(&ok);
QVERIFY(!ok);
l = QString("INF").toLong(&ok, 36);
QVERIFY(ok);
l = QString("INF0").toLong(&ok, 36);
QVERIFY(ok);
l = QString("0INF0").toLong(&ok, 36);
QVERIFY(ok);
}
void tst_QString::arg_fillChar_data()
{
QTest::addColumn<QString>("pattern");
QTest::addColumn<QList<QVariant> >("replaceValues");
QTest::addColumn<IntList>("widths");
QTest::addColumn<QString>("fillChars");
QTest::addColumn<QString>("expected");
QList<QVariant> replaceValues;
IntList widths;
QString fillChars;
replaceValues << QVariant((int)5) << QVariant(QString("f")) << QVariant((int)0);
widths << 3 << 2 << 5;
QTest::newRow("str0") << QString("%1%2%3") << replaceValues << widths << QString("abc") << QString("aa5bfcccc0");
replaceValues.clear();
widths.clear();
replaceValues << QVariant((int)5.5) << QVariant(QString("foo")) << QVariant((qulonglong)INT_MAX);
widths << 10 << 2 << 5;
QTest::newRow("str1") << QString("%3.%1.%3.%2") << replaceValues << widths << QString("0 c")
<< QString("2147483647.0000000005.2147483647.foo");
replaceValues.clear();
widths.clear();
replaceValues << QVariant(QString("fisk"));
widths << 100;
QTest::newRow("str2") << QString("%9 og poteter") << replaceValues << widths << QString("f")
<< QString("fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffisk og poteter");
}
void tst_QString::arg_fillChar()
{
static const int base = 10;
static const char fmt = 'g';
static const int prec = -1;
QFETCH(QString, pattern);
QFETCH(QList<QVariant>, replaceValues);
QFETCH(IntList, widths);
QFETCH(QString, fillChars);
QFETCH(QString, expected);
QCOMPARE(replaceValues.count(), fillChars.count());
QCOMPARE(replaceValues.count(), widths.count());
QString actual = pattern;
for (int i=0; i<replaceValues.count(); ++i) {
const QVariant &var = replaceValues.at(i);
const int width = widths.at(i);
const QChar &fillChar = fillChars.at(i);
switch (var.type()) {
case QVariant::String: actual = actual.arg(var.toString(), width, fillChar); break;
case QVariant::Int: actual = actual.arg(var.toInt(), width, base, fillChar); break;
case QVariant::UInt: actual = actual.arg(var.toUInt(), width, base, fillChar); break;
case QVariant::Double: actual = actual.arg(var.toDouble(), width, fmt, prec, fillChar); break;
case QVariant::LongLong: actual = actual.arg(var.toLongLong(), width, base, fillChar); break;
case QVariant::ULongLong: actual = actual.arg(var.toULongLong(), width, base, fillChar); break;
default: QVERIFY(0); break;
}
}
QCOMPARE(actual, expected);
}
static inline int sign(int x)
{
return x == 0 ? 0 : (x < 0 ? -1 : 1);
}
void tst_QString::compare_data()
{
QTest::addColumn<QString>("s1");
QTest::addColumn<QString>("s2");
QTest::addColumn<int>("csr"); // case sensitive result
QTest::addColumn<int>("cir"); // case insensitive result
// null strings
QTest::newRow("data0") << QString("") << QString("") << 0 << 0;
QTest::newRow("data1") << QString("a") << QString("") << 1 << 1;
QTest::newRow("data2") << QString("") << QString("a") << -1 << -1;
// equal length
QTest::newRow("data3") << QString("abc") << QString("abc") << 0 << 0;
QTest::newRow("data4") << QString("abC") << QString("abc") << -1 << 0;
QTest::newRow("data5") << QString("abc") << QString("abC") << 1 << 0;
// different length
QTest::newRow("data6") << QString("abcdef") << QString("abc") << 1 << 1;
QTest::newRow("data6") << QString("abCdef") << QString("abc") << -1 << 1;
QTest::newRow("data7") << QString("abc") << QString("abcdef") << -1 << -1;
QString upper;
upper += QChar(QChar::highSurrogate(0x10400));
upper += QChar(QChar::lowSurrogate(0x10400));
QString lower;
lower += QChar(QChar::highSurrogate(0x10428));
lower += QChar(QChar::lowSurrogate(0x10428));
QTest::newRow("data8") << upper << lower << -1 << 0;
// embedded nulls
// These dont work as of now. Its OK that these dont work since \0 is not a valid unicode
/*QTest::newRow("data9") << QString(QByteArray("\0", 1)) << QString(QByteArray("\0", 1)) << 0 << 0;
QTest::newRow("data10") << QString(QByteArray("\0", 1)) << QString("") << 1 << 1;
QTest::newRow("data11") << QString("") << QString(QByteArray("\0", 1)) << -1 << -1;
QTest::newRow("data12") << QString("ab\0c") << QString(QByteArray("ab\0c", 4)) << 0 << 0;
QTest::newRow("data13") << QString(QByteArray("ab\0c", 4)) << QString("abc") << -1 << -1;
QTest::newRow("data14") << QString("abc") << QString(QByteArray("ab\0c", 4)) << 1 << 1;*/
}
static bool isLatin(const QString &s)
{
for (int i = 0; i < s.length(); ++i)
if (s.at(i).unicode() > 0xff)
return false;
return true;
}
void tst_QString::compare()
{
QFETCH(QString, s1);
QFETCH(QString, s2);
QFETCH(int, csr);
QFETCH(int, cir);
QStringRef r1(&s1, 0, s1.length());
QStringRef r2(&s2, 0, s2.length());
QCOMPARE(sign(QString::compare(s1, s2)), csr);
QCOMPARE(sign(QStringRef::compare(r1, r2)), csr);
QCOMPARE(sign(s1.compare(s2)), csr);
QCOMPARE(sign(s1.compare(r2)), csr);
QCOMPARE(sign(r1.compare(r2)), csr);
QCOMPARE(sign(s1.compare(s2, Qt::CaseSensitive)), csr);
QCOMPARE(sign(s1.compare(s2, Qt::CaseInsensitive)), cir);
QCOMPARE(sign(s1.compare(r2, Qt::CaseSensitive)), csr);
QCOMPARE(sign(s1.compare(r2, Qt::CaseInsensitive)), cir);
QCOMPARE(sign(r1.compare(r2, Qt::CaseSensitive)), csr);
QCOMPARE(sign(r1.compare(r2, Qt::CaseInsensitive)), cir);
QCOMPARE(sign(QString::compare(s1, s2, Qt::CaseSensitive)), csr);
QCOMPARE(sign(QString::compare(s1, s2, Qt::CaseInsensitive)), cir);
QCOMPARE(sign(QString::compare(s1, r2, Qt::CaseSensitive)), csr);
QCOMPARE(sign(QString::compare(s1, r2, Qt::CaseInsensitive)), cir);
QCOMPARE(sign(QStringRef::compare(r1, r2, Qt::CaseSensitive)), csr);
QCOMPARE(sign(QStringRef::compare(r1, r2, Qt::CaseInsensitive)), cir);
if (!cir) {
QCOMPARE(s1.toCaseFolded(), s2.toCaseFolded());
}
if (isLatin(s2)) {
QCOMPARE(sign(QString::compare(s1, QLatin1String(s2.toLatin1()))), csr);
QCOMPARE(sign(QString::compare(s1, QLatin1String(s2.toLatin1()), Qt::CaseInsensitive)), cir);
QCOMPARE(sign(QStringRef::compare(r1, QLatin1String(s2.toLatin1()))), csr);
QCOMPARE(sign(QStringRef::compare(r1, QLatin1String(s2.toLatin1()), Qt::CaseInsensitive)), cir);
}
if (isLatin(s1)) {
QCOMPARE(sign(QString::compare(QLatin1String(s1.toLatin1()), s2)), csr);
QCOMPARE(sign(QString::compare(QLatin1String(s1.toLatin1()), s2, Qt::CaseInsensitive)), cir);
}
}
void tst_QString::resizeAfterFromRawData()
{
QString buffer("hello world");
QString array = QString::fromRawData(buffer.constData(), buffer.size());
QVERIFY(array.constData() == buffer.constData());
array.resize(5);
QVERIFY(array.constData() == buffer.constData());
}
void tst_QString::resizeAfterReserve()
{
QString s;
s.reserve(100);
s += "hello world";
// resize should not affect capacity
s.resize(s.size());
QVERIFY(s.capacity() == 100);
// but squeeze does
s.squeeze();
QVERIFY(s.capacity() == s.size());
// clear does too
s.clear();
QVERIFY(s.capacity() == 0);
// test resize(0) border case
s.reserve(100);
s += "hello world";
s.resize(0);
QVERIFY(s.capacity() == 100);
}
void tst_QString::resizeWithNegative() const
{
{
QString string(QLatin1String("input"));
string.resize(-1);
QCOMPARE(string, QString());
}
{
QString string(QLatin1String("input"));
string.resize(-9099);
QCOMPARE(string, QString());
}
{
/* Example code from customer. */
QString s(QLatin1String("hola"));
s.reserve(1);
s.resize(-1);
QCOMPARE(s, QString());
}
}
void tst_QString::truncateWithNegative() const
{
{
QString string(QLatin1String("input"));
string.truncate(-1);
QCOMPARE(string, QString());
}
{
QString string(QLatin1String("input"));
string.truncate(-9099);
QCOMPARE(string, QString());
}
{
/* Example code from customer. */
QString test(QLatin1String("c"));
test.replace(QRegExp(QLatin1String("c")), QLatin1String("z"));
test.truncate(-1);
QCOMPARE(test, QString());
}
}
void tst_QString::QCharRefMutableUnicode() const
{
QString str;
str.resize(3);
str[0].unicode() = 115;
str[1].unicode() = 116;
str[2].unicode() = 114;
QCOMPARE(str, QString::fromLatin1("str"));
}
void tst_QString::QCharRefDetaching() const
{
{
QString str = QString::fromLatin1("str");
QString copy;
copy[0] = QLatin1Char('S');
QCOMPARE(str, QString::fromLatin1("str"));
}
{
ushort buf[] = { 's', 't', 'r' };
QString str = QString::fromRawData((const QChar *)buf, 3);
str[0] = QLatin1Char('S');
QCOMPARE(buf[0], ushort('s'));
}
{
static const ushort buf[] = { 's', 't', 'r' };
QString str = QString::fromRawData((const QChar *)buf, 3);
// this causes a crash in most systems if the detaching doesn't work
str[0] = QLatin1Char('S');
QCOMPARE(buf[0], ushort('s'));
}
}
void tst_QString::sprintfZU() const
{
{
QString string;
size_t s = 6;
string.sprintf("%zu", s);
QCOMPARE(string, QString::fromLatin1("6"));
}
{
QString string;
string.sprintf("%s\n", "foo");
QCOMPARE(string, QString::fromLatin1("foo\n"));
}
{
/* This code crashed. I don't know how to reduce it further. In other words,
* both %zu and %s needs to be present. */
size_t s = 6;
QString string;
string.sprintf("%zu%s", s, "foo");
QCOMPARE(string, QString::fromLatin1("6foo"));
}
{
size_t s = 6;
QString string;
string.sprintf("%zu %s\n", s, "foo");
QCOMPARE(string, QString::fromLatin1("6 foo\n"));
}
}
void tst_QString::repeatedSignature() const
{
/* repated() should be a const member. */
const QString string;
string.repeated(3);
}
void tst_QString::repeated() const
{
QFETCH(QString, string);
QFETCH(QString, expected);
QFETCH(int, count);
QCOMPARE(string.repeated(count), expected);
}
void tst_QString::repeated_data() const
{
QTest::addColumn<QString>("string" );
QTest::addColumn<QString>("expected" );
QTest::addColumn<int>("count" );
/* Empty strings. */
QTest::newRow("")
<< QString()
<< QString()
<< 0;
QTest::newRow("")
<< QString()
<< QString()
<< -1004;
QTest::newRow("")
<< QString()
<< QString()
<< 1;
QTest::newRow("")
<< QString()
<< QString()
<< 5;
/* On simple string. */
QTest::newRow("")
<< QString(QLatin1String("abc"))
<< QString()
<< -1004;
QTest::newRow("")
<< QString(QLatin1String("abc"))
<< QString()
<< -1;
QTest::newRow("")
<< QString(QLatin1String("abc"))
<< QString()
<< 0;
QTest::newRow("")
<< QString(QLatin1String("abc"))
<< QString(QLatin1String("abc"))
<< 1;
QTest::newRow("")
<< QString(QLatin1String("abc"))
<< QString(QLatin1String("abcabc"))
<< 2;
QTest::newRow("")
<< QString(QLatin1String("abc"))
<< QString(QLatin1String("abcabcabc"))
<< 3;
QTest::newRow("")
<< QString(QLatin1String("abc"))
<< QString(QLatin1String("abcabcabcabc"))
<< 4;
}
void tst_QString::task262677remove()
{
QString driveName = QLatin1String("V:\\blahblah\\more_blahblah\\");
driveName.remove(2, INT_MAX); // should be "V:" - instead, it's "V::\\blahblah\\more_blahblah\\"
QVERIFY(driveName == QLatin1String("V:"));
}
void tst_QString::QTBUG10404_compareRef()
{
QString a = "ABCDEFGH";
QCOMPARE(QStringRef(&a, 1, 2).compare(QLatin1String("BC")), 0);
QVERIFY(QStringRef(&a, 1, 2).compare(QLatin1String("BCD")) < 0);
QCOMPARE(QStringRef(&a, 1, 2).compare(QLatin1String("Bc"), Qt::CaseInsensitive), 0);
QVERIFY(QStringRef(&a, 1, 2).compare(QLatin1String("bCD"), Qt::CaseInsensitive) < 0);
QCOMPARE(QStringRef(&a, 1, 2).compare(QString::fromLatin1("BC")), 0);
QVERIFY(QStringRef(&a, 1, 2).compare(QString::fromLatin1("BCD")) < 0);
QCOMPARE(QStringRef(&a, 1, 2).compare(QString::fromLatin1("Bc"), Qt::CaseInsensitive), 0);
QVERIFY(QStringRef(&a, 1, 2).compare(QString::fromLatin1("bCD"), Qt::CaseInsensitive) < 0);
QCOMPARE(QString::fromLatin1("BC").compare(QStringRef(&a, 1, 2)), 0);
QVERIFY(QString::fromLatin1("BCD").compare(QStringRef(&a, 1, 2)) > 0);
QCOMPARE(QString::fromLatin1("Bc").compare(QStringRef(&a, 1, 2), Qt::CaseInsensitive), 0);
QVERIFY(QString::fromLatin1("bCD").compare(QStringRef(&a, 1, 2), Qt::CaseInsensitive) > 0);
QCOMPARE(QStringRef(&a, 1, 2).compare(QStringRef(&a, 1, 2)), 0);
QVERIFY(QStringRef(&a, 1, 2).compare(QStringRef(&a, 1, 3)) < 0);
QCOMPARE(QStringRef(&a, 1, 2).compare(QStringRef(&a, 1, 2), Qt::CaseInsensitive), 0);
QVERIFY(QStringRef(&a, 1, 2).compare(QStringRef(&a, 1, 3), Qt::CaseInsensitive) < 0);
QString a2 = "ABCDEFGh";
QCOMPARE(QStringRef(&a2, 1, 2).compare(QStringRef(&a, 1, 2)), 0);
QVERIFY(QStringRef(&a2, 1, 2).compare(QStringRef(&a, 1, 3)) < 0);
QCOMPARE(QStringRef(&a2, 1, 2).compare(QStringRef(&a, 1, 2), Qt::CaseInsensitive), 0);
QVERIFY(QStringRef(&a2, 1, 2).compare(QStringRef(&a, 1, 3), Qt::CaseInsensitive) < 0);
}
void tst_QString::QTBUG9281_arg_locale()
{
QLocale l(QLocale::English, QLocale::UnitedKingdom);
l.setNumberOptions(QLocale::OmitGroupSeparator);
QLocale::setDefault(l);
QString str("*%L1*%L2*");
str = str.arg(123456).arg(1234.56);
QCOMPARE(str, QString::fromLatin1("*123456*1234.56*"));
QLocale::setDefault(QLocale::C);
}
void tst_QString::toUpperLower_icu()
{
#ifndef QT_USE_ICU
QSKIP("Qt was built without ICU support", SkipAll);
#endif
QString s = QString::fromLatin1("i");
QCOMPARE(s.toUpper(), QString::fromLatin1("I"));
QCOMPARE(s.toLower(), QString::fromLatin1("i"));
QLocale::setDefault(QLocale(QLocale::Turkish, QLocale::Turkey));
// turkish locale has a capital I with a dot (U+0130, utf8 c4b0)
QCOMPARE(s.toUpper(), QString::fromUtf8("\xc4\xb0"));
QCOMPARE(QString::fromUtf8("\xc4\xb0").toLower(), s);
// nothing should happen here
QCOMPARE(s.toLower(), s);
QCOMPARE(QString::fromLatin1("I").toUpper(), QString::fromLatin1("I"));
// U+0131, utf8 c4b1 is the lower-case i without a dot
QString sup = QString::fromUtf8("\xc4\xb1");
QCOMPARE(sup.toUpper(), QString::fromLatin1("I"));
QCOMPARE(QString::fromLatin1("I").toLower(), sup);
// nothing should happen here
QCOMPARE(sup.toLower(), sup);
QCOMPARE(QString::fromLatin1("i").toLower(), QString::fromLatin1("i"));
// the cleanup function will restore the default locale
}
QTEST_APPLESS_MAIN(tst_QString)
#include "tst_qstring.moc"
Reference in New Issue View Git Blame Copy Permalink