1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 /*-*-encoding:latin1-*-*/

    44 //#include <iostream>

    45 //using namespace std;

    46 

    47 #include <QtTest/QtTest>

    48 

    49 #ifdef Q_OS_UNIX

    50 #include <locale.h>

    51 #endif

    52 

    53 #include <QBuffer>

    54 #include <QByteArray>

    55 #include <QCoreApplication>

    56 #include <QDebug>

    57 #include <QFile>

    58 #include <QTcpSocket>

    59 #include <QTextStream>

    60 #include <QTextCodec>

    61 #include <QProcess>

    62 

    63 #include "../network-settings.h"

    64 

    65 static const char *TestFileName = "testfile";

    66 

    67 Q_DECLARE_METATYPE(qlonglong)

    68 Q_DECLARE_METATYPE(qulonglong)

    69 Q_DECLARE_METATYPE(QList<int>)

    70 

    71 QT_BEGIN_NAMESPACE

    72 template<> struct QMetaTypeId<QIODevice::OpenModeFlag>

    73 { enum { Defined = 1 }; static inline int qt_metatype_id() { return QMetaType::Int; } };

    74 QT_END_NAMESPACE

    75 

    76 //TESTED_CLASS=

    77 //TESTED_FILES=

    78 

    79 #ifdef Q_OS_SYMBIAN

    80 #define SRCDIR ""

    81 #endif

    82 

    83 class tst_QTextStream : public QObject

    84 {

    85     Q_OBJECT

    86 

    87 public:

    88     tst_QTextStream();

    89     virtual ~tst_QTextStream();

    90 

    91 public slots:

    92     void init();

    93     void cleanup();

    94 

    95 private slots:

    96     void getSetCheck();

    97     void construction();

    98 

    99     // lines

   100     void readLineFromDevice_data();

   101     void readLineFromDevice();

   102     void readLineFromString_data();

   103     void readLineFromString();

   104     void readLineFromTextDevice_data();

   105     void readLineFromTextDevice();

   106     void readLineUntilNull();

   107     void readLineMaxlen_data();

   108     void readLineMaxlen();

   109     void readLinesFromBufferCRCR();

   110 

   111     // all

   112     void readAllFromDevice_data();

   113     void readAllFromDevice();

   114     void readAllFromString_data();

   115     void readAllFromString();

   116     void readLineFromStringThenChangeString();

   117 

   118     // device tests

   119     void setDevice();

   120 

   121     // char operators

   122     void QChar_operators_FromDevice_data();

   123     void QChar_operators_FromDevice();

   124     void char_operators_FromDevice_data();

   125     void char_operators_FromDevice();

   126 

   127     // natural number read operator

   128     void signedShort_read_operator_FromDevice_data();

   129     void signedShort_read_operator_FromDevice();

   130     void unsignedShort_read_operator_FromDevice_data();

   131     void unsignedShort_read_operator_FromDevice();

   132     void signedInt_read_operator_FromDevice_data();

   133     void signedInt_read_operator_FromDevice();

   134     void unsignedInt_read_operator_FromDevice_data();

   135     void unsignedInt_read_operator_FromDevice();

   136     void qlonglong_read_operator_FromDevice_data();

   137     void qlonglong_read_operator_FromDevice();

   138     void qulonglong_read_operator_FromDevice_data();

   139     void qulonglong_read_operator_FromDevice();

   140 

   141     // natural number write operator

   142     void signedShort_write_operator_ToDevice_data();

   143     void signedShort_write_operator_ToDevice();

   144     void unsignedShort_write_operator_ToDevice_data();

   145     void unsignedShort_write_operator_ToDevice();

   146     void signedInt_write_operator_ToDevice_data();

   147     void signedInt_write_operator_ToDevice();

   148     void unsignedInt_write_operator_ToDevice_data();

   149     void unsignedInt_write_operator_ToDevice();

   150     void qlonglong_write_operator_ToDevice_data();

   151     void qlonglong_write_operator_ToDevice();

   152     void qulonglong_write_operator_ToDevice_data();

   153     void qulonglong_write_operator_ToDevice();

   154 

   155     void int_read_with_locale_data();

   156     void int_read_with_locale();

   157 

   158     void int_write_with_locale_data();

   159     void int_write_with_locale();

   160 

   161     // real number read operator

   162     void float_read_operator_FromDevice_data();

   163     void float_read_operator_FromDevice();

   164     void double_read_operator_FromDevice_data();

   165     void double_read_operator_FromDevice();

   166 

   167     // real number write operator

   168     void float_write_operator_ToDevice_data();

   169     void float_write_operator_ToDevice();

   170     void double_write_operator_ToDevice_data();

   171     void double_write_operator_ToDevice();

   172 

   173     void double_write_with_flags_data();

   174     void double_write_with_flags();

   175 

   176     void double_write_with_precision_data();

   177     void double_write_with_precision();

   178 

   179     // text read operators

   180     void charPtr_read_operator_FromDevice_data();

   181     void charPtr_read_operator_FromDevice();

   182     void stringRef_read_operator_FromDevice_data();

   183     void stringRef_read_operator_FromDevice();

   184     void byteArray_read_operator_FromDevice_data();

   185     void byteArray_read_operator_FromDevice();

   186 

   187     // text write operators

   188     void string_write_operator_ToDevice_data();

   189     void string_write_operator_ToDevice();

   190 

   191     // other

   192     void skipWhiteSpace_data();

   193     void skipWhiteSpace();

   194     void lineCount_data();

   195     void lineCount();

   196     void performance();

   197     void hexTest_data();

   198     void hexTest();

   199     void binTest_data();

   200     void binTest();

   201     void octTest_data();

   202     void octTest();

   203     void zeroTermination();

   204     void ws_manipulator();

   205     void stillOpenWhenAtEnd();

   206     void readNewlines_data();

   207     void readNewlines();

   208     void seek();

   209     void pos();

   210     void pos2();

   211     void readStdin();

   212     void readAllFromStdin();

   213     void readLineFromStdin();

   214     void read();

   215     void qbool();

   216     void forcePoint();

   217     void forceSign();

   218     void read0d0d0a();

   219     void numeralCase_data();

   220     void numeralCase();

   221     void nanInf();

   222     void utf8IncompleteAtBufferBoundary_data();

   223     void utf8IncompleteAtBufferBoundary();

   224 

   225     // status

   226     void status_real_read_data();

   227     void status_real_read();

   228     void status_integer_read();

   229     void status_word_read();

   230 

   231     // use case tests

   232     void useCase1();

   233     void useCase2();

   234 

   235     // manipulators

   236     void manipulators_data();

   237     void manipulators();

   238 

   239     // UTF-16 BOM (Byte Order Mark)

   240     void generateBOM();

   241     void readBomSeekBackReadBomAgain();

   242 

   243     // old tests

   244 #ifdef QT3_SUPPORT

   245     void qt3_operator_shiftleft_data();

   246     void qt3_operator_shiftleft();

   247     void qt3_operator_shiftright_data();

   248     void qt3_operator_shiftright();

   249     void qt3_operator_shift_QChar_data();

   250     void qt3_operator_shift_QChar();

   251     void qt3_operator_shift_char_data();

   252     void qt3_operator_shift_char();

   253     void qt3_operator_shift_short_data();

   254     void qt3_operator_shift_short();

   255     void qt3_operator_shift_ushort_data();

   256     void qt3_operator_shift_ushort();

   257     void qt3_operator_shift_int_data();

   258     void qt3_operator_shift_int();

   259     void qt3_operator_shift_uint_data();

   260     void qt3_operator_shift_uint();

   261     void qt3_operator_shift_long_data();

   262     void qt3_operator_shift_long();

   263     void qt3_operator_shift_ulong_data();

   264     void qt3_operator_shift_ulong();

   265     void qt3_operator_shift_float_data();

   266     void qt3_operator_shift_float();

   267     void qt3_operator_shift_double_data();

   268     void qt3_operator_shift_double();

   269     void qt3_operator_shift_QString_data();

   270     void qt3_operator_shift_QString();

   271     void qt3_operator_shift_QByteArray_data();

   272     void qt3_operator_shift_QByteArray();

   273 

   274     void qt3_writeDataToFileReadAsLines_data();

   275     void qt3_writeDataToFileReadAsLines();

   276     void qt3_writeDataToQStringReadAsLines_data();

   277     void qt3_writeDataToQStringReadAsLines();

   278 

   279     void qt3_readLineFromString();

   280 #endif

   281 

   282     // task-specific tests

   283     void task180679_alignAccountingStyle();

   284     void task178772_setCodec();

   285 

   286 private:

   287     void generateLineData(bool for_QString);

   288     void generateAllData(bool for_QString);

   289     void generateOperatorCharData(bool for_QString);

   290     void generateNaturalNumbersData(bool for_QString);

   291     void generateRealNumbersData(bool for_QString);

   292     void generateStringData(bool for_QString);

   293     void generateRealNumbersDataWrite();

   294 

   295     // Qt 3 privates

   296 #ifdef QT3_SUPPORT

   297     void qt3_createWriteStream( QTextStream *&os );

   298     void qt3_closeWriteStream( QTextStream *os );

   299     void qt3_createReadStream( QTextStream *&is );

   300     void qt3_closeReadStream( QTextStream *is );

   301     void qt3_read_QChar( QTextStream *s );

   302     void qt3_write_QChar( QTextStream *s );

   303     void qt3_read_char( QTextStream *s );

   304     void qt3_write_char( QTextStream *s );

   305     void qt3_read_short( QTextStream *s );

   306     void qt3_write_short( QTextStream *s );

   307     void qt3_read_ushort( QTextStream *s );

   308     void qt3_write_ushort( QTextStream *s );

   309     void qt3_read_int( QTextStream *s );

   310     void qt3_write_int( QTextStream *s );

   311     void qt3_read_uint( QTextStream *s );

   312     void qt3_write_uint( QTextStream *s );

   313     void qt3_read_long( QTextStream *s );

   314     void qt3_write_long( QTextStream *s );

   315     void qt3_read_ulong( QTextStream *s );

   316     void qt3_write_ulong( QTextStream *s );

   317     void qt3_read_float( QTextStream *s );

   318     void qt3_write_float( QTextStream *s );

   319     void qt3_read_double( QTextStream *s );

   320     void qt3_write_double( QTextStream *s );

   321     void qt3_read_QString( QTextStream *s );

   322     void qt3_write_QString( QTextStream *s );

   323     void qt3_read_QByteArray( QTextStream *s );

   324     void qt3_write_QByteArray( QTextStream *s );

   325     void qt3_operatorShift_data( QIODevice::OpenMode );

   326     void qt3_do_shiftleft( QTextStream *ts );

   327     QTextStream::Encoding qt3_toEncoding( const QString& );

   328     QString qt3_decodeString( QByteArray array, const QString& encoding );

   329 #endif

   330 

   331     // Qt 3 data

   332     QTextStream *os;

   333     QTextStream *is;

   334     QTextStream *ts;

   335     QFile *inFile;

   336     QFile *inResource;

   337     QFile *outFile;

   338     QByteArray *inArray;

   339     QBuffer *inBuffer;

   340     QString *inString;

   341     bool file_is_empty;

   342 };

   343 

   344 // Testing get/set functions

   345 void tst_QTextStream::getSetCheck()

   346 {

   347     // Initialize codecs

   348     int argc = 0;

   349     char **argv = 0;

   350     QCoreApplication app(argc, argv);

   351 

   352     QTextStream obj1;

   353     // QTextCodec * QTextStream::codec()

   354     // void QTextStream::setCodec(QTextCodec *)

   355     QTextCodec *var1 = QTextCodec::codecForName("en");

   356     obj1.setCodec(var1);

   357     QCOMPARE(var1, obj1.codec());

   358     obj1.setCodec((QTextCodec *)0);

   359     QCOMPARE((QTextCodec *)0, obj1.codec());

   360 

   361     // bool QTextStream::autoDetectUnicode()

   362     // void QTextStream::setAutoDetectUnicode(bool)

   363     obj1.setAutoDetectUnicode(false);

   364     QCOMPARE(false, obj1.autoDetectUnicode());

   365     obj1.setAutoDetectUnicode(true);

   366     QCOMPARE(true, obj1.autoDetectUnicode());

   367 

   368     // bool QTextStream::generateByteOrderMark()

   369     // void QTextStream::setGenerateByteOrderMark(bool)

   370     obj1.setGenerateByteOrderMark(false);

   371     QCOMPARE(false, obj1.generateByteOrderMark());

   372     obj1.setGenerateByteOrderMark(true);

   373     QCOMPARE(true, obj1.generateByteOrderMark());

   374 

   375     // QIODevice * QTextStream::device()

   376     // void QTextStream::setDevice(QIODevice *)

   377     QFile *var4 = new QFile;

   378     obj1.setDevice(var4);

   379     QCOMPARE(static_cast<QIODevice *>(var4), obj1.device());

   380     obj1.setDevice((QIODevice *)0);

   381     QCOMPARE((QIODevice *)0, obj1.device());

   382     delete var4;

   383 

   384     // Status QTextStream::status()

   385     // void QTextStream::setStatus(Status)

   386     obj1.setStatus(QTextStream::Status(QTextStream::Ok));

   387     QCOMPARE(QTextStream::Status(QTextStream::Ok), obj1.status());

   388     obj1.setStatus(QTextStream::Status(QTextStream::ReadPastEnd));

   389     QCOMPARE(QTextStream::Status(QTextStream::ReadPastEnd), obj1.status());

   390     obj1.resetStatus();

   391     obj1.setStatus(QTextStream::Status(QTextStream::ReadCorruptData));

   392     QCOMPARE(QTextStream::Status(QTextStream::ReadCorruptData), obj1.status());

   393 

   394     // FieldAlignment QTextStream::fieldAlignment()

   395     // void QTextStream::setFieldAlignment(FieldAlignment)

   396     obj1.setFieldAlignment(QTextStream::FieldAlignment(QTextStream::AlignLeft));

   397     QCOMPARE(QTextStream::FieldAlignment(QTextStream::AlignLeft), obj1.fieldAlignment());

   398     obj1.setFieldAlignment(QTextStream::FieldAlignment(QTextStream::AlignRight));

   399     QCOMPARE(QTextStream::FieldAlignment(QTextStream::AlignRight), obj1.fieldAlignment());

   400     obj1.setFieldAlignment(QTextStream::FieldAlignment(QTextStream::AlignCenter));

   401     QCOMPARE(QTextStream::FieldAlignment(QTextStream::AlignCenter), obj1.fieldAlignment());

   402     obj1.setFieldAlignment(QTextStream::FieldAlignment(QTextStream::AlignAccountingStyle));

   403     QCOMPARE(QTextStream::FieldAlignment(QTextStream::AlignAccountingStyle), obj1.fieldAlignment());

   404 

   405     // QChar QTextStream::padChar()

   406     // void QTextStream::setPadChar(QChar)

   407     QChar var7 = 'Q';

   408     obj1.setPadChar(var7);

   409     QCOMPARE(var7, obj1.padChar());

   410     obj1.setPadChar(QChar());

   411     QCOMPARE(QChar(), obj1.padChar());

   412 

   413     // int QTextStream::fieldWidth()

   414     // void QTextStream::setFieldWidth(int)

   415     obj1.setFieldWidth(0);

   416     QCOMPARE(0, obj1.fieldWidth());

   417     obj1.setFieldWidth(INT_MIN);

   418     QCOMPARE(INT_MIN, obj1.fieldWidth());

   419     obj1.setFieldWidth(INT_MAX);

   420     QCOMPARE(INT_MAX, obj1.fieldWidth());

   421 

   422     // NumberFlags QTextStream::numberFlags()

   423     // void QTextStream::setNumberFlags(NumberFlags)

   424     obj1.setNumberFlags(QTextStream::NumberFlags(QTextStream::ShowBase));

   425     QCOMPARE(QTextStream::NumberFlags(QTextStream::ShowBase), obj1.numberFlags());

   426     obj1.setNumberFlags(QTextStream::NumberFlags(QTextStream::ForcePoint));

   427     QCOMPARE(QTextStream::NumberFlags(QTextStream::ForcePoint), obj1.numberFlags());

   428     obj1.setNumberFlags(QTextStream::NumberFlags(QTextStream::ForceSign));

   429     QCOMPARE(QTextStream::NumberFlags(QTextStream::ForceSign), obj1.numberFlags());

   430     obj1.setNumberFlags(QTextStream::NumberFlags(QTextStream::UppercaseBase));

   431     QCOMPARE(QTextStream::NumberFlags(QTextStream::UppercaseBase), obj1.numberFlags());

   432     obj1.setNumberFlags(QTextStream::NumberFlags(QTextStream::UppercaseDigits));

   433     QCOMPARE(QTextStream::NumberFlags(QTextStream::UppercaseDigits), obj1.numberFlags());

   434 

   435     // int QTextStream::integerBase()

   436     // void QTextStream::setIntegerBase(int)

   437     obj1.setIntegerBase(0);

   438     QCOMPARE(0, obj1.integerBase());

   439     obj1.setIntegerBase(INT_MIN);

   440     QCOMPARE(INT_MIN, obj1.integerBase());

   441     obj1.setIntegerBase(INT_MAX);

   442     QCOMPARE(INT_MAX, obj1.integerBase());

   443 

   444     // RealNumberNotation QTextStream::realNumberNotation()

   445     // void QTextStream::setRealNumberNotation(RealNumberNotation)

   446     obj1.setRealNumberNotation(QTextStream::RealNumberNotation(QTextStream::SmartNotation));

   447     QCOMPARE(QTextStream::RealNumberNotation(QTextStream::SmartNotation), obj1.realNumberNotation());

   448     obj1.setRealNumberNotation(QTextStream::RealNumberNotation(QTextStream::FixedNotation));

   449     QCOMPARE(QTextStream::RealNumberNotation(QTextStream::FixedNotation), obj1.realNumberNotation());

   450     obj1.setRealNumberNotation(QTextStream::RealNumberNotation(QTextStream::ScientificNotation));

   451     QCOMPARE(QTextStream::RealNumberNotation(QTextStream::ScientificNotation), obj1.realNumberNotation());

   452 

   453     // int QTextStream::realNumberPrecision()

   454     // void QTextStream::setRealNumberPrecision(int)

   455     obj1.setRealNumberPrecision(0);

   456     QCOMPARE(0, obj1.realNumberPrecision());

   457     obj1.setRealNumberPrecision(INT_MIN);

   458     QCOMPARE(6, obj1.realNumberPrecision()); // Setting a negative precision reverts it to the default value (6).

   459     obj1.setRealNumberPrecision(INT_MAX);

   460     QCOMPARE(INT_MAX, obj1.realNumberPrecision());

   461 }

   462 

   463 tst_QTextStream::tst_QTextStream()

   464 {

   465     // Initialize Qt 3 data

   466     ts = 0;

   467     os = 0;

   468     is = 0;

   469     outFile = 0;

   470     inFile = 0;

   471     inResource = 0;

   472     inArray = 0;

   473     inBuffer = 0;

   474     inString = 0;

   475     file_is_empty = FALSE;

   476 

   477     Q_SET_DEFAULT_IAP

   478 }

   479 

   480 tst_QTextStream::~tst_QTextStream()

   481 {

   482 }

   483 

   484 void tst_QTextStream::init()

   485 {

   486     // Initialize Qt 3 data

   487     ts = 0;

   488     os = 0;

   489     is = 0;

   490     inFile = 0;

   491     inResource = 0;

   492     outFile = 0;

   493     inArray = 0;

   494     inBuffer = 0;

   495     inString = 0;

   496     file_is_empty = FALSE;

   497 }

   498 

   499 void tst_QTextStream::cleanup()

   500 {

   501     // Clean up Qt 3 data

   502     delete ts;

   503     ts = 0;

   504     delete os;

   505     os = 0;

   506     delete is;

   507     is = 0;

   508     delete inResource;

   509     inResource = 0;

   510     delete inFile;

   511     inFile = 0;

   512     delete outFile;

   513     outFile = 0;

   514     delete inArray;

   515     inArray = 0;

   516     delete inBuffer;

   517     inBuffer = 0;

   518     delete inString;

   519     inString = 0;

   520 

   521     QCoreApplication::instance()->processEvents();

   522 }

   523 

   524 // ------------------------------------------------------------------------------

   525 void tst_QTextStream::construction()

   526 {

   527     QTextStream stream;

   528     QCOMPARE(stream.codec(), QTextCodec::codecForLocale());

   529     QCOMPARE(stream.device(), static_cast<QIODevice *>(0));

   530     QCOMPARE(stream.string(), static_cast<QString *>(0));

   531 

   532     QTest::ignoreMessage(QtWarningMsg, "QTextStream: No device");

   533     QVERIFY(stream.atEnd());

   534 

   535     QTest::ignoreMessage(QtWarningMsg, "QTextStream: No device");

   536     QCOMPARE(stream.readAll(), QString());

   537 

   538 }

   539 

   540 void tst_QTextStream::generateLineData(bool for_QString)

   541 {

   542     QTest::addColumn<QByteArray>("data");

   543     QTest::addColumn<QStringList>("lines");

   544 

   545     // latin-1

   546     QTest::newRow("emptyer") << QByteArray() << QStringList();

   547     QTest::newRow("lf") << QByteArray("\n") << (QStringList() << "");

   548     QTest::newRow("crlf") << QByteArray("\r\n") << (QStringList() << "");

   549     QTest::newRow("oneline/nothing") << QByteArray("ole") << (QStringList() << "ole");

   550     QTest::newRow("oneline/lf") << QByteArray("ole\n") << (QStringList() << "ole");

   551     QTest::newRow("oneline/crlf") << QByteArray("ole\r\n") << (QStringList() << "ole");

   552     QTest::newRow("twolines/lf/lf") << QByteArray("ole\ndole\n") << (QStringList() << "ole" << "dole");

   553     QTest::newRow("twolines/crlf/crlf") << QByteArray("ole\r\ndole\r\n") << (QStringList() << "ole" << "dole");

   554     QTest::newRow("twolines/lf/crlf") << QByteArray("ole\ndole\r\n") << (QStringList() << "ole" << "dole");

   555     QTest::newRow("twolines/lf/nothing") << QByteArray("ole\ndole") << (QStringList() << "ole" << "dole");

   556     QTest::newRow("twolines/crlf/nothing") << QByteArray("ole\r\ndole") << (QStringList() << "ole" << "dole");

   557     QTest::newRow("threelines/lf/lf/lf") << QByteArray("ole\ndole\ndoffen\n") << (QStringList() << "ole" << "dole" << "doffen");

   558     QTest::newRow("threelines/crlf/crlf/crlf") << QByteArray("ole\r\ndole\r\ndoffen\r\n") << (QStringList() << "ole" << "dole" << "doffen");

   559     QTest::newRow("threelines/crlf/crlf/nothing") << QByteArray("ole\r\ndole\r\ndoffen") << (QStringList() << "ole" << "dole" << "doffen");

   560 

   561     if (!for_QString) {

   562         // utf-8

   563         QTest::newRow("utf8/twolines")

   564             << QByteArray("\xef\xbb\xbf"

   565                           "\x66\x67\x65\x0a"

   566                           "\x66\x67\x65\x0a", 11)

   567             << (QStringList() << "fge" << "fge");

   568 

   569         // utf-16

   570         // one line

   571         QTest::newRow("utf16-BE/nothing")

   572             << QByteArray("\xfe\xff"

   573                           "\x00\xe5\x00\x67\x00\x65", 8) << (QStringList() << "\345ge");

   574         QTest::newRow("utf16-LE/nothing")

   575             << QByteArray("\xff\xfe"

   576                           "\xe5\x00\x67\x00\x65\x00", 8) << (QStringList() << "\345ge");

   577         QTest::newRow("utf16-BE/lf")

   578             << QByteArray("\xfe\xff"

   579                           "\x00\xe5\x00\x67\x00\x65\x00\x0a", 10) << (QStringList() << "\345ge");

   580         QTest::newRow("utf16-LE/lf")

   581             << QByteArray("\xff\xfe"

   582                           "\xe5\x00\x67\x00\x65\x00\x0a\x00", 10) << (QStringList() << "\345ge");

   583 

   584         // two lines

   585         QTest::newRow("utf16-BE/twolines")

   586             << QByteArray("\xfe\xff"

   587                           "\x00\xe5\x00\x67\x00\x65\x00\x0a"

   588                           "\x00\xe5\x00\x67\x00\x65\x00\x0a", 18)

   589             << (QStringList() << "\345ge" << "\345ge");

   590         QTest::newRow("utf16-LE/twolines")

   591             << QByteArray("\xff\xfe"

   592                           "\xe5\x00\x67\x00\x65\x00\x0a\x00"

   593                           "\xe5\x00\x67\x00\x65\x00\x0a\x00", 18)

   594             << (QStringList() << "\345ge" << "\345ge");

   595 

   596         // three lines

   597         QTest::newRow("utf16-BE/threelines")

   598             << QByteArray("\xfe\xff"

   599                           "\x00\xe5\x00\x67\x00\x65\x00\x0a"

   600                           "\x00\xe5\x00\x67\x00\x65\x00\x0a"

   601                           "\x00\xe5\x00\x67\x00\x65\x00\x0a", 26)

   602             << (QStringList() << "\345ge" << "\345ge" << "\345ge");

   603         QTest::newRow("utf16-LE/threelines")

   604             << QByteArray("\xff\xfe"

   605                           "\xe5\x00\x67\x00\x65\x00\x0a\x00"

   606                           "\xe5\x00\x67\x00\x65\x00\x0a\x00"

   607                           "\xe5\x00\x67\x00\x65\x00\x0a\x00", 26)

   608             << (QStringList() << "\345ge" << "\345ge" << "\345ge");

   609 

   610         // utf-32

   611         QTest::newRow("utf32-BE/twolines")

   612             << QByteArray("\x00\x00\xfe\xff"

   613                           "\x00\x00\x00\xe5\x00\x00\x00\x67\x00\x00\x00\x65\x00\x00\x00\x0a"

   614                           "\x00\x00\x00\xe5\x00\x00\x00\x67\x00\x00\x00\x65\x00\x00\x00\x0a", 36)

   615             << (QStringList() << "\345ge" << "\345ge");

   616         QTest::newRow("utf32-LE/twolines")

   617             << QByteArray("\xff\xfe\x00\x00"

   618                           "\xe5\x00\x00\x00\x67\x00\x00\x00\x65\x00\x00\x00\x0a\x00\x00\x00"

   619                           "\xe5\x00\x00\x00\x67\x00\x00\x00\x65\x00\x00\x00\x0a\x00\x00\x00", 36)

   620             << (QStringList() << "\345ge" << "\345ge");

   621     }

   622 

   623     // partials

   624     QTest::newRow("cr") << QByteArray("\r") << (QStringList() << "");

   625     QTest::newRow("oneline/cr") << QByteArray("ole\r") << (QStringList() << "ole");

   626     if (!for_QString)

   627         QTest::newRow("utf16-BE/cr") << QByteArray("\xfe\xff\x00\xe5\x00\x67\x00\x65\x00\x0d", 10) << (QStringList() << "\345ge");

   628 }

   629 

   630 // ------------------------------------------------------------------------------

   631 void tst_QTextStream::readLineFromDevice_data()

   632 {

   633     generateLineData(false);

   634 }

   635 

   636 // ------------------------------------------------------------------------------

   637 void tst_QTextStream::readLineFromDevice()

   638 {

   639     QFETCH(QByteArray, data);

   640     QFETCH(QStringList, lines);

   641 

   642     QFile::remove(TestFileName);

   643     QFile file(TestFileName);

   644     QVERIFY(file.open(QFile::ReadWrite));

   645     QCOMPARE(file.write(data), qlonglong(data.size()));

   646     QVERIFY(file.flush());

   647     file.seek(0);

   648 

   649     QTextStream stream(&file);

   650     QStringList list;

   651     while (!stream.atEnd())

   652         list << stream.readLine();

   653 

   654     QCOMPARE(list, lines);

   655 }

   656 

   657 // ------------------------------------------------------------------------------

   658 void tst_QTextStream::readLineMaxlen_data()

   659 {

   660     QTest::addColumn<QString>("input");

   661     QTest::addColumn<QStringList>("lines");

   662 

   663     QTest::newRow("Hey")

   664         << QString("Hey")

   665         << (QStringList() << QString("Hey") << QString(""));

   666     QTest::newRow("Hey\\n")

   667         << QString("Hey\n")

   668         << (QStringList() << QString("Hey") << QString(""));

   669     QTest::newRow("HelloWorld")

   670         << QString("HelloWorld")

   671         << (QStringList() << QString("Hello") << QString("World"));

   672     QTest::newRow("Helo\\nWorlds")

   673         << QString("Helo\nWorlds")

   674         << (QStringList() << QString("Helo") << QString("World"));

   675     QTest::newRow("AAAAA etc.")

   676         << QString(16385, QLatin1Char('A'))

   677         << (QStringList() << QString("AAAAA") << QString("AAAAA"));

   678     QTest::newRow("multibyte string")

   679         << QString::fromUtf8("\341\233\222\341\233\226\341\232\251\341\232\271\341\232\242\341\233\232\341\232\240\n")

   680         << (QStringList() << QString::fromUtf8("\341\233\222\341\233\226\341\232\251\341\232\271\341\232\242")

   681             << QString::fromUtf8("\341\233\232\341\232\240"));

   682 }

   683 

   684 // ------------------------------------------------------------------------------

   685 void tst_QTextStream::readLineMaxlen()

   686 {

   687     QFETCH(QString, input);

   688     QFETCH(QStringList, lines);

   689     for (int i = 0; i < 2; ++i) {

   690         bool useDevice = (i == 1);

   691         QTextStream stream;

   692         QFile::remove("testfile");

   693         QFile file("testfile");

   694         if (useDevice) {

   695             file.open(QIODevice::ReadWrite);

   696             file.write(input.toUtf8());

   697             file.seek(0);

   698             stream.setDevice(&file);

   699             stream.setCodec("utf-8");

   700         } else {

   701             stream.setString(&input);

   702         }

   703 

   704         QStringList list;

   705         list << stream.readLine(5);

   706         list << stream.readLine(5);

   707 

   708         QCOMPARE(list, lines);

   709     }

   710 }

   711 

   712 // ------------------------------------------------------------------------------

   713 void tst_QTextStream::readLinesFromBufferCRCR()

   714 {

   715     QBuffer buffer;

   716     buffer.open(QIODevice::WriteOnly);

   717     QByteArray data("0123456789\r\r\n");

   718 

   719     for (int i = 0; i < 10000; ++i)

   720         buffer.write(data);

   721 

   722     buffer.close();

   723     if (buffer.open(QIODevice::ReadOnly|QIODevice::Text)) {

   724         QTextStream stream(&buffer);

   725         while (!stream.atEnd())

   726             QCOMPARE(stream.readLine(), QString("0123456789"));

   727     }

   728 }

   729 

   730 // ------------------------------------------------------------------------------

   731 void tst_QTextStream::readLineFromString_data()

   732 {

   733     generateLineData(true);

   734 }

   735 

   736 // ------------------------------------------------------------------------------

   737 void tst_QTextStream::readLineFromString()

   738 {

   739     QFETCH(QByteArray, data);

   740     QFETCH(QStringList, lines);

   741 

   742     QString dataString = data;

   743 

   744     QTextStream stream(&dataString, QIODevice::ReadOnly);

   745     QStringList list;

   746     while (!stream.atEnd())

   747         list << stream.readLine();

   748 

   749     QCOMPARE(list, lines);

   750 }

   751 

   752 // ------------------------------------------------------------------------------

   753 void tst_QTextStream::readLineFromStringThenChangeString()

   754 {

   755     QString first = "First string";

   756     QString second = "Second string";

   757 

   758     QTextStream stream(&first, QIODevice::ReadOnly);

   759     QString result = stream.readLine();

   760     QCOMPARE(first, result);

   761 

   762     stream.setString(&second, QIODevice::ReadOnly);

   763     result = stream.readLine();

   764     QCOMPARE(second, result);

   765 }

   766 

   767 // ------------------------------------------------------------------------------

   768 void tst_QTextStream::setDevice()

   769 {

   770     // Check that the read buffer is reset after setting a new device

   771     QByteArray data1("Hello World");

   772     QByteArray data2("How are you");

   773 

   774     QBuffer bufferOld(&data1);

   775     bufferOld.open(QIODevice::ReadOnly);

   776 

   777     QBuffer bufferNew(&data2);

   778     bufferNew.open(QIODevice::ReadOnly);

   779 

   780     QString text;

   781     QTextStream stream(&bufferOld);

   782     stream >> text;

   783     QCOMPARE(text, QString("Hello"));

   784 

   785     stream.setDevice(&bufferNew);

   786     stream >> text;

   787     QCOMPARE(text, QString("How"));

   788 }

   789 

   790 // ------------------------------------------------------------------------------

   791 void tst_QTextStream::readLineFromTextDevice_data()

   792 {

   793     generateLineData(false);

   794 }

   795 

   796 // ------------------------------------------------------------------------------

   797 void tst_QTextStream::readLineFromTextDevice()

   798 {

   799     QFETCH(QByteArray, data);

   800     QFETCH(QStringList, lines);

   801 

   802     for (int i = 0; i < 8; ++i) {

   803         QBuffer buffer(&data);

   804         if (i < 4)

   805             QVERIFY(buffer.open(QIODevice::ReadOnly | QIODevice::Text));

   806         else

   807             QVERIFY(buffer.open(QIODevice::ReadOnly));

   808 

   809         QTextStream stream(&buffer);

   810         QStringList list;

   811         while (!stream.atEnd()) {

   812             stream.pos(); // <- triggers side effects

   813             QString line;

   814 

   815             if (i & 1) {

   816                 QChar c;

   817                 while (!stream.atEnd()) {

   818                     stream >> c;

   819                     if (stream.status() == QTextStream::Ok) {

   820                         if (c != QLatin1Char('\n') && c != QLatin1Char('\r'))

   821                             line += c;

   822                         if (c == QLatin1Char('\n'))

   823                             break;

   824                     }

   825                 }

   826             } else {

   827                 line = stream.readLine();

   828             }

   829 

   830             if ((i & 3) == 3 && !QString(QTest::currentDataTag()).contains("utf16"))

   831                 stream.seek(stream.pos());

   832             list << line;

   833         }

   834         QCOMPARE(list, lines);

   835     }

   836 }

   837 

   838 // ------------------------------------------------------------------------------

   839 void tst_QTextStream::generateAllData(bool for_QString)

   840 {

   841     QTest::addColumn<QByteArray>("input");

   842     QTest::addColumn<QString>("output");

   843 

   844     // latin-1

   845     QTest::newRow("empty") << QByteArray() << QString();

   846     QTest::newRow("latin1-a") << QByteArray("a") << QString("a");

   847     QTest::newRow("latin1-a\\r") << QByteArray("a\r") << QString("a\r");

   848     QTest::newRow("latin1-a\\r\\n") << QByteArray("a\r\n") << QString("a\r\n");

   849     QTest::newRow("latin1-a\\n") << QByteArray("a\n") << QString("a\n");

   850 

   851     // utf-16

   852     if (!for_QString) {

   853         // one line

   854         QTest::newRow("utf16-BE/nothing")

   855             << QByteArray("\xfe\xff"

   856                           "\x00\xe5\x00\x67\x00\x65", 8) << QString("\345ge");

   857         QTest::newRow("utf16-LE/nothing")

   858             << QByteArray("\xff\xfe"

   859                           "\xe5\x00\x67\x00\x65\x00", 8) << QString("\345ge");

   860         QTest::newRow("utf16-BE/lf")

   861             << QByteArray("\xfe\xff"

   862                           "\x00\xe5\x00\x67\x00\x65\x00\x0a", 10) << QString("\345ge\n");

   863         QTest::newRow("utf16-LE/lf")

   864             << QByteArray("\xff\xfe"

   865                           "\xe5\x00\x67\x00\x65\x00\x0a\x00", 10) << QString("\345ge\n");

   866         QTest::newRow("utf16-BE/crlf")

   867             << QByteArray("\xfe\xff"

   868                           "\x00\xe5\x00\x67\x00\x65\x00\x0d\x00\x0a", 12) << QString("\345ge\r\n");

   869         QTest::newRow("utf16-LE/crlf")

   870             << QByteArray("\xff\xfe"

   871                           "\xe5\x00\x67\x00\x65\x00\x0d\x00\x0a\x00", 12) << QString("\345ge\r\n");

   872 

   873         // two lines

   874         QTest::newRow("utf16-BE/twolines")

   875             << QByteArray("\xfe\xff"

   876                           "\x00\xe5\x00\x67\x00\x65\x00\x0a"

   877                           "\x00\xe5\x00\x67\x00\x65\x00\x0a", 18)

   878             << QString("\345ge\n\345ge\n");

   879         QTest::newRow("utf16-LE/twolines")

   880             << QByteArray("\xff\xfe"

   881                           "\xe5\x00\x67\x00\x65\x00\x0a\x00"

   882                           "\xe5\x00\x67\x00\x65\x00\x0a\x00", 18)

   883             << QString("\345ge\n\345ge\n");

   884 

   885         // three lines

   886         QTest::newRow("utf16-BE/threelines")

   887             << QByteArray("\xfe\xff"

   888                           "\x00\xe5\x00\x67\x00\x65\x00\x0a"

   889                           "\x00\xe5\x00\x67\x00\x65\x00\x0a"

   890                           "\x00\xe5\x00\x67\x00\x65\x00\x0a", 26)

   891             << QString("\345ge\n\345ge\n\345ge\n");

   892         QTest::newRow("utf16-LE/threelines")

   893             << QByteArray("\xff\xfe"

   894                           "\xe5\x00\x67\x00\x65\x00\x0a\x00"

   895                           "\xe5\x00\x67\x00\x65\x00\x0a\x00"

   896                           "\xe5\x00\x67\x00\x65\x00\x0a\x00", 26)

   897             << QString("\345ge\n\345ge\n\345ge\n");

   898     }

   899 }

   900 

   901 // ------------------------------------------------------------------------------

   902 void tst_QTextStream::readLineUntilNull()

   903 {

   904     QFile file(SRCDIR "rfc3261.txt");

   905     QVERIFY(file.open(QFile::ReadOnly));

   906 

   907     QTextStream stream(&file);

   908     for (int i = 0; i < 15066; ++i) {

   909         QString line = stream.readLine();

   910         QVERIFY(!line.isNull());

   911         QVERIFY(!line.isNull());

   912     }

   913     QVERIFY(!stream.readLine().isNull());

   914     QVERIFY(stream.readLine().isNull());

   915 }

   916 

   917 // ------------------------------------------------------------------------------

   918 void tst_QTextStream::readAllFromDevice_data()

   919 {

   920     generateAllData(false);

   921 }

   922 

   923 // ------------------------------------------------------------------------------

   924 void tst_QTextStream::readAllFromDevice()

   925 {

   926     QFETCH(QByteArray, input);

   927     QFETCH(QString, output);

   928 

   929     QBuffer buffer(&input);

   930     buffer.open(QBuffer::ReadOnly);

   931 

   932     QTextStream stream(&buffer);

   933     QCOMPARE(stream.readAll(), output);

   934 }

   935 

   936 // ------------------------------------------------------------------------------

   937 void tst_QTextStream::readAllFromString_data()

   938 {

   939     generateAllData(true);

   940 }

   941 

   942 // ------------------------------------------------------------------------------

   943 void tst_QTextStream::readAllFromString()

   944 {

   945     QFETCH(QByteArray, input);

   946     QFETCH(QString, output);

   947 

   948     QString str = input;

   949 

   950     QTextStream stream(&str);

   951     QCOMPARE(stream.readAll(), output);

   952 }

   953 

   954 // ------------------------------------------------------------------------------

   955 void tst_QTextStream::skipWhiteSpace_data()

   956 {

   957     QTest::addColumn<QByteArray>("input");

   958     QTest::addColumn<QChar>("output");

   959 

   960     // latin1

   961     QTest::newRow("empty") << QByteArray() << QChar('\0');

   962     QTest::newRow(" one") << QByteArray(" one") << QChar('o');

   963     QTest::newRow("\\none") << QByteArray("\none") << QChar('o');

   964     QTest::newRow("\\n one") << QByteArray("\n one") << QChar('o');

   965     QTest::newRow(" \\r\\n one") << QByteArray(" \r\n one") << QChar('o');

   966 

   967     // utf-16

   968     QTest::newRow("utf16-BE (empty)") << QByteArray("\xfe\xff", 2) << QChar('\0');

   969     QTest::newRow("utf16-BE ( one)") << QByteArray("\xfe\xff\x00 \x00o\x00n\x00e", 10) << QChar('o');

   970     QTest::newRow("utf16-BE (\\none)") << QByteArray("\xfe\xff\x00\n\x00o\x00n\x00e", 10) << QChar('o');

   971     QTest::newRow("utf16-BE (\\n one)") << QByteArray("\xfe\xff\x00\n\x00 \x00o\x00n\x00e", 12) << QChar('o');

   972     QTest::newRow("utf16-BE ( \\r\\n one)") << QByteArray("\xfe\xff\x00 \x00\r\x00\n\x00 \x00o\x00n\x00e", 20) << QChar('o');

   973 

   974     QTest::newRow("utf16-LE (empty)") << QByteArray("\xff\xfe", 2) << QChar('\0');

   975     QTest::newRow("utf16-LE ( one)") << QByteArray("\xff\xfe \x00o\x00n\x00e\x00", 10) << QChar('o');

   976     QTest::newRow("utf16-LE (\\none)") << QByteArray("\xff\xfe\n\x00o\x00n\x00e\x00", 10) << QChar('o');

   977     QTest::newRow("utf16-LE (\\n one)") << QByteArray("\xff\xfe\n\x00 \x00o\x00n\x00e\x00", 12) << QChar('o');

   978     QTest::newRow("utf16-LE ( \\r\\n one)") << QByteArray("\xff\xfe \x00\r\x00\n\x00 \x00o\x00n\x00e\x00", 20) << QChar('o');

   979 }

   980 

   981 // ------------------------------------------------------------------------------

   982 void tst_QTextStream::skipWhiteSpace()

   983 {

   984     QFETCH(QByteArray, input);

   985     QFETCH(QChar, output);

   986 

   987     QBuffer buffer(&input);

   988     buffer.open(QBuffer::ReadOnly);

   989 

   990     QTextStream stream(&buffer);

   991     stream.skipWhiteSpace();

   992 

   993     QChar tmp;

   994     stream >> tmp;

   995 

   996     QCOMPARE(tmp, output);

   997 

   998     QString str = input;

   999     QTextStream stream2(&input);

  1000     stream2.skipWhiteSpace();

  1001 

  1002     stream2 >> tmp;

  1003 

  1004     QCOMPARE(tmp, output);

  1005 }

  1006 

  1007 // ------------------------------------------------------------------------------

  1008 void tst_QTextStream::lineCount_data()

  1009 {

  1010     QTest::addColumn<QByteArray>("data");

  1011     QTest::addColumn<int>("lineCount");

  1012 

  1013     QTest::newRow("empty") << QByteArray() << 0;

  1014     QTest::newRow("oneline") << QByteArray("a\n") << 1;

  1015     QTest::newRow("twolines") << QByteArray("a\nb\n") << 2;

  1016     QTest::newRow("oneemptyline") << QByteArray("\n") << 1;

  1017     QTest::newRow("twoemptylines") << QByteArray("\n\n") << 2;

  1018     QTest::newRow("buffersize-1 line") << QByteArray(16382, '\n') << 16382;

  1019     QTest::newRow("buffersize line") << QByteArray(16383, '\n') << 16383;

  1020     QTest::newRow("buffersize+1 line") << QByteArray(16384, '\n') << 16384;

  1021     QTest::newRow("buffersize+2 line") << QByteArray(16385, '\n') << 16385;

  1022 

  1023     QFile file(SRCDIR "rfc3261.txt"); file.open(QFile::ReadOnly);

  1024     QTest::newRow("rfc3261") << file.readAll() << 15067;

  1025 }

  1026 

  1027 // ------------------------------------------------------------------------------

  1028 void tst_QTextStream::lineCount()

  1029 {

  1030     QFETCH(QByteArray, data);

  1031     QFETCH(int, lineCount);

  1032 

  1033     QFile out("out.txt");

  1034     out.open(QFile::WriteOnly);

  1035 

  1036     QTextStream lineReader(data);

  1037     int lines = 0;

  1038     while (!lineReader.atEnd()) {

  1039         QString line = lineReader.readLine();

  1040         out.write(line.toLatin1() + "\n");

  1041         ++lines;

  1042     }

  1043 

  1044     out.close();

  1045     QCOMPARE(lines, lineCount);

  1046 }

  1047 

  1048 // ------------------------------------------------------------------------------

  1049 void tst_QTextStream::performance()

  1050 {

  1051     // Phase #1 - test speed of reading a huge text file with QFile.

  1052     QTime stopWatch;

  1053 

  1054     int elapsed1 = 0;

  1055     int elapsed2 = 0;

  1056 

  1057         stopWatch.restart();

  1058         int nlines1 = 0;

  1059         QFile file(SRCDIR "rfc3261.txt");

  1060         QVERIFY(file.open(QFile::ReadOnly));

  1061 

  1062         while (!file.atEnd()) {

  1063             ++nlines1;

  1064             file.readLine();

  1065         }

  1066 

  1067         elapsed1 += stopWatch.elapsed();

  1068         stopWatch.restart();

  1069 

  1070         int nlines2 = 0;

  1071         QFile file2(SRCDIR "rfc3261.txt");

  1072         QVERIFY(file2.open(QFile::ReadOnly));

  1073 

  1074         QTextStream stream(&file2);

  1075         while (!stream.atEnd()) {

  1076             ++nlines2;

  1077             stream.readLine();

  1078         }

  1079 

  1080         elapsed2 += stopWatch.elapsed();

  1081         QCOMPARE(nlines1, nlines2);

  1082 

  1083     qDebug("QFile used %.2f seconds to read the file",

  1084            elapsed1 / 1000.0);

  1085 

  1086     qDebug("QTextStream used %.2f seconds to read the file",

  1087            elapsed2 / 1000.0);

  1088     if (elapsed2 > elapsed1) {

  1089         qDebug("QFile is %.2fx faster than QTextStream",

  1090                double(elapsed2) / double(elapsed1));

  1091     } else {

  1092         qDebug("QTextStream is %.2fx faster than QFile",

  1093                double(elapsed1) / double(elapsed2));

  1094     }

  1095 }

  1096 

  1097 // ------------------------------------------------------------------------------

  1098 void tst_QTextStream::hexTest_data()

  1099 {

  1100     QTest::addColumn<qlonglong>("number");

  1101     QTest::addColumn<QByteArray>("data");

  1102 

  1103     QTest::newRow("0") << Q_INT64_C(0) << QByteArray("0x0");

  1104     QTest::newRow("1") << Q_INT64_C(1) << QByteArray("0x1");

  1105     QTest::newRow("2") << Q_INT64_C(2) << QByteArray("0x2");

  1106     QTest::newRow("3") << Q_INT64_C(3) << QByteArray("0x3");

  1107     QTest::newRow("4") << Q_INT64_C(4) << QByteArray("0x4");

  1108     QTest::newRow("5") << Q_INT64_C(5) << QByteArray("0x5");

  1109     QTest::newRow("6") << Q_INT64_C(6) << QByteArray("0x6");

  1110     QTest::newRow("7") << Q_INT64_C(7) << QByteArray("0x7");

  1111     QTest::newRow("8") << Q_INT64_C(8) << QByteArray("0x8");

  1112     QTest::newRow("9") << Q_INT64_C(9) << QByteArray("0x9");

  1113     QTest::newRow("a") << Q_INT64_C(0xa) << QByteArray("0xa");

  1114     QTest::newRow("b") << Q_INT64_C(0xb) << QByteArray("0xb");

  1115     QTest::newRow("c") << Q_INT64_C(0xc) << QByteArray("0xc");

  1116     QTest::newRow("d") << Q_INT64_C(0xd) << QByteArray("0xd");

  1117     QTest::newRow("e") << Q_INT64_C(0xe) << QByteArray("0xe");

  1118     QTest::newRow("f") << Q_INT64_C(0xf) << QByteArray("0xf");

  1119     QTest::newRow("-1") << Q_INT64_C(-1) << QByteArray("-0x1");

  1120     QTest::newRow("0xffffffff") << Q_INT64_C(0xffffffff) << QByteArray("0xffffffff");

  1121     QTest::newRow("0xfffffffffffffffe") << Q_INT64_C(0xfffffffffffffffe) << QByteArray("-0x2");

  1122     QTest::newRow("0xffffffffffffffff") << Q_INT64_C(0xffffffffffffffff) << QByteArray("-0x1");

  1123     QTest::newRow("0x7fffffffffffffff") << Q_INT64_C(0x7fffffffffffffff) << QByteArray("0x7fffffffffffffff");

  1124 }

  1125 

  1126 // ------------------------------------------------------------------------------

  1127 void tst_QTextStream::hexTest()

  1128 {

  1129     QFETCH(qlonglong, number);

  1130     QFETCH(QByteArray, data);

  1131 

  1132     QByteArray array;

  1133     QTextStream stream(&array);

  1134