Long live Qt 4.5!

3 files changed, 894 insertions, 0 deletions

diff --git a/tests/auto/q3cstring/.gitignore b/tests/auto/q3cstring/.gitignore
new file mode 100644
index 0000000..1a1bd6d
--- /dev/null
+++ b/tests/auto/q3cstring/.gitignore
@@ -0,0 +1,2 @@
+tst_q3cstring
+COMPARE.txt
diff --git a/tests/auto/q3cstring/q3cstring.pro b/tests/auto/q3cstring/q3cstring.pro
new file mode 100644
index 0000000..78077b8
--- /dev/null
+++ b/tests/auto/q3cstring/q3cstring.pro
@@ -0,0 +1,7 @@
+load(qttest_p4)
+SOURCES  += tst_q3cstring.cpp
+
+
+QT += qt3support
+
+
diff --git a/tests/auto/q3cstring/tst_q3cstring.cpp b/tests/auto/q3cstring/tst_q3cstring.cpp
new file mode 100644
index 0000000..f9bdf6b
--- /dev/null
+++ b/tests/auto/q3cstring/tst_q3cstring.cpp
@@ -0,0 +1,885 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, 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.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtTest/QtTest>
+#include <q3cstring.h>
+#include <qregexp.h>
+#include <qtextstream.h>
+
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_Q3CString : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_Q3CString();
+    virtual ~tst_Q3CString();
+
+
+public slots:
+    void init();
+    void cleanup();
+private slots:
+    void setExpand();
+    void check_QTextStream();
+    void check_QDataStream();
+    void replace_uint_uint_data();
+    void replace_uint_uint();
+    void replace_string_data();
+    void replace_string();
+    void replace_regexp_data();
+    void replace_regexp();
+    void remove_uint_uint_data();
+    void remove_uint_uint();
+    void prepend();
+    void append();
+    void insert();
+    void simplifyWhiteSpace();
+    void stripWhiteSpace();
+    void lower();
+    void upper();
+    void rightJustify();
+    void leftJustify();
+    void mid();
+    void right();
+    void left();
+    void contains();
+    void findRev();
+    void find();
+    void sprintf();
+    void copy();
+    void fill();
+    void truncate();
+    void constructor();
+    void isEmpty();
+    void isNull();
+    void acc_01();
+    void length_data();
+    void length();
+
+    // testfunctions?
+    void remove_string_data();
+    void remove_regexp_data();
+};
+
+Q_DECLARE_METATYPE(Q3CString)
+
+tst_Q3CString::tst_Q3CString()
+{
+}
+
+tst_Q3CString::~tst_Q3CString()
+{
+}
+
+void tst_Q3CString::init()
+{
+}
+
+void tst_Q3CString::cleanup()
+{
+}
+
+void tst_Q3CString::remove_uint_uint_data()
+{
+    replace_uint_uint_data();
+}
+
+void tst_Q3CString::remove_string_data()
+{
+    replace_string_data();
+}
+
+void tst_Q3CString::remove_regexp_data()
+{
+    replace_regexp_data();
+}
+
+void tst_Q3CString::length_data()
+{
+    QTest::addColumn<Q3CString>("s1");
+    QTest::addColumn<int>("res");
+
+    QTest::newRow( "data0" )  << Q3CString("Test") << 4;
+    QTest::newRow( "data1" )  << Q3CString("The quick brown fox jumps over the lazy dog") << 43;
+    QTest::newRow( "data2" )  << Q3CString(0) << 0;
+    QTest::newRow( "data3" )  << Q3CString("A") << 1;
+    QTest::newRow( "data4" )  << Q3CString("AB") << 2;
+    QTest::newRow( "data5" )  << Q3CString("AB\n") << 3;
+    QTest::newRow( "data6" )  << Q3CString("AB\nC") << 4;
+    QTest::newRow( "data7" )  << Q3CString("\n") << 1;
+    QTest::newRow( "data8" )  << Q3CString("\nA") << 2;
+    QTest::newRow( "data9" )  << Q3CString("\nAB") << 3;
+    QTest::newRow( "data10" )  << Q3CString("\nAB\nCDE") << 7;
+    QTest::newRow( "data11" )  << Q3CString("shdnftrheid fhgnt gjvnfmd chfugkh bnfhg thgjf vnghturkf chfnguh bjgnfhvygh hnbhgutjfv dhdnjds dcjs d") << 100;
+}
+
+void tst_Q3CString::replace_uint_uint_data()
+{
+    QTest::addColumn<Q3CString>("string");
+    QTest::addColumn<int>("index");
+    QTest::addColumn<int>("len");
+    QTest::addColumn<Q3CString>("after");
+    QTest::addColumn<Q3CString>("result");
+
+    QTest::newRow( "rem00" ) << Q3CString("-<>ABCABCABCABC>") << 0 << 3 << Q3CString("") << Q3CString("ABCABCABCABC>");
+    QTest::newRow( "rem01" ) << Q3CString("ABCABCABCABC>") << 1 << 4 <<Q3CString("") <<Q3CString("ACABCABC>");
+    QTest::newRow( "rem02" ) << Q3CString("ACABCABC>") << 999 << 4 << Q3CString("") << Q3CString("ACABCABC>");
+    QTest::newRow( "rem03" ) << Q3CString("ACABCABC>") << 9 << 4 << Q3CString("") << Q3CString("ACABCABC>");
+    QTest::newRow( "rem04" ) << Q3CString("ACABCABC>") << 8 << 4 << Q3CString("") << Q3CString("ACABCABC");
+    QTest::newRow( "rem05" ) << Q3CString("ACABCABC") << 7 << 1 << Q3CString("") << Q3CString("ACABCAB");
+    QTest::newRow( "rem06" ) << Q3CString("ACABCAB") << 4 << 0 << Q3CString("") << Q3CString("ACABCAB");
+
+    QTest::newRow( "rep00" ) << Q3CString("ACABCAB") << 4 << 0 << Q3CString("X") << Q3CString("ACABXCAB");
+    QTest::newRow( "rep01" ) << Q3CString("ACABXCAB") << 4 << 1 << Q3CString("Y") << Q3CString("ACABYCAB");
+    QTest::newRow( "rep02" ) << Q3CString("ACABYCAB") << 4 << 1 << Q3CString("") << Q3CString("ACABCAB");
+    QTest::newRow( "rep03" ) << Q3CString("ACABCAB") << 0 << 9999 << Q3CString("XX") << Q3CString("XX");
+    QTest::newRow( "rep04" ) << Q3CString("XX") << 0 << 9999 << Q3CString("") << Q3CString("");
+}
+
+void tst_Q3CString::replace_string_data()
+{
+    QTest::addColumn<Q3CString>("string");
+    QTest::addColumn<Q3CString>("before");
+    QTest::addColumn<Q3CString>("after");
+    QTest::addColumn<Q3CString>("result");
+
+    QTest::newRow( "rem00" ) << Q3CString("") << Q3CString("") << Q3CString("") << Q3CString("");
+    QTest::newRow( "rem01" ) << Q3CString("A") << Q3CString("") << Q3CString("") << Q3CString("A");
+    QTest::newRow( "rem02" ) << Q3CString("A") << Q3CString("A") << Q3CString("") << Q3CString("");
+    QTest::newRow( "rem03" ) << Q3CString("A") << Q3CString("B") << Q3CString("") << Q3CString("A");
+    QTest::newRow( "rem04" ) << Q3CString("AA") << Q3CString("A") << Q3CString("") << Q3CString("");
+    QTest::newRow( "rem05" ) << Q3CString("AB") << Q3CString("A") << Q3CString("") << Q3CString("B");
+    QTest::newRow( "rem06" ) << Q3CString("AB") << Q3CString("B") << Q3CString("") << Q3CString("A");
+    QTest::newRow( "rem07" ) << Q3CString("AB") << Q3CString("C") << Q3CString("") << Q3CString("AB");
+    QTest::newRow( "rem08" ) << Q3CString("ABA") << Q3CString("A") << Q3CString("") << Q3CString("B");
+    QTest::newRow( "rem09" ) << Q3CString("ABA") << Q3CString("B") << Q3CString("") << Q3CString("AA");
+    QTest::newRow( "rem10" ) << Q3CString("ABA") << Q3CString("C") << Q3CString("") << Q3CString("ABA");
+    QTest::newRow( "rem11" ) << Q3CString("banana") << Q3CString("an") << Q3CString("") << Q3CString("ba");
+    QTest::newRow( "rem12" ) << Q3CString("") << Q3CString("A") << Q3CString("") << Q3CString("");
+    QTest::newRow( "rem13" ) << Q3CString("") << Q3CString("A") << Q3CString(0) << Q3CString("");
+    QTest::newRow( "rem14" ) << Q3CString(0) << Q3CString("A") << Q3CString("") << Q3CString(0);
+    QTest::newRow( "rem15" ) << Q3CString(0) << Q3CString("A") << Q3CString(0) << Q3CString(0);
+#if QT_VERSION < 0x040000
+    QTest::newRow( "rem16" ) << Q3CString(0) << Q3CString("") << Q3CString("A") << Q3CString(0);
+#endif
+    QTest::newRow( "rem17" ) << Q3CString(0) << Q3CString("") << Q3CString("") << Q3CString(0);
+    // ### how should the one below behave in Q3CString????
+//    QTest::newRow( "rem18" ) << Q3CString("") << Q3CString(0) << Q3CString("A") << Q3CString("A");
+    QTest::newRow( "rem19" ) << Q3CString("") << Q3CString(0) << Q3CString("") << Q3CString("");
+
+    QTest::newRow( "rep00" ) << Q3CString("ABC") << Q3CString("B") << Q3CString("-") << Q3CString("A-C");
+    QTest::newRow( "rep01" ) << Q3CString("$()*+.?[\\]^{|}") << Q3CString("$()*+.?[\\]^{|}") << Q3CString("X") << Q3CString("X");
+    QTest::newRow( "rep02" ) << Q3CString("ABCDEF") << Q3CString("") << Q3CString("X") << Q3CString("XAXBXCXDXEXFX");
+    QTest::newRow( "rep03" ) << Q3CString("") << Q3CString("") << Q3CString("X") << Q3CString("X");
+}
+
+void tst_Q3CString::replace_regexp_data()
+{
+    QTest::addColumn<Q3CString>("string");
+    QTest::addColumn<Q3CString>("regexp");
+    QTest::addColumn<Q3CString>("after");
+    QTest::addColumn<Q3CString>("result");
+
+    QTest::newRow( "rem00" ) << Q3CString("alpha") << Q3CString("a+") << Q3CString("") << Q3CString("lph");
+#if QT_VERSION >= 0x030100
+    QTest::newRow( "rem01" ) << Q3CString("banana") << Q3CString("^.a") << Q3CString("") << Q3CString("nana");
+#endif
+    QTest::newRow( "rem02" ) << Q3CString("") << Q3CString("^.a") << Q3CString("") << Q3CString("");
+    QTest::newRow( "rem03" ) << Q3CString("") << Q3CString("^.a") << Q3CString(0) << Q3CString("");
+    QTest::newRow( "rem04" ) << Q3CString(0) << Q3CString("^.a") << Q3CString("") << Q3CString(0);
+    QTest::newRow( "rem05" ) << Q3CString(0) << Q3CString("^.a") << Q3CString(0) << Q3CString(0);
+
+#if QT_VERSION >= 0x030100
+    QTest::newRow( "rep00" ) << Q3CString("A <i>bon mot</i>.") << Q3CString("<i>([^<]*)</i>") << Q3CString("\\emph{\\1}") << Q3CString("A \\emph{bon mot}.");
+    QTest::newRow( "rep01" ) << Q3CString("banana") << Q3CString("^.a()") << Q3CString("\\1") << Q3CString("nana");
+    QTest::newRow( "rep02" ) << Q3CString("banana") << Q3CString("(ba)") << Q3CString("\\1X\\1") << Q3CString("baXbanana");
+    QTest::newRow( "rep03" ) << Q3CString("banana") << Q3CString("(ba)(na)na") << Q3CString("\\2X\\1") << Q3CString("naXba");
+#endif
+}
+
+void tst_Q3CString::length()
+{
+    QFETCH( Q3CString, s1 );
+    QTEST( (int)s1.length(), "res" );
+}
+
+#include <qfile.h>
+
+void tst_Q3CString::acc_01()
+{
+    Q3CString a;
+    Q3CString b; //b(10);
+    Q3CString bb; //bb((int)0);
+    Q3CString c("String C");
+    char 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';
+    Q3CString d(tmp,8);
+    Q3CString ca(a);
+    Q3CString cb(b);
+    Q3CString cc(c);
+    Q3CString n;
+    Q3CString e("String E");
+    Q3CString f;
+    f = e;
+    f.detach();
+    f[7]='F';
+    QCOMPARE(e,(Q3CString)"String E");
+    char text[]="String f";
+    f = text;
+    text[7]='!';
+    QCOMPARE(f,(Q3CString)"String f");
+    f[7]='F';
+    QCOMPARE(text[7],'!');
+
+#if 0
+    a="";
+    a[0]='A';
+    Q3CString res = "A";
+    QCOMPARE(a,res);
+    QCOMPARE(a.length(),(uint)1);
+    compare(a.length(),(uint)1);
+    a[1]='B';
+    QCOMPARE(a,(Q3CString)"AB");
+    QCOMPARE(a.length(),(uint)2);
+    a[2]='C';
+    QCOMPARE(a,(Q3CString)"ABC");
+    QCOMPARE(a.length(),(uint)3);
+    a = Q3CString();
+    QVERIFY(a.isNull());
+    a[0]='A';
+    QCOMPARE(a,(Q3CString)"A");
+    QCOMPARE(a.length(),(uint)1);
+    a[1]='B';
+    QCOMPARE(a,(Q3CString)"AB");
+    QCOMPARE(a.length(),(uint)2);
+    a[2]='C';
+    QCOMPARE(a,(Q3CString)"ABC");
+    QCOMPARE(a.length(),(uint)3);
+#endif
+    a="123";
+    b="456";
+    a[0]=a[1];
+    QCOMPARE(a,(Q3CString)"223");
+    a[1]=b[1];
+    QCOMPARE(b,(Q3CString)"456");
+    QCOMPARE(a,(Q3CString)"253");
+
+    char t[]="TEXT";
+    a="A";
+    a=t;
+    QCOMPARE(a,(Q3CString)"TEXT");
+    QCOMPARE(a,(Q3CString)t);
+    a[0]='X';
+    QCOMPARE(a,(Q3CString)"XEXT");
+    QCOMPARE(t[0],'T');
+    t[0]='Z';
+    QCOMPARE(a,(Q3CString)"XEXT");
+
+    a="ABC";
+    QCOMPARE(((const char*)a)[1],'B');
+    QCOMPARE(strcmp(a,(Q3CString)"ABC"),0);
+    a += "DEF";
+    QCOMPARE(a, (Q3CString)"ABCDEF");
+    a += 'G';
+    QCOMPARE(a, (Q3CString)"ABCDEFG");
+    a += ((const char*)(0));
+    QCOMPARE(a, (Q3CString)"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(a+b,(Q3CString)"ABCABC");
+    QCOMPARE(a	+"XXXX",(Q3CString)"ABCXXXX");
+    QCOMPARE(a+'X',(Q3CString)"ABCX");
+    QCOMPARE("XXXX"+a,(Q3CString)"XXXXABC");
+    QCOMPARE('X'+a,(Q3CString)"XABC");
+    a = (const char*)0;
+    QVERIFY(a.isNull());
+#if QT_VERSION < 0x040000
+    QVERIFY((const char*)a==0);
+#else
+    QVERIFY(*((const char *)a) == 0);
+#endif
+
+    {
+	QFile f("COMPARE.txt");
+	f.open( QIODevice::WriteOnly );
+	QTextStream ts( &f );
+	ts.setEncoding(QTextStream::Unicode);
+	ts << "Abc";
+    }
+}
+
+void tst_Q3CString::isNull()
+{
+    Q3CString a;
+    QVERIFY( a.isNull() );
+
+    const char *str = "foo";
+    a.sprintf( str );
+    QVERIFY( !a.isNull() );
+}
+
+void tst_Q3CString::isEmpty()
+{
+    Q3CString a;
+    QVERIFY(a.isEmpty());
+    Q3CString c("Not empty");
+    QVERIFY(!c.isEmpty());
+}
+
+void tst_Q3CString::constructor()
+{
+    Q3CString a;
+    Q3CString b; //b(10);
+    Q3CString c("String C");
+    char 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';
+    Q3CString d(tmp,9);
+    Q3CString ca(a);
+    Q3CString cb(b);
+    Q3CString cc(c);
+
+    QCOMPARE(a,ca);
+    QVERIFY(a.isNull());
+#if QT_VERSION < 0x040000
+    QVERIFY(a != (Q3CString)"");
+#else
+    QVERIFY(a == Q3CString(""));
+#endif
+    QCOMPARE(b,cb);
+    QCOMPARE(c,cc);
+    QCOMPARE(d,(Q3CString)"String D");
+
+    Q3CString null(0);
+    QVERIFY( null.isNull() );
+    QVERIFY( null.isEmpty() );
+    Q3CString empty("");
+    QVERIFY( !empty.isNull() );
+    QVERIFY( empty.isEmpty() );
+}
+
+void tst_Q3CString::truncate()
+{
+    Q3CString e("String E");
+    e.truncate(4);
+    QCOMPARE(e,(Q3CString)"Stri");
+
+    e = "String E";
+    e.truncate(0);
+    QCOMPARE(e,(Q3CString)"");
+    QVERIFY(e.isEmpty());
+    QVERIFY(!e.isNull());
+
+}
+
+void tst_Q3CString::fill()
+{
+    Q3CString e;
+    e.fill('e',1);
+    QCOMPARE(e,(Q3CString)"e");
+    Q3CString f;
+    f.fill('f',3);
+    QCOMPARE(f,(Q3CString)"fff");
+    f.fill('F');
+    QCOMPARE(f,(Q3CString)"FFF");
+}
+
+void tst_Q3CString::copy()
+{
+    Q3CString e;
+    e = "String E";
+    Q3CString ce = e.copy();
+    QCOMPARE(ce,(Q3CString)"String E");
+    e = "XXX";
+    QCOMPARE(ce,(Q3CString)"String E");
+    QCOMPARE(e,(Q3CString)"XXX");
+}
+
+void tst_Q3CString::sprintf()
+{
+    Q3CString a;
+    a.sprintf("COMPARE");
+    QCOMPARE(a,(Q3CString)"COMPARE");
+    a.sprintf("%%%d",1);
+    QCOMPARE(a,(Q3CString)"%1");
+    QCOMPARE(a.sprintf("X%dY",2),(Q3CString)"X2Y");
+    //QCOMPARE(a.sprintf("X%sY",(Q3CString)"hello"),"XhelloY");
+    // QCOMPARE(a.sprintf("X%9sY","hello"),(Q3CString)"X    helloY");
+    QCOMPARE(a.sprintf("X%9iY", 50000 ),(Q3CString)"X    50000Y");
+    QCOMPARE(a.sprintf("X%-9sY","hello"),(Q3CString)"Xhello    Y");
+    QCOMPARE(a.sprintf("X%-9iY", 50000 ),(Q3CString)"X50000    Y");
+    //Q3CString fmt("X%-10SY");
+    //Q3CString txt("hello");
+    //QCOMPARE(a.sprintf(fmt,(Q3CString)&txt),"X     helloY");
+}
+
+void tst_Q3CString::find()
+{
+    Q3CString a;
+    a="";
+    QCOMPARE(a.find('A'),-1);
+    a=Q3CString();
+    QCOMPARE(a.find('A'),-1);
+    a="ABCDEFGHIEfGEFG"; // 15 chars
+    QCOMPARE(a.find('A'),0);
+    QCOMPARE(a.find('C'),2);
+    QCOMPARE(a.find('Z'),-1);
+    QCOMPARE(a.find('E'),4);
+    QCOMPARE(a.find('E',4),4);
+    QCOMPARE(a.find('E',5),9);
+    //QCOMPARE(a.find('G',-1),14);    // -ve does what?  Parameter should be uint?
+    //QCOMPARE(a.find('G',-2),11);    // -ve does what?  Parameter should be uint?
+    QCOMPARE(a.find('f'),10);
+#if QT_VERSION < 0x040000
+    // case sensitive find has been removed in 4.0
+    QCOMPARE(a.find('f',0,FALSE),5);
+    QCOMPARE(a.find('g',0,TRUE),-1);
+    QCOMPARE(a.find("fgh",0,FALSE),5);
+    QCOMPARE(a.find("fgh",0,TRUE),-1);
+    QCOMPARE(a.find("EFG",5,TRUE),12);
+    QCOMPARE(a.find("EFG",5,FALSE),9);
+    QCOMPARE(a.find("EFG",4,TRUE),4);
+    QCOMPARE(a.find("EfG",4,FALSE),4);
+    QCOMPARE(a.find("EfG",4,TRUE),9);
+#endif
+//  QCOMPARE(a.find("efg",-1,FALSE),12);    // -ve does what?  Parameter should be uint?
+//  QCOMPARE(a.find("efg",-2,FALSE),12);    // -ve does what?  Parameter should be uint?
+//  QCOMPARE(a.find("efg",-3,FALSE),12);    // -ve does what?  Parameter should be uint?
+//  QCOMPARE(a.find("efg",-4,FALSE),9);    // -ve does what?  Parameter should be uint?
+//  QCOMPARE(a.find(QRegExp("[EFG][EFG]"),0),4);
+//  QCOMPARE(a.find(QRegExp("[EFG][EFG]"),4),4);
+//  QCOMPARE(a.find(QRegExp("[EFG][EFG]"),5),5);
+//  QCOMPARE(a.find(QRegExp("[EFG][EFG]"),6),11);
+//  QCOMPARE(a.find(QRegExp("G"),14),14);
+}
+
+void tst_Q3CString::findRev()
+{
+    Q3CString a;
+    a="ABCDEFGHIEfGEFG"; // 15 chars
+    QCOMPARE(a.findRev('G'),14);
+//     QCOMPARE(a.findRev('G',-3),11);
+//     QCOMPARE(a.findRev('G',-5),6);
+    QCOMPARE(a.findRev('G',14),14);
+    QCOMPARE(a.findRev('G',13),11);
+    QCOMPARE(a.findRev('B'),1);
+    QCOMPARE(a.findRev('B',1),1);
+    QCOMPARE(a.findRev('B',0),-1);
+#if QT_VERSION < 0x040000
+    QCOMPARE(a.findRev("efg",99,FALSE),-1);
+//    QCOMPARE(a.findRev("efg",15,FALSE),-1);
+    QCOMPARE(a.findRev("efg",16,FALSE),-1);
+    QCOMPARE(a.findRev("efg",14,FALSE),12);
+    QCOMPARE(a.findRev("efg",12,FALSE),12);
+    QCOMPARE(a.findRev("efg",11,FALSE),9);
+#endif
+//    QCOMPARE(a.findRev(QRegExp("[EFG][EFG]"),14),13);
+//    QCOMPARE(a.findRev(QRegExp("[EFG][EFG]"),11),11);
+}
+
+void tst_Q3CString::contains()
+{
+    Q3CString a;
+    a="ABCDEFGHIEfGEFG"; // 15 chars
+#if QT_VERSION < 0x040000
+    QCOMPARE(a.contains('A'),1);
+    QCOMPARE(a.contains('Z'),0);
+    QCOMPARE(a.contains('E'),3);
+    QCOMPARE(a.contains('F'),2);
+    QCOMPARE(a.contains('F',FALSE),3);
+    QCOMPARE(a.contains("FG"),2);
+    QCOMPARE(a.contains("FG",FALSE),3);
+#else
+    QVERIFY(a.contains('A'));
+    QVERIFY(!a.contains('Z'));
+    QVERIFY(a.contains('E'));
+    QVERIFY(a.contains('F'));
+    QVERIFY(a.contains("FG"));
+    QCOMPARE(a.count('A'),1);
+    QCOMPARE(a.count('Z'),0);
+    QCOMPARE(a.count('E'),3);
+    QCOMPARE(a.count('F'),2);
+    QCOMPARE(a.count("FG"),2);
+#endif
+//    QCOMPARE(a.contains(QRegExp("[FG][HI]")),1);
+//    QCOMPARE(a.contains(QRegExp("[G][HE]")),2);
+}
+
+void tst_Q3CString::left()
+{
+    Q3CString a;
+    a="ABCDEFGHIEfGEFG"; // 15 chars
+    QCOMPARE(a.left(3),(Q3CString)"ABC");
+    QVERIFY(!a.left(0).isNull());
+    QCOMPARE(a.left(0),(Q3CString)"");
+
+    Q3CString n;
+    QVERIFY(n.left(3).isNull());
+    QVERIFY(n.left(0).isNull());
+    QVERIFY(n.left(0).isNull());
+}
+
+void tst_Q3CString::right()
+{
+    Q3CString a;
+    a="ABCDEFGHIEfGEFG"; // 15 chars
+    QCOMPARE(a.right(3),(Q3CString)"EFG");
+    QCOMPARE(a.right(0),(Q3CString)"");
+
+    Q3CString n;
+    QVERIFY(n.right(3).isNull());
+    QVERIFY(n.right(0).isNull());
+}
+
+void tst_Q3CString::mid()
+{
+    Q3CString a;
+    a="ABCDEFGHIEfGEFG"; // 15 chars
+
+    QCOMPARE(a.mid(3,3),(Q3CString)"DEF");
+    QCOMPARE(a.mid(0,0),(Q3CString)"");
+    QVERIFY(a.mid(9999).isNull());
+    QVERIFY(a.mid(9999,1).isNull());
+
+    Q3CString 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());
+}
+
+void tst_Q3CString::leftJustify()
+{
+    Q3CString a;
+    a="ABC";
+    QCOMPARE(a.leftJustify(5,'-'),(Q3CString)"ABC--");
+    QCOMPARE(a.leftJustify(4,'-'),(Q3CString)"ABC-");
+    QCOMPARE(a.leftJustify(4),(Q3CString)"ABC ");
+    QCOMPARE(a.leftJustify(3),(Q3CString)"ABC");
+    QCOMPARE(a.leftJustify(2),(Q3CString)"ABC");
+    QCOMPARE(a.leftJustify(1),(Q3CString)"ABC");
+    QCOMPARE(a.leftJustify(0),(Q3CString)"ABC");
+
+    Q3CString n;
+    QVERIFY(!n.leftJustify(3).isNull());    // I expected TRUE
+    QCOMPARE(a.leftJustify(4,' ',TRUE),(Q3CString)"ABC ");
+    QCOMPARE(a.leftJustify(3,' ',TRUE),(Q3CString)"ABC");
+    QCOMPARE(a.leftJustify(2,' ',TRUE),(Q3CString)"AB");
+    QCOMPARE(a.leftJustify(1,' ',TRUE),(Q3CString)"A");
+    QCOMPARE(a.leftJustify(0,' ',TRUE),(Q3CString)"");
+}
+
+void tst_Q3CString::rightJustify()
+{
+    Q3CString a;
+    a="ABC";
+    QCOMPARE(a.rightJustify(5,'-'),(Q3CString)"--ABC");
+    QCOMPARE(a.rightJustify(4,'-'),(Q3CString)"-ABC");
+    QCOMPARE(a.rightJustify(4),(Q3CString)" ABC");
+    QCOMPARE(a.rightJustify(3),(Q3CString)"ABC");
+    QCOMPARE(a.rightJustify(2),(Q3CString)"ABC");
+    QCOMPARE(a.rightJustify(1),(Q3CString)"ABC");
+    QCOMPARE(a.rightJustify(0),(Q3CString)"ABC");
+
+    Q3CString n;
+    QVERIFY(!n.rightJustify(3).isNull());  // I expected TRUE
+    QCOMPARE(a.rightJustify(4,'-',TRUE),(Q3CString)"-ABC");
+    QCOMPARE(a.rightJustify(4,' ',TRUE),(Q3CString)" ABC");
+    QCOMPARE(a.rightJustify(3,' ',TRUE),(Q3CString)"ABC");
+    QCOMPARE(a.rightJustify(2,' ',TRUE),(Q3CString)"AB");
+    QCOMPARE(a.rightJustify(1,' ',TRUE),(Q3CString)"A");
+    QCOMPARE(a.rightJustify(0,' ',TRUE),(Q3CString)"");
+    QCOMPARE(a,(Q3CString)"ABC");
+}
+
+void tst_Q3CString::upper()
+{
+    Q3CString a;
+    a="Text";
+    QCOMPARE(a.upper(),(Q3CString)"TEXT");
+}
+
+void tst_Q3CString::lower()
+{
+    Q3CString a;
+    a="Text";
+    QCOMPARE(a.lower(),(Q3CString)"text");
+}
+
+void tst_Q3CString::stripWhiteSpace()
+{
+    Q3CString a;
+    a="Text";
+    QCOMPARE(a,(Q3CString)"Text");
+    QCOMPARE(a.stripWhiteSpace(),(Q3CString)"Text");
+    QCOMPARE(a,(Q3CString)"Text");
+    a=" ";
+    QCOMPARE(a.stripWhiteSpace(),(Q3CString)"");
+    QCOMPARE(a,(Q3CString)" ");
+    a=" a   ";
+    QCOMPARE(a.stripWhiteSpace(),(Q3CString)"a");
+}
+
+void tst_Q3CString::simplifyWhiteSpace()
+{
+    Q3CString j;
+    j.simplifyWhiteSpace();
+
+    Q3CString a;
+    a = "a ";
+    QCOMPARE(a.simplifyWhiteSpace(),(Q3CString)"a");
+    a=" a   b ";
+    QCOMPARE(a.simplifyWhiteSpace(),(Q3CString)"a b");
+}
+
+void tst_Q3CString::insert()
+{
+    Q3CString a;
+    a = "Ys";
+    QCOMPARE(a.insert(1,'e'),(Q3CString)"Yes");
+    QCOMPARE(a.insert(3,'!'),(Q3CString)"Yes!");
+    QCOMPARE(a.insert(5,'?'),(Q3CString)"Yes! ?");
+
+    a="ABC";
+    QCOMPARE(a.insert(5,"DEF"),(Q3CString)"ABC  DEF");
+    a="ABC";
+    QCOMPARE(a.insert(0,"ABC"),(Q3CString)"ABCABC");
+    QCOMPARE(a,(Q3CString)"ABCABC");
+
+    // ######### Q3CString::insert is not safe against self insertion...
+//     Q3CString res = "ABCABCABCABC";
+//     QCOMPARE(a.insert(0,a),res);
+    a += "ABCABC";
+    Q3CString res = "ABCABCABCABC";
+    QCOMPARE(a, res);
+    res = "<ABCABCABCABC";
+    QCOMPARE(a.insert(0,'<'),res );
+    res = "<>ABCABCABCABC";
+    QCOMPARE(a.insert(1,'>'),res );
+}
+
+void tst_Q3CString::append()
+{
+    Q3CString a;
+    a = "<>ABCABCABCABC";
+    QCOMPARE(a.append(">"),(Q3CString)"<>ABCABCABCABC>");
+}
+
+void tst_Q3CString::prepend()
+{
+    Q3CString a;
+    a = "<>ABCABCABCABC>";
+    QCOMPARE(a.prepend("-"),(Q3CString)"-<>ABCABCABCABC>");
+}
+
+void tst_Q3CString::replace_uint_uint()
+{
+    QFETCH( Q3CString, string );
+    QFETCH( int, index );
+    QFETCH( int, len );
+    QFETCH( Q3CString, after );
+
+    Q3CString s1 = string;
+    s1.replace( (uint) index, (int) len, after );
+    QFETCH( Q3CString, result );
+    QVERIFY( s1 == result );
+
+    Q3CString s2 = string;
+    s2.replace( (uint) index, (uint) len, after );
+    QVERIFY( s2 == result );
+
+}
+
+void tst_Q3CString::replace_string()
+{
+#if QT_VERSION >= 0x030100
+    QFETCH( Q3CString, string );
+    QFETCH( Q3CString, before );
+    QFETCH( Q3CString, after );
+    QFETCH( Q3CString, result );
+
+    if ( before.length() == 1 ) {
+	char ch = before[0];
+
+	Q3CString s1 = string;
+	s1.replace( ch, after );
+	QCOMPARE( s1, result );
+    }
+
+    Q3CString s3 = string;
+    s3.replace( before, after );
+    QCOMPARE( s3, result );
+
+#if QT_VERSION < 0x040000
+    if ( !string.isNull() ) {
+	/*
+	  I've changed the isNull() behavior in QString::replace() in
+	  Qt 3.2, according to the philosophy that null and empty
+	  should behave mostly the same.
+	*/
+	Q3CString s4 = string;
+	s4.replace( QRegExp(QRegExp::escape(before)), after );
+	QVERIFY( s4 == result );
+    }
+#endif
+#else
+    QSKIP( "Not tested with Qt versions < 3.1", SkipAll);
+#endif
+}
+
+void tst_Q3CString::replace_regexp()
+{
+#if QT_VERSION >= 0x040000
+    QSKIP("This functionality has been removed in Qt 4.", SkipAll);
+#else
+    QFETCH( Q3CString, string );
+    QFETCH( Q3CString, regexp );
+    QFETCH( Q3CString, after );
+    QFETCH( Q3CString, result );
+
+    string.replace( QRegExp(regexp), after );
+    QVERIFY( string == result );
+#endif
+}
+
+void tst_Q3CString::remove_uint_uint()
+{
+    QFETCH( Q3CString, string );
+    QFETCH( int, index );
+    QFETCH( int, len );
+    QFETCH( Q3CString, after );
+    QFETCH( Q3CString, result );
+
+    if ( after.length() == 0 ) {
+	Q3CString s1 = string;
+	s1.remove( (uint) index, (uint) len );
+	QVERIFY( s1 == result );
+    } else {
+	QSKIP("Test data applies only to replace_uint_uint(), not remove_uint_uint()", SkipSingle);
+    }
+}
+
+void tst_Q3CString::check_QDataStream()
+{
+    Q3CString a;
+    QByteArray ar;
+    {
+	QDataStream out(&ar,QIODevice::WriteOnly);
+	out << Q3CString("COMPARE Text");
+    }
+    {
+        QDataStream in(&ar,QIODevice::ReadOnly);
+        in >> a;
+        QCOMPARE(a,(Q3CString)"COMPARE Text");
+    }
+}
+
+void tst_Q3CString::check_QTextStream()
+{
+    Q3CString a;
+    QByteArray ar;
+    {
+	QTextStream out(&ar,QIODevice::WriteOnly);
+	out << Q3CString("This is COMPARE Text");
+    }
+    {
+	QTextStream in(&ar,QIODevice::ReadOnly);
+	in >> a;
+	QCOMPARE(a,(Q3CString)"This");
+    }
+}
+
+void tst_Q3CString::setExpand()
+{
+    Q3CString a;
+    a="ABC";
+    a.setExpand(0,'X');
+    QCOMPARE(a,(Q3CString)"XBC");
+    a.setExpand(4,'Z');
+    QCOMPARE(a,(Q3CString)"XBC Z");
+    a.setExpand(3,'Y');
+    QCOMPARE(a,(Q3CString)"XBCYZ");
+}
+
+
+QTEST_APPLESS_MAIN(tst_Q3CString)
+#include "tst_q3cstring.moc"