Long live Qt 4.5!

3 files changed, 1355 insertions, 0 deletions

diff --git a/tests/auto/q3textstream/.gitignore b/tests/auto/q3textstream/.gitignore
new file mode 100644
index 0000000..255c330
--- /dev/null
+++ b/tests/auto/q3textstream/.gitignore
@@ -0,0 +1,2 @@
+tst_q3textstream
+q3textstream.out
diff --git a/tests/auto/q3textstream/q3textstream.pro b/tests/auto/q3textstream/q3textstream.pro
new file mode 100644
index 0000000..7c80af7
--- /dev/null
+++ b/tests/auto/q3textstream/q3textstream.pro
@@ -0,0 +1,6 @@
+load(qttest_p4)
+SOURCES  += tst_q3textstream.cpp
+QT += qt3support
+MOC_DIR=tmp
+
+
diff --git a/tests/auto/q3textstream/tst_q3textstream.cpp b/tests/auto/q3textstream/tst_q3textstream.cpp
new file mode 100644
index 0000000..7932b79
--- /dev/null
+++ b/tests/auto/q3textstream/tst_q3textstream.cpp
@@ -0,0 +1,1347 @@
+/****************************************************************************
+**
+** 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 <QtCore/QtCore>
+#include <QtTest/QtTest>
+#include <Qt3Support/Q3TextStream>
+
+Q_DECLARE_METATYPE(Q3CString)
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_Q3TextStream : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_Q3TextStream();
+    virtual ~tst_Q3TextStream();
+
+public slots:
+    void init();
+    void cleanup();
+
+private slots:
+    void operator_shiftleft_data();
+    void operator_shiftleft();
+    void operator_shiftright_data();
+    void operator_shiftright();
+
+    void operator_shift_QChar_data();
+    void operator_shift_QChar();
+    void operator_shift_char_data();
+    void operator_shift_char();
+    void operator_shift_short_data();
+    void operator_shift_short();
+    void operator_shift_ushort_data();
+    void operator_shift_ushort();
+    void operator_shift_int_data();
+    void operator_shift_int();
+    void operator_shift_uint_data();
+    void operator_shift_uint();
+    void operator_shift_long_data();
+    void operator_shift_long();
+    void operator_shift_ulong_data();
+    void operator_shift_ulong();
+    void operator_shift_float_data();
+    void operator_shift_float();
+    void operator_shift_double_data();
+    void operator_shift_double();
+    void operator_shift_QString_data();
+    void operator_shift_QString();
+    void operator_shift_Q3CString_data();
+    void operator_shift_Q3CString();
+
+    void QTextCodecCodecForIndex() const;
+
+    void atEnd();
+    void eof();
+    void precision();
+    
+    void task28319();
+
+private:
+    void createWriteStream( Q3TextStream *&os );
+    void closeWriteStream( Q3TextStream *os );
+    void createReadStream( Q3TextStream *&is );
+    void closeReadStream( Q3TextStream *is );
+
+    void read_QChar( Q3TextStream *s );
+    void write_QChar( Q3TextStream *s );
+    void read_char( Q3TextStream *s );
+    void write_char( Q3TextStream *s );
+    void read_short( Q3TextStream *s );
+    void write_short( Q3TextStream *s );
+    void read_ushort( Q3TextStream *s );
+    void write_ushort( Q3TextStream *s );
+    void read_int( Q3TextStream *s );
+    void write_int( Q3TextStream *s );
+    void read_uint( Q3TextStream *s );
+    void write_uint( Q3TextStream *s );
+    void read_long( Q3TextStream *s );
+    void write_long( Q3TextStream *s );
+    void read_ulong( Q3TextStream *s );
+    void write_ulong( Q3TextStream *s );
+    void read_float( Q3TextStream *s );
+    void write_float( Q3TextStream *s );
+    void read_double( Q3TextStream *s );
+    void write_double( Q3TextStream *s );
+    void read_QString( Q3TextStream *s );
+    void write_QString( Q3TextStream *s );
+    void read_Q3CString( Q3TextStream *s );
+    void write_Q3CString( Q3TextStream *s );
+
+    void operatorShift_data();
+
+    void do_shiftleft( Q3TextStream *ts );
+    Q3TextStream::Encoding toEncoding( const QString& );
+    QString decodeString( QByteArray array, const QString& encoding );
+
+    Q3TextStream *os;
+    Q3TextStream *is;
+    Q3TextStream *ts;
+    QFile *inFile;
+    QFile *outFile;
+    QByteArray *inArray;
+    QBuffer *inBuffer;
+    QString *inString;
+    bool file_is_empty;
+};
+
+tst_Q3TextStream::tst_Q3TextStream()
+{
+    ts = 0;
+    os = 0;
+    is = 0;
+    outFile = 0;
+    inFile = 0;
+    inArray = 0;
+    inBuffer = 0;
+    inString = 0;
+    file_is_empty = FALSE;
+}
+
+tst_Q3TextStream::~tst_Q3TextStream()
+{
+}
+
+void tst_Q3TextStream::init()
+{
+    ts = 0;
+    os = 0;
+    is = 0;
+    inFile = 0;
+    outFile = 0;
+    inArray = 0;
+    inBuffer = 0;
+    inString = 0;
+    file_is_empty = FALSE;
+}
+
+void tst_Q3TextStream::cleanup()
+{
+    delete ts;
+    ts = 0;
+    delete os;
+    os = 0;
+    delete is;
+    is = 0;
+    delete inFile;
+    inFile = 0;
+    delete outFile;
+    outFile = 0;
+    delete inArray;
+    inArray = 0;
+    delete inBuffer;
+    inBuffer = 0;
+    delete inString;
+    inString = 0;
+}
+
+void tst_Q3TextStream::operator_shiftright_data()
+{
+    operatorShift_data();
+}
+
+void tst_Q3TextStream::operator_shiftleft_data()
+{
+    operatorShift_data();
+}
+
+static const double doubleDummy = 567.89;
+static const int intDummy = 1234;
+static const QString stringDummy = "ABCD";
+
+static const char * const devices[] = {
+    "file",
+    "bytearray",
+    "buffer",
+    "string",
+    0
+};
+
+static const char * const encodings[] = {
+    "Locale",
+    "Latin1",
+    "Unicode",
+    "UnicodeNetworkOrder",
+    "UnicodeReverse",
+    "RawUnicode",
+    "UnicodeUTF8",
+    0
+};
+
+void tst_Q3TextStream::operatorShift_data()
+{
+    QTest::addColumn<QString>( "device" );
+    QTest::addColumn<QString>( "encoding" );
+    QTest::addColumn<QString>( "type" );
+    QTest::addColumn<double>( "doubleVal" );
+    QTest::addColumn<int>( "intVal" );
+    QTest::addColumn<QString>( "stringVal" );
+    QTest::addColumn<QByteArray>( "encoded" );
+
+    for ( int i=0; devices[i] != 0; i++ ) {
+	QString dev = devices[i];
+
+	/*
+	  We first test each type at least once.
+	*/
+	QTest::newRow( dev + "0" ) << dev << QString("UnicodeUTF8") << QString("QChar")
+		<< doubleDummy << (int) 'Z' << stringDummy
+		<< QByteArray( Q3CString("Z") );
+	QTest::newRow( dev + "1" ) << dev << QString("UnicodeUTF8") << QString("char")
+		<< doubleDummy << (int) 'Z' << stringDummy
+		<< QByteArray( Q3CString("Z") );
+	QTest::newRow( dev + "2" ) << dev << QString("UnicodeUTF8") << QString("signed short")
+		<< doubleDummy << 12345 << stringDummy
+		<< QByteArray( Q3CString("12345") );
+	QTest::newRow( dev + "3" ) << dev << QString("UnicodeUTF8") << QString("unsigned short")
+		<< doubleDummy << 12345 << stringDummy
+		<< QByteArray( Q3CString("12345") );
+	QTest::newRow( dev + "4" ) << dev << QString("UnicodeUTF8") << QString("signed int")
+		<< doubleDummy << 12345 << stringDummy
+		<< QByteArray( Q3CString("12345") );
+	QTest::newRow( dev + "5" ) << dev << QString("UnicodeUTF8") << QString("unsigned int")
+		<< doubleDummy << 12345 << stringDummy
+		<< QByteArray( Q3CString("12345") );
+	QTest::newRow( dev + "6" ) << dev << QString("UnicodeUTF8") << QString("signed long")
+		<< doubleDummy << 12345 << stringDummy
+		<< QByteArray( Q3CString("12345") );
+	QTest::newRow( dev + "7" ) << dev << QString("UnicodeUTF8") << QString("unsigned long")
+		<< doubleDummy << 12345 << stringDummy
+		<< QByteArray( Q3CString("12345") );
+	QTest::newRow( dev + "8" ) << dev << QString("UnicodeUTF8") << QString("float")
+		<< (double)3.1415f << intDummy << stringDummy
+		<< QByteArray( Q3CString("3.1415") );
+	QTest::newRow( dev + "9" ) << dev << QString("UnicodeUTF8") << QString("double")
+		<< 3.1415 << intDummy << stringDummy
+		<< QByteArray( Q3CString("3.1415") );
+	QTest::newRow( dev + "10" ) << dev << QString("UnicodeUTF8") << QString("char *")
+		<< doubleDummy << intDummy << QString("I-am-a-string")
+		<< QByteArray( Q3CString("I-am-a-string") );
+	QTest::newRow( dev + "11" ) << dev << QString("UnicodeUTF8") << QString("QString")
+		<< doubleDummy << intDummy << QString("I-am-a-string")
+		<< QByteArray( Q3CString("I-am-a-string") );
+	QTest::newRow( dev + "12" ) << dev << QString("UnicodeUTF8") << QString("Q3CString")
+		<< doubleDummy << intDummy << QString("I-am-a-string")
+		<< QByteArray( Q3CString("I-am-a-string") );
+
+	/*
+	  Then we test some special cases that have caused problems in the past.
+	*/
+	QTest::newRow( dev + "20" ) << dev << QString("UnicodeUTF8") << QString("QChar")
+		<< doubleDummy << 0xff8c << stringDummy
+		<< QByteArray( Q3CString("\xef\xbe\x8c") );
+	QTest::newRow( dev + "21" ) << dev << QString("UnicodeUTF8") << QString("QChar")
+		<< doubleDummy << 0x8cff << stringDummy
+		<< QByteArray( Q3CString("\xe8\xb3\xbf") );
+    }
+}
+
+void tst_Q3TextStream::do_shiftleft( Q3TextStream *ts )
+{
+    QFETCH( QString, encoding );
+    QFETCH( QString, type );
+    QFETCH( double,  doubleVal );
+    QFETCH( int, intVal );
+    QFETCH( QString,  stringVal );
+
+    ts->setEncoding( toEncoding(encoding) );
+
+    if ( type == "QChar" ) {
+	if ( intVal >= 0 && intVal <= 0xffff )
+	    *ts << QChar( intVal );
+    } else if ( type == "char" ) {
+	*ts << (char) intVal;
+    } else if ( type == "signed short" ) {
+	*ts << (signed short) intVal;
+    } else if ( type == "unsigned short" ) {
+	*ts << (unsigned short) intVal;
+    } else if ( type == "signed int" ) {
+	*ts << (signed int) intVal;
+    } else if ( type == "unsigned int" ) {
+	*ts << (unsigned int) intVal;
+    } else if ( type == "signed long" ) {
+	*ts << (signed long) intVal;
+    } else if ( type == "unsigned long" ) {
+	*ts << (unsigned long) intVal;
+    } else if ( type == "float" ) {
+	*ts << (float) doubleVal;
+    } else if ( type == "double" ) {
+	*ts << (double) doubleVal;
+    } else if ( type == "char *" ) {
+	*ts << stringVal.latin1();
+    } else if ( type == "QString" ) {
+	*ts << stringVal;
+    } else if ( type == "Q3CString" ) {
+	*ts << Q3CString( stringVal.latin1() );
+    } else {
+	qWarning( "Unknown type: %s" + type );
+    }
+}
+
+void tst_Q3TextStream::operator_shiftleft()
+{
+    QFETCH( QString, device );
+    QFETCH( QString, encoding );
+    QFETCH( QByteArray, encoded );
+#if QT_VERSION < 0x040000
+    encoded.resize( encoded.size() - 1 );
+#endif
+
+    if ( device == "file" ) {
+	QFile outFile( "qtextstream.out" );
+	QVERIFY( outFile.open( IO_WriteOnly ) );
+	Q3TextStream ts( &outFile );
+
+	do_shiftleft( &ts );
+	outFile.close();
+
+	QFile inFile( "qtextstream.out" );
+	QVERIFY( inFile.open( IO_ReadOnly ) );
+	QCOMPARE( inFile.readAll(), encoded );
+    } else if ( device == "bytearray" ) {
+	QByteArray outArray;
+	Q3TextStream ts( outArray, IO_WriteOnly );
+
+	do_shiftleft( &ts );
+
+	QCOMPARE( outArray, encoded );
+    } else if ( device == "buffer" ) {
+	QByteArray outArray;
+	QBuffer outBuffer;
+        outBuffer.setBuffer( &outArray );
+	QVERIFY( outBuffer.open(IO_WriteOnly) );
+	Q3TextStream ts( &outBuffer );
+
+	do_shiftleft( &ts );
+
+	QCOMPARE( outArray, encoded );
+    } else if ( device == "string" ) {
+	QString outString;
+	Q3TextStream ts( &outString, IO_WriteOnly );
+
+	do_shiftleft( &ts );
+
+	QString decodedString = decodeString( encoded, encoding );
+	QCOMPARE( outString, decodedString );
+    } else {
+	qWarning( "Unknown device type: " + device );
+    }
+}
+
+void tst_Q3TextStream::operator_shiftright()
+{
+    QFETCH( QString, device );
+    QFETCH( QString, encoding );
+    QFETCH( QString, type );
+    QFETCH( double,  doubleVal );
+    QFETCH( int, intVal );
+    QFETCH( QString,  stringVal );
+    QFETCH( QByteArray, encoded );
+#if QT_VERSION < 0x040000
+    encoded.resize( encoded.size() - 1 );
+#endif
+
+    if ( device == "file" ) {
+	QFile outFile( "qtextstream.out" );
+	QVERIFY( outFile.open( IO_WriteOnly ) );
+	QCOMPARE( (int) outFile.writeBlock(encoded), encoded.size() );
+	outFile.close();
+
+	inFile = new QFile( "qtextstream.out" );
+	QVERIFY( inFile->open( IO_ReadOnly ) );
+	ts = new Q3TextStream( inFile );
+    } else if ( device == "bytearray" ) {
+	ts = new Q3TextStream( encoded, IO_ReadOnly );
+    } else if ( device == "buffer" ) {
+	inBuffer = new QBuffer;
+        inBuffer->setData( encoded );
+	QVERIFY( inBuffer->open(IO_ReadOnly) );
+	ts = new Q3TextStream( inBuffer );
+    } else if ( device == "string" ) {
+	inString = new QString( decodeString(encoded, encoding) );
+	ts = new Q3TextStream( inString, IO_ReadOnly );
+    } else {
+	qWarning( "Unknown device type: " + device );
+    }
+
+    ts->setEncoding( toEncoding(encoding) );
+
+    if ( type == "QChar" ) {
+	QChar c;
+	if ( intVal >= 0 && intVal <= 0xffff )
+	    *ts >> c;
+	QCOMPARE( c, QChar(intVal) );
+    } else if ( type == "char" ) {
+	char c;
+	*ts >> c;
+	QVERIFY( c == (char) intVal );
+    } else if ( type == "signed short" ) {
+	signed short h;
+	*ts >> h;
+	QVERIFY( h == (signed short) intVal );
+    } else if ( type == "unsigned short" ) {
+	unsigned short h;
+	*ts >> h;
+	QVERIFY( h == (unsigned short) intVal );
+    } else if ( type == "signed int" ) {
+	signed int i;
+	*ts >> i;
+	QVERIFY( i == (signed int) intVal );
+    } else if ( type == "unsigned int" ) {
+	unsigned int i;
+	*ts >> i;
+	QVERIFY( i == (unsigned int) intVal );
+    } else if ( type == "signed long" ) {
+	signed long ell;
+	*ts >> ell;
+	QVERIFY( ell == (signed long) intVal );
+    } else if ( type == "unsigned long" ) {
+	unsigned long ell;
+	*ts >> ell;
+	QVERIFY( ell == (unsigned long) intVal );
+    } else if ( type == "float" ) {
+	float f;
+	*ts >> f;
+	QVERIFY( f == (float) doubleVal );
+    } else if ( type == "double" ) {
+	double d;
+	*ts >> d;
+	QVERIFY( d == (double) doubleVal );
+    } else if ( type == "char *" ) {
+	char *cp = new char[2048];
+	*ts >> cp;
+	QVERIFY( qstrcmp(cp, stringVal.latin1()) == 0 );
+	delete[] cp;
+    } else if ( type == "QString" ) {
+	QString s;
+	*ts >> s;
+	QCOMPARE( s, stringVal );
+    } else if ( type == "Q3CString" ) {
+	Q3CString s;
+	*ts >> s;
+	QCOMPARE( QString::fromLatin1(s), stringVal );
+    } else {
+	qWarning( "Unknown type: %s" + type );
+    }
+}
+
+Q3TextStream::Encoding tst_Q3TextStream::toEncoding( const QString &str )
+{
+    if ( str == "Locale" )
+	return Q3TextStream::Locale;
+    else if ( str == "Latin1" )
+	return Q3TextStream::Latin1;
+    else if ( str == "Unicode" )
+	return Q3TextStream::Unicode;
+    else if ( str == "UnicodeNetworkOrder" )
+	return Q3TextStream::UnicodeNetworkOrder;
+    else if ( str == "UnicodeReverse" )
+	return Q3TextStream::UnicodeReverse;
+    else if ( str == "RawUnicode" )
+	return Q3TextStream::RawUnicode;
+    else if ( str == "UnicodeUTF8" )
+	return Q3TextStream::UnicodeUTF8;
+
+    qWarning( "No such encoding " + str );
+    return Q3TextStream::Latin1;
+}
+
+QString tst_Q3TextStream::decodeString( QByteArray array, const QString& encoding )
+{
+    switch ( toEncoding(encoding) ) {
+    case Q3TextStream::Locale:
+	return QString::fromLocal8Bit( array.data(), array.size() );
+    case Q3TextStream::Latin1:
+	return QString::fromLatin1( array.data(), array.size() );
+    case Q3TextStream::Unicode:
+    case Q3TextStream::UnicodeNetworkOrder:
+    case Q3TextStream::UnicodeReverse:
+    case Q3TextStream::RawUnicode:
+	qWarning( "Unicode not implemented ###" );
+	return QString();
+    case Q3TextStream::UnicodeUTF8:
+	return QString::fromUtf8( array.data(), array.size() );
+    default:
+	return QString();
+    }
+}
+
+// ************************************************
+
+void tst_Q3TextStream::createWriteStream( Q3TextStream *&os )
+{
+    QFETCH( QString, device );
+
+    if ( device == "file" ) {
+	outFile = new QFile( "qtextstream.out" );
+	QVERIFY( outFile->open( IO_WriteOnly ) );
+	os = new Q3TextStream( outFile );
+    } else if ( device == "bytearray" ) {
+	inArray = new QByteArray;
+	os = new Q3TextStream( *inArray, IO_WriteOnly );
+    } else if ( device == "buffer" ) {
+	inBuffer = new QBuffer;
+	QVERIFY( inBuffer->open(IO_WriteOnly) );
+	os = new Q3TextStream( inBuffer );
+    } else if ( device == "string" ) {
+	inString = new QString;
+	os = new Q3TextStream( inString, IO_WriteOnly );
+    } else {
+	qWarning( "Error creating write stream: Unknown device type '" + device + "'" );
+    }
+
+    QFETCH( QString, encoding );
+    os->setEncoding( toEncoding( encoding ));
+}
+
+void tst_Q3TextStream::closeWriteStream( Q3TextStream *os )
+{
+    QFETCH( QString, device );
+
+    if ( os->device() )
+	os->device()->close();
+}
+
+void tst_Q3TextStream::createReadStream( Q3TextStream *&is )
+{
+    QFETCH( QString, device );
+
+    if ( device == "file" ) {
+	inFile = new QFile( "qtextstream.out" );
+	QVERIFY( inFile->open( IO_ReadOnly ) );
+	is = new Q3TextStream( inFile );
+    } else if ( device == "bytearray" ) {
+	is = new Q3TextStream( *inArray, IO_ReadOnly );
+    } else if ( device == "buffer" ) {
+	QVERIFY( inBuffer->open(IO_ReadOnly) );
+	is = new Q3TextStream( inBuffer );
+    } else if ( device == "string" ) {
+	is = new Q3TextStream( inString, IO_ReadOnly );
+    } else {
+	qWarning( "Error creating read stream: Unknown device type '" + device + "'" );
+    }
+
+    QFETCH( QString, encoding );
+    is->setEncoding( toEncoding( encoding ));
+
+    if (!file_is_empty) {
+	QVERIFY( !is->atEnd() );
+	QVERIFY( !is->eof() );
+    }
+}
+
+void tst_Q3TextStream::closeReadStream( Q3TextStream *is )
+{
+    QVERIFY( is->atEnd() );
+    QVERIFY( is->eof() );
+
+    if ( is->device() )
+	is->device()->close();
+}
+
+void tst_Q3TextStream::precision()
+{
+}
+
+void tst_Q3TextStream::atEnd()
+{
+    // atEnd is actually tested in all the operator_shift*functions
+    // but it's sufficient to mention one here.
+}
+
+void tst_Q3TextStream::eof()
+{
+    // eof is obsolete, but as long as it's supported it should work.
+    // eof is actually tested in all the operator_shift*functions
+    // but it's sufficient to mention one here.
+}
+
+// **************** QChar ****************
+
+void tst_Q3TextStream::operator_shift_QChar_data()
+{
+    QTest::addColumn<QString>( "device" );
+    QTest::addColumn<QString>( "encoding" );
+    QTest::addColumn<ushort>( "qchar" );
+
+    for ( int d=0; devices[d] != 0; d++ ) {
+	QString device = devices[d];
+	for ( int e=0; encodings[e] != 0; e++ ) {
+	    QString encoding = encodings[e];
+
+	    QString tag = device + "_" + encoding + "_";
+	    QTest::newRow( tag + "0" ) << device << encoding << QChar( 'A' ).unicode();
+	    QTest::newRow( tag + "1" ) << device << encoding << QChar( 'B' ).unicode();
+	    QTest::newRow( tag + "2" ) << device << encoding << QChar( 'Z' ).unicode();
+	    QTest::newRow( tag + "3" ) << device << encoding << QChar( 'z' ).unicode();
+	    QTest::newRow( tag + "4" ) << device << encoding << QChar( '@' ).unicode();
+	}
+    }
+}
+
+void tst_Q3TextStream::operator_shift_QChar()
+{
+// Uncomment the qDebug and you'll see all the combinations we actually run :-))
+//    qDebug( data()->dataTag() );
+
+    createWriteStream( os );
+    write_QChar( os );
+    closeWriteStream( os );
+
+    createReadStream( is );
+    read_QChar( is );
+    closeReadStream( is );
+}
+
+void tst_Q3TextStream::read_QChar( Q3TextStream *s )
+{
+    QFETCH( ushort, qchar );
+    QChar expected( qchar );
+    QChar actual;
+    *s >> actual;
+    QVERIFY( actual == expected );
+}
+
+void tst_Q3TextStream::write_QChar( Q3TextStream *s )
+{
+    QFETCH( ushort, qchar );
+    QChar actual( qchar );
+    *s << actual;
+}
+
+// **************** char ****************
+
+void tst_Q3TextStream::operator_shift_char_data()
+{
+    QTest::addColumn<QString>( "device" );
+    QTest::addColumn<QString>( "encoding" );
+    QTest::addColumn<int>( "ch" );
+
+    for ( int d=0; devices[d] != 0; d++ ) {
+	QString device = devices[d];
+	for ( int e=0; encodings[e] != 0; e++ ) {
+	    QString encoding = encodings[e];
+
+	    QString tag = device + "_" + encoding + "_";
+	    QTest::newRow( tag + "0" ) << device << encoding << int('A');
+	    QTest::newRow( tag + "1" ) << device << encoding << int('B');
+	    QTest::newRow( tag + "2" ) << device << encoding << int('Z');
+	    QTest::newRow( tag + "3" ) << device << encoding << int(14);
+	    QTest::newRow( tag + "4" ) << device << encoding << int('0');
+	}
+    }
+}
+
+void tst_Q3TextStream::operator_shift_char()
+{
+    createWriteStream( os );
+    write_char( os );
+    closeWriteStream( os );
+
+    createReadStream( is );
+    read_char( is );
+    closeReadStream( is );
+}
+
+void tst_Q3TextStream::read_char( Q3TextStream *s )
+{
+    QFETCH( int, ch );
+    char c(ch);
+    char exp;
+    *s >> exp;
+    QCOMPARE( exp, c );
+}
+
+void tst_Q3TextStream::write_char( Q3TextStream *s )
+{
+    QFETCH( int, ch );
+    char c(ch);
+    *s << c;
+}
+
+// **************** short ****************
+
+void tst_Q3TextStream::operator_shift_short_data()
+{
+    QTest::addColumn<QString>( "device" );
+    QTest::addColumn<QString>( "encoding" );
+    QTest::addColumn<short>( "ss" );
+
+    for ( int d=0; devices[d] != 0; d++ ) {
+	QString device = devices[d];
+	for ( int e=0; encodings[e] != 0; e++ ) {
+	    QString encoding = encodings[e];
+
+	    QString tag = device + "_" + encoding + "_";
+	    QTest::newRow( tag + "0" ) << device << encoding << short(0);
+	    QTest::newRow( tag + "1" ) << device << encoding << short(-1);
+	    QTest::newRow( tag + "2" ) << device << encoding << short(1);
+	    QTest::newRow( tag + "3" ) << device << encoding << short(255);
+	    QTest::newRow( tag + "4" ) << device << encoding << short(-254);
+	}
+    }
+}
+
+void tst_Q3TextStream::operator_shift_short()
+{
+    createWriteStream( os );
+    write_short( os );
+    closeWriteStream( os );
+
+    createReadStream( is );
+    read_short( is );
+    closeReadStream( is );
+}
+
+void tst_Q3TextStream::read_short( Q3TextStream *s )
+{
+    QFETCH( short, ss );
+    short exp;
+    QString A, B;
+    *s >> A >> exp >> B;
+    QCOMPARE( A, QString("A") );
+    QCOMPARE( B, QString("B") );
+    QCOMPARE( exp, ss );
+    s->skipWhiteSpace();
+}
+
+void tst_Q3TextStream::write_short( Q3TextStream *s )
+{
+    QFETCH( short, ss );
+    *s << " A " << ss << " B ";
+}
+
+// **************** ushort ****************
+
+void tst_Q3TextStream::operator_shift_ushort_data()
+{
+    QTest::addColumn<QString>( "device" );
+    QTest::addColumn<QString>( "encoding" );
+    QTest::addColumn<ushort>( "us" );
+
+    for ( int d=0; devices[d] != 0; d++ ) {
+	QString device = devices[d];
+	for ( int e=0; encodings[e] != 0; e++ ) {
+	    QString encoding = encodings[e];
+
+	    QString tag = device + "_" + encoding + "_";
+	    QTest::newRow( tag + "0" ) << device << encoding << ushort(0);
+	    QTest::newRow( tag + "1" ) << device << encoding << ushort(1);
+	    QTest::newRow( tag + "2" ) << device << encoding << ushort(10);
+	    QTest::newRow( tag + "3" ) << device << encoding << ushort(255);
+	    QTest::newRow( tag + "4" ) << device << encoding << ushort(512);
+	}
+    }
+}
+
+void tst_Q3TextStream::operator_shift_ushort()
+{
+    createWriteStream( os );
+    write_ushort( os );
+    closeWriteStream( os );
+
+    createReadStream( is );
+    read_ushort( is );
+    closeReadStream( is );
+}
+
+void tst_Q3TextStream::read_ushort( Q3TextStream *s )
+{
+    QFETCH( ushort, us );
+    ushort exp;
+    QString A, B;
+    *s >> A >> exp >> B;
+    QCOMPARE( A, QString("A") );
+    QCOMPARE( B, QString("B") );
+    QCOMPARE( exp, us );
+    s->skipWhiteSpace();
+}
+
+void tst_Q3TextStream::write_ushort( Q3TextStream *s )
+{
+    QFETCH( ushort, us );
+    *s << " A " << us << " B ";
+}
+
+// **************** int ****************
+
+void tst_Q3TextStream::operator_shift_int_data()
+{
+    QTest::addColumn<QString>( "device" );
+    QTest::addColumn<QString>( "encoding" );
+    QTest::addColumn<int>( "si" );
+
+    for ( int d=0; devices[d] != 0; d++ ) {
+	QString device = devices[d];
+	for ( int e=0; encodings[e] != 0; e++ ) {
+	    QString encoding = encodings[e];
+
+	    QString tag = device + "_" + encoding + "_";
+	    QTest::newRow( tag + "0" ) << device << encoding << int(0);
+	    QTest::newRow( tag + "1" ) << device << encoding << int(1);
+	    QTest::newRow( tag + "2" ) << device << encoding << int(10);
+	    QTest::newRow( tag + "3" ) << device << encoding << int(255);
+	    QTest::newRow( tag + "4" ) << device << encoding << int(512);
+	    QTest::newRow( tag + "5" ) << device << encoding << int(-1);
+	    QTest::newRow( tag + "6" ) << device << encoding << int(-10);
+	    QTest::newRow( tag + "7" ) << device << encoding << int(-255);
+	    QTest::newRow( tag + "8" ) << device << encoding << int(-512);
+	}
+    }
+}
+
+void tst_Q3TextStream::operator_shift_int()
+{
+    createWriteStream( os );
+    write_int( os );
+    closeWriteStream( os );
+
+    createReadStream( is );
+    read_int( is );
+    closeReadStream( is );
+}
+
+void tst_Q3TextStream::read_int( Q3TextStream *s )
+{
+    QFETCH( int, si );
+    int exp;
+    QString A, B;
+    *s >> A >> exp >> B;
+    QCOMPARE( A, QString("A") );
+    QCOMPARE( B, QString("B") );
+    QCOMPARE( exp, si );
+    s->skipWhiteSpace();
+}
+
+void tst_Q3TextStream::write_int( Q3TextStream *s )
+{
+    QFETCH( int, si );
+    *s << " A " << si << " B ";
+}
+
+// **************** uint ****************
+
+void tst_Q3TextStream::operator_shift_uint_data()
+{
+    QTest::addColumn<QString>( "device" );
+    QTest::addColumn<QString>( "encoding" );
+    QTest::addColumn<uint>( "ui" );
+
+    for ( int d=0; devices[d] != 0; d++ ) {
+	QString device = devices[d];
+	for ( int e=0; encodings[e] != 0; e++ ) {
+	    QString encoding = encodings[e];
+
+	    QString tag = device + "_" + encoding + "_";
+	    QTest::newRow( tag + "0" ) << device << encoding << uint(0);
+	    QTest::newRow( tag + "1" ) << device << encoding << uint(1);
+	    QTest::newRow( tag + "2" ) << device << encoding << uint(10);
+	    QTest::newRow( tag + "3" ) << device << encoding << uint(255);
+	    QTest::newRow( tag + "4" ) << device << encoding << uint(512);
+	}
+    }
+}
+
+void tst_Q3TextStream::operator_shift_uint()
+{
+    createWriteStream( os );
+    write_uint( os );
+    closeWriteStream( os );
+
+    createReadStream( is );
+    read_uint( is );
+    closeReadStream( is );
+}
+
+void tst_Q3TextStream::read_uint( Q3TextStream *s )
+{
+    QFETCH( uint, ui );
+    uint exp;
+    QString A, B;
+    *s >> A >> exp >> B;
+    QCOMPARE( A, QString("A") );
+    QCOMPARE( B, QString("B") );
+    QCOMPARE( exp, ui );
+    s->skipWhiteSpace();
+}
+
+void tst_Q3TextStream::write_uint( Q3TextStream *s )
+{
+    QFETCH( uint, ui );
+    *s << " A " << ui << " B ";
+}
+
+// **************** long ****************
+
+void tst_Q3TextStream::operator_shift_long_data()
+{
+    QTest::addColumn<QString>( "device" );
+    QTest::addColumn<QString>( "encoding" );
+    QTest::addColumn<long>( "sl" );
+
+    for ( int d=0; devices[d] != 0; d++ ) {
+	QString device = devices[d];
+	for ( int e=0; encodings[e] != 0; e++ ) {
+	    QString encoding = encodings[e];
+
+	    QString tag = device + "_" + encoding + "_";
+	    QTest::newRow( tag + "0" ) << device << encoding << long(0);
+	    QTest::newRow( tag + "1" ) << device << encoding << long(1);
+	    QTest::newRow( tag + "2" ) << device << encoding << long(10);
+	    QTest::newRow( tag + "3" ) << device << encoding << long(255);
+	    QTest::newRow( tag + "4" ) << device << encoding << long(65535);
+	    QTest::newRow( tag + "5" ) << device << encoding << long(-1);
+	    QTest::newRow( tag + "6" ) << device << encoding << long(-10);
+	    QTest::newRow( tag + "7" ) << device << encoding << long(-255);
+	    QTest::newRow( tag + "8" ) << device << encoding << long(-65534);
+	}
+    }
+}
+
+void tst_Q3TextStream::operator_shift_long()
+{
+    createWriteStream( os );
+    write_long( os );
+    closeWriteStream( os );
+
+    createReadStream( is );
+    read_long( is );
+    closeReadStream( is );
+}
+
+void tst_Q3TextStream::read_long( Q3TextStream *s )
+{
+    QFETCH( long, sl );
+    long exp;
+    QString A, B;
+    *s >> A >> exp >> B;
+    QCOMPARE( A, QString("A") );
+    QCOMPARE( B, QString("B") );
+    QCOMPARE( exp, sl );
+    s->skipWhiteSpace();
+}
+
+void tst_Q3TextStream::write_long( Q3TextStream *s )
+{
+    QFETCH( long, sl );
+    *s << " A " << sl << " B ";
+}
+
+// **************** long ****************
+
+void tst_Q3TextStream::operator_shift_ulong_data()
+{
+    QTest::addColumn<QString>( "device" );
+    QTest::addColumn<QString>( "encoding" );
+    QTest::addColumn<ulong>( "ul" );
+
+    for ( int d=0; devices[d] != 0; d++ ) {
+	QString device = devices[d];
+	for ( int e=0; encodings[e] != 0; e++ ) {
+	    QString encoding = encodings[e];
+
+	    QString tag = device + "_" + encoding + "_";
+	    QTest::newRow( tag + "0" ) << device << encoding << ulong(0);
+	    QTest::newRow( tag + "1" ) << device << encoding << ulong(1);
+	    QTest::newRow( tag + "2" ) << device << encoding << ulong(10);
+	    QTest::newRow( tag + "3" ) << device << encoding << ulong(255);
+	    QTest::newRow( tag + "4" ) << device << encoding << ulong(65535);
+	}
+    }
+}
+
+void tst_Q3TextStream::operator_shift_ulong()
+{
+    createWriteStream( os );
+    write_ulong( os );
+    closeWriteStream( os );
+
+    createReadStream( is );
+    read_ulong( is );
+    closeReadStream( is );
+}
+
+void tst_Q3TextStream::read_ulong( Q3TextStream *s )
+{
+    QFETCH( ulong, ul );
+    ulong exp;
+    QString A, B;
+    *s >> A >> exp >> B;
+    QCOMPARE( A, QString("A") );
+    QCOMPARE( B, QString("B") );
+    QCOMPARE( exp, ul );
+    s->skipWhiteSpace();
+}
+
+void tst_Q3TextStream::write_ulong( Q3TextStream *s )
+{
+    QFETCH( ulong, ul );
+    *s << " A " << ul << " B ";
+}
+
+// **************** float ****************
+
+void tst_Q3TextStream::operator_shift_float_data()
+{
+    QTest::addColumn<QString>( "device" );
+    QTest::addColumn<QString>( "encoding" );
+    QTest::addColumn<float>( "f" );
+
+    for ( int d=0; devices[d] != 0; d++ ) {
+	QString device = devices[d];
+	for ( int e=0; encodings[e] != 0; e++ ) {
+	    QString encoding = encodings[e];
+
+	    QString tag = device + "_" + encoding + "_";
+	    QTest::newRow( tag + "0" ) << device << encoding << float(0.0);
+	    QTest::newRow( tag + "1" ) << device << encoding << float(0.0001);
+	    QTest::newRow( tag + "2" ) << device << encoding << float(-0.0001);
+	    QTest::newRow( tag + "3" ) << device << encoding << float(3.45678);
+	    QTest::newRow( tag + "4" ) << device << encoding << float(-3.45678);
+	}
+    }
+}
+
+void tst_Q3TextStream::operator_shift_float()
+{
+    createWriteStream( os );
+    write_float( os );
+    closeWriteStream( os );
+
+    createReadStream( is );
+    read_float( is );
+    closeReadStream( is );
+}
+
+void tst_Q3TextStream::read_float( Q3TextStream *s )
+{
+    QFETCH( float, f );
+    float exp;
+    QString A, B;
+    *s >> A >> exp >> B;
+    QCOMPARE( A, QString("A") );
+    QCOMPARE( B, QString("B") );
+    QCOMPARE( exp, f );
+    s->skipWhiteSpace();
+}
+
+void tst_Q3TextStream::write_float( Q3TextStream *s )
+{
+    QFETCH( float, f );
+    *s << " A " << f << " B ";
+}
+
+// **************** double ****************
+
+void tst_Q3TextStream::operator_shift_double_data()
+{
+    QTest::addColumn<QString>( "device" );
+    QTest::addColumn<QString>( "encoding" );
+    QTest::addColumn<double>( "d" );
+
+    for ( int d=0; devices[d] != 0; d++ ) {
+	QString device = devices[d];
+	for ( int e=0; encodings[e] != 0; e++ ) {
+	    QString encoding = encodings[e];
+
+	    QString tag = device + "_" + encoding + "_";
+	    QTest::newRow( tag + "0" ) << device << encoding << double(0.0);
+	    QTest::newRow( tag + "1" ) << device << encoding << double(0.0001);
+	    QTest::newRow( tag + "2" ) << device << encoding << double(-0.0001);
+	    QTest::newRow( tag + "3" ) << device << encoding << double(3.45678);
+	    QTest::newRow( tag + "4" ) << device << encoding << double(-3.45678);
+	    QTest::newRow( tag + "5" ) << device << encoding << double(1.23456789);
+	    QTest::newRow( tag + "6" ) << device << encoding << double(-1.23456789);
+	}
+    }
+}
+
+void tst_Q3TextStream::operator_shift_double()
+{
+    createWriteStream( os );
+    os->precision( 10 );
+    write_double( os );
+    closeWriteStream( os );
+
+    createReadStream( is );
+    is->precision( 10 );
+    read_double( is );
+    closeReadStream( is );
+}
+
+void tst_Q3TextStream::read_double( Q3TextStream *s )
+{
+    QFETCH( double, d );
+    double exp;
+    QString A, B;
+    *s >> A >> exp >> B;
+    QCOMPARE( A, QString("A") );
+    QCOMPARE( B, QString("B") );
+    QCOMPARE( exp, d );
+    s->skipWhiteSpace();
+}
+
+void tst_Q3TextStream::write_double( Q3TextStream *s )
+{
+    QFETCH( double, d );
+    *s << " A " << d << " B ";
+}
+
+// **************** QString ****************
+
+void tst_Q3TextStream::operator_shift_QString_data()
+{
+    QTest::addColumn<QString>( "device" );
+    QTest::addColumn<QString>( "encoding" );
+    QTest::addColumn<QString>( "str" );
+    QTest::addColumn<bool>( "multi_str" );
+    QTest::addColumn<bool>( "zero_length" );
+
+    for ( int d=0; devices[d] != 0; d++ ) {
+	QString device = devices[d];
+	for ( int e=0; encodings[e] != 0; e++ ) {
+	    QString encoding = encodings[e];
+
+	    QString tag = device + "_" + encoding + "_";
+	    QTest::newRow( tag + "0" ) << device << encoding << QString("") << bool(FALSE) << bool(TRUE);
+	    QTest::newRow( tag + "1" ) << device << encoding << QString() << bool(FALSE) << bool(TRUE);
+	    QTest::newRow( tag + "2" ) << device << encoding << QString("foo") << bool(FALSE) << bool(FALSE);
+	    QTest::newRow( tag + "3" ) << device << encoding << QString("foo\nbar") << bool(TRUE) << bool(FALSE);
+	    QTest::newRow( tag + "4" ) << device << encoding << QString("cjacka ckha cka ckah ckac kahckadhcbkgdk vkzdfbvajef vkahv") << bool(TRUE) << bool(FALSE);
+	}
+    }
+}
+
+void tst_Q3TextStream::operator_shift_QString()
+{
+    QFETCH( bool, zero_length );
+    file_is_empty = zero_length;
+
+    createWriteStream( os );
+    write_QString( os );
+    closeWriteStream( os );
+
+    createReadStream( is );
+    read_QString( is );
+    closeReadStream( is );
+}
+
+void tst_Q3TextStream::read_QString( Q3TextStream *s )
+{
+    QString exp;
+    QFETCH( QString, str );
+    if (str.isNull())
+	str = "";
+
+    QFETCH( bool, multi_str );
+    if (!multi_str) {
+	*s >> exp;
+	QCOMPARE( exp, str );
+    } else {
+	QStringList l;
+	l = QStringList::split( " ", str );
+	if (l.count() < 2)
+	    l = QStringList::split( "\n", str );
+	for (uint i=0; i<uint(l.count()); i++) {
+	    *s >> exp;
+	    QCOMPARE( exp, l[i] );
+	}
+    }
+}
+
+void tst_Q3TextStream::write_QString( Q3TextStream *s )
+{
+    QFETCH( QString, str );
+    *s << str;
+}
+
+// **************** Q3CString ****************
+
+void tst_Q3TextStream::operator_shift_Q3CString_data()
+{
+    QTest::addColumn<QString>( "device" );
+    QTest::addColumn<QString>( "encoding" );
+    QTest::addColumn<Q3CString>( "cs" );
+    QTest::addColumn<bool>( "multi_str" );
+    QTest::addColumn<bool>( "zero_length" );
+
+    for ( int d=0; devices[d] != 0; d++ ) {
+	QString device = devices[d];
+	for ( int e=0; encodings[e] != 0; e++ ) {
+	    QString encoding = encodings[e];
+
+	    QString tag = device + "_" + encoding + "_";
+	    QTest::newRow( tag + "0" ) << device << encoding << Q3CString("") << bool(FALSE) << bool(TRUE);
+	    QTest::newRow( tag + "1" ) << device << encoding << Q3CString(0) << bool(FALSE) << bool(TRUE);
+	    QTest::newRow( tag + "2" ) << device << encoding << Q3CString("foo") << bool(FALSE) << bool(FALSE);
+	    QTest::newRow( tag + "3" ) << device << encoding << Q3CString("foo\nbar") << bool(TRUE) << bool(FALSE);
+	    QTest::newRow( tag + "4" ) << device << encoding << Q3CString("cjacka ckha cka ckah ckac kahckadhcbkgdk vkzdfbvajef vkahv") << bool(TRUE) << bool(FALSE);
+	}
+    }
+}
+
+void tst_Q3TextStream::operator_shift_Q3CString()
+{
+    QFETCH( bool, zero_length );
+    file_is_empty = zero_length;
+
+    createWriteStream( os );
+    write_Q3CString( os );
+    closeWriteStream( os );
+
+    createReadStream( is );
+    read_Q3CString( is );
+    closeReadStream( is );
+}
+
+void tst_Q3TextStream::read_Q3CString( Q3TextStream *s )
+{
+/*
+    QFETCH( Q3CString, cs );
+    Q3CString exp;
+    *s >> exp;
+    QCOMPARE( exp, cs );
+*/
+    Q3CString exp;
+    QFETCH( Q3CString, cs );
+    if (cs.isNull())
+	cs = "";
+
+    QFETCH( bool, multi_str );
+    if (!multi_str) {
+	*s >> exp;
+	QCOMPARE( exp, cs );
+    } else {
+	QStringList l;
+	l = QStringList::split( " ", cs );
+	if (l.count() < 2)
+	    l = QStringList::split( "\n", cs );
+	for (uint i=0; i<uint(l.count()); i++) {
+	    *s >> exp;
+	    QCOMPARE( exp, Q3CString(l[i].toLatin1()) );
+	}
+    }
+}
+
+void tst_Q3TextStream::write_Q3CString( Q3TextStream *s )
+{
+    QFETCH( Q3CString, cs );
+    *s << cs;
+}
+
+void tst_Q3TextStream::task28319()
+{
+    /*
+#if QT_VERSION >= 0x040000
+    // Specific test for task 28319
+    QFile f("28319.txt");
+    if (f.open(IO_WriteOnly)) {
+	// First we write some text
+	Q3TextStream writeStream(&f);
+	writeStream.setEncoding(Q3TextStream::Unicode);
+	writeStream << "This is a";
+	f.close();
+    } else {
+	QVERIFY(FALSE);
+    }
+    if (f.open(IO_WriteOnly | IO_Append)) {
+	// Now we append some text
+	Q3TextStream appendStream(&f);
+	appendStream.setEncoding(Q3TextStream::Unicode);
+	appendStream << " test";
+	f.close();
+    } else {
+	QVERIFY(FALSE);
+    }
+    if (f.open(IO_ReadOnly)) {
+	// Now we read in the text
+	Q3TextStream readStream(&f);
+	QString text = readStream.read();
+	QCOMPARE(text, QString("This is a test"));
+    } else {
+	QVERIFY(FALSE);
+    }
+#else
+    QSKIP( "A minor bug we don't want to fix in 3.2.", SkipAll);
+#endif
+    */
+}
+
+/*!
+ \since 4.5
+
+ This code worked in Qt 3 and should also in Qt 4. It should not crash due to
+ out of bounds.
+
+ */
+void tst_Q3TextStream::QTextCodecCodecForIndex() const
+{
+    for(int i = 0; QTextCodec::codecForIndex(i); i++)
+        ;
+}
+
+QTEST_MAIN(tst_Q3TextStream)
+#include "tst_q3textstream.moc"