diff options
Diffstat (limited to 'tests/auto/q3textstream/tst_q3textstream.cpp')
| -rw-r--r-- | tests/auto/q3textstream/tst_q3textstream.cpp | 1347 |
1 files changed, 1347 insertions, 0 deletions
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" |