/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <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 ( 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 ( 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()
{
/*
// 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);
}
*/
}
/*!
\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"