/****************************************************************************

**

** Copyright (C) 2010 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 <QtTest/QtTest>

#include <QtGui/QtGui>

#ifdef QT3_SUPPORT

#include <Qt3Support/Qt3Support>

#endif

#include <QtSvg/QtSvg>

#if defined(Q_OS_SYMBIAN)

# define STRINGIFY(x) #x

# define TOSTRING(x) STRINGIFY(x)

# define SRCDIR "C:/Private/" TOSTRING(SYMBIAN_SRCDIR_UID) "/"

#define SVGFILE "tests2.svg"

#endif

Q_DECLARE_METATYPE(QBitArray)

Q_DECLARE_METATYPE(qint64)

//TESTED_CLASS=

//TESTED_FILES=

class tst_QDataStream : public QObject

{

Q_OBJECT

public:

    tst_QDataStream();

    virtual ~tst_QDataStream();

    void stream_data(int noOfElements);

public slots:

    void init();

    void cleanup();

private slots:

    void getSetCheck();

    void stream_bool_data();

    void stream_bool();

    void stream_QBool_data();

    void stream_QBool();

    void stream_QBool_in_4_0();

    void stream_QBitArray_data();

    void stream_QBitArray();

    void stream_QBrush_data();

    void stream_QBrush();

    void stream_QColor_data();

    void stream_QColor();

    void stream_QByteArray_data();

    void stream_QByteArray();

    void stream_QCursor_data();

    void stream_QCursor();

    void stream_QDate_data();

    void stream_QDate();

    void stream_QTime_data();

    void stream_QTime();

    void stream_QDateTime_data();

    void stream_QDateTime();

    void stream_QFont_data();

    void stream_QFont();

    void stream_QImage_data();

    void stream_QImage();

    void stream_QPalette_data();

    void stream_QPalette();

    void stream_QColorGroup_data();

    void stream_QColorGroup();

    void stream_QPen_data();

    void stream_QPen();

    void stream_QPixmap_data();

    void stream_QPixmap();

    void stream_QPoint_data();

    void stream_QPoint();

    void stream_QRect_data();

    void stream_QRect();

    void stream_QPolygon_data();

    void stream_QPolygon();

    void stream_QRegion_data();

    void stream_QRegion();

    void stream_QSize_data();

    void stream_QSize();

    void stream_QString_data();

    void stream_QString();

    void stream_QRegExp_data();

    void stream_QRegExp();

    void stream_Map_data();

    void stream_Map();

    void stream_Hash_data();

    void stream_Hash();

    void stream_qint64_data();

    void stream_qint64();

    void stream_QWMatrix_data();

    void stream_QWMatrix();

    void stream_QIcon_data();

    void stream_QIcon();

    void stream_QEasingCurve_data();

    void stream_QEasingCurve();

    void stream_atEnd_data();

    void stream_atEnd();

    void stream_QByteArray2();

    void setVersion_data();

    void setVersion();

    void skipRawData_data();

    void skipRawData();

    void status_qint8_data();

    void status_qint8();

    void status_qint16_data();

    void status_qint16();

    void status_qint32_data();

    void status_qint32();

    void status_qint64_data();

    void status_qint64();

    void status_float_data();

    void status_float();

    void status_double_data();

    void status_double();

    void status_charptr_QByteArray_data();

    void status_charptr_QByteArray();

    void status_QString_data();

    void status_QString();

    void status_QBitArray_data();

    void status_QBitArray();

    void status_QHash_QMap();

    void status_QLinkedList_QList_QVector();

    void streamToAndFromQByteArray();

    void streamRealDataTypes();

    void floatingPointPrecision();

#ifdef QT3_SUPPORT

    void task_224283();

#endif

    void compatibility_Qt3();

    void compatibility_Qt2();

private:

    void writebool(QDataStream *s);

    void writeQBool(QDataStream *s);

    void writeQBitArray(QDataStream *s);

    void writeQBrush(QDataStream *s);

    void writeQColor(QDataStream *s);

    void writeQByteArray(QDataStream *s);

    void writeQCursor(QDataStream *s);

    void writeQWaitCursor(QDataStream *s);

    void writeQDate(QDataStream *s);

    void writeQTime(QDataStream *s);

    void writeQDateTime(QDataStream *s);

    void writeQFont(QDataStream *s);

    void writeQImage(QDataStream *s);

    void writeQPalette(QDataStream *s);

    void writeQColorGroup(QDataStream *s);

    void writeQPen(QDataStream *s);

    void writeQPixmap(QDataStream *s);

    void writeQPoint(QDataStream *s);

    void writeQRect(QDataStream *s);

    void writeQPolygon(QDataStream *s);

    void writeQRegion(QDataStream *s);

    void writeQSize(QDataStream *s);

    void writeQString(QDataStream* dev);

    void writeQRegExp(QDataStream* dev);

    void writeMap(QDataStream* dev);

    void writeHash(QDataStream* dev);

    void writeqint64(QDataStream *s);

    void writeQWMatrix(QDataStream *s);

    void writeQIcon(QDataStream *s);

    void writeQEasingCurve(QDataStream *s);

    void readbool(QDataStream *s);

    void readQBool(QDataStream *s);

    void readQBitArray(QDataStream *s);

    void readQBrush(QDataStream *s);

    void readQColor(QDataStream *s);

    void readQByteArray(QDataStream *s);

    void readQCursor(QDataStream *s);

    void readQDate(QDataStream *s);

    void readQTime(QDataStream *s);

    void readQDateTime(QDataStream *s);

    void readQFont(QDataStream *s);

    void readQImage(QDataStream *s);

    void readQPalette(QDataStream *s);

    void readQColorGroup(QDataStream *s);

    void readQPen(QDataStream *s);

    void readQPixmap(QDataStream *s);

    void readQPoint(QDataStream *s);

    void readQRect(QDataStream *s);

    void readQPolygon(QDataStream *s);

    void readQRegion(QDataStream *s);

    void readQSize(QDataStream *s);

    void readQString(QDataStream *s);

    void readQRegExp(QDataStream *s);

    void readMap(QDataStream *s);

    void readHash(QDataStream *s);

    void readqint64(QDataStream *s);

    void readQWMatrix(QDataStream *s);

    void readQIcon(QDataStream *s);

    void readQEasingCurve(QDataStream *s);

private:

    QString svgFile;

};

static int NColorRoles[] = {

    QPalette::NoRole,              // No Version

    QPalette::NoRole,              // Qt_1_0

    QPalette::HighlightedText + 1, // Qt_2_0

    QPalette::HighlightedText + 1, // Qt_2_1

    QPalette::LinkVisited + 1,     // Qt_3_0

    QPalette::HighlightedText + 1, // Qt_3_1

    QPalette::HighlightedText + 1, // Qt_3_3

    QPalette::HighlightedText + 1, // Qt_4_0, Qt_4_1

    QPalette::HighlightedText + 1, // Qt_4_2

    QPalette::AlternateBase + 1,   // Qt_4_3

    QPalette::ToolTipText + 1,     // Qt_4_4

    QPalette::ToolTipText + 1,     // Qt_4_5

    QPalette::ToolTipText + 1,     // Qt_4_6

    0                              // add the correct value for Qt_4_7 here later

};

// Testing get/set functions

void tst_QDataStream::getSetCheck()

{

    QDataStream obj1;

    // QIODevice * QDataStream::device()

    // void QDataStream::setDevice(QIODevice *)

    QFile *var1 = new QFile;

    obj1.setDevice(var1);

    QCOMPARE((QIODevice *)var1, (QIODevice *)obj1.device());

    obj1.setDevice((QIODevice *)0);

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

    delete var1;

    // Status QDataStream::status()

    // void QDataStream::setStatus(Status)

    obj1.setStatus(QDataStream::Ok);

    QCOMPARE(QDataStream::Ok, obj1.status());

    obj1.setStatus(QDataStream::ReadPastEnd);

    QCOMPARE(QDataStream::ReadPastEnd, obj1.status());

    obj1.resetStatus();

    obj1.setStatus(QDataStream::ReadCorruptData);

    QCOMPARE(QDataStream::ReadCorruptData, obj1.status());

}

tst_QDataStream::tst_QDataStream()

{

    svgFile = QLatin1String(SRCDIR SVGFILE);

}

tst_QDataStream::~tst_QDataStream()

{

    QFile::remove(QLatin1String("qdatastream.out"));

}

void tst_QDataStream::init()

{

}

void tst_QDataStream::cleanup()

{

}

static int dataIndex(const QString &tag)

{

    int pos = tag.lastIndexOf("_");

    if (pos >= 0) {

	int ret = 0;

	QString count = tag.mid(pos + 1);

	bool ok;

	ret = count.toInt(&ok);

	if (ok)

	    return ret;

    }

    return -1;

}

static const char * const devices[] = {

    "file",

    "bytearray",

    "buffer",

    0

};

/*

    IMPORTANT.

    In this testcase i follow a different approach than usual: I don't use the full power of

    QtTestTable and QtTestData. This is done deliberately because QtTestData uses a QDataStream

    itself to handle its data. So it would be a bit inapropriate to fully rely on QtTestData in this

    testcase.

    I do use QString in QtTestData because this is thouroughly tested in the selftest.

*/

void tst_QDataStream::stream_data(int noOfElements)

{

    QTest::addColumn<QString>("device");

    QTest::addColumn<QString>("byteOrder");

    for (int d=0; devices[d] != 0; d++) {

	QString device = devices[d];

	for (int b=0; b<2; b++) {

	    QString byte_order = b == 0 ? "BigEndian" : "LittleEndian";

	    QString tag = device + "_" + byte_order;

	    for (int e=0; e<noOfElements; e++) {

		QTest::newRow(qPrintable(tag + QString("_%1").arg(e))) << device << QString(byte_order);

	    }

	}

    }

}

static const char* open_xpm[]={

"16 13 6 1",

". c None",

"b c #ffff00",

"d c #000000",

"* c #999999",

"c c #cccccc",

"a c #ffffff",

"...*****........",

"..*aaaaa*.......",

".*abcbcba******.",

".*acbcbcaaaaaa*d",

".*abcbcbcbcbcb*d",

"*************b*d",

"*aaaaaaaaaa**c*d",

"*abcbcbcbcbbd**d",

".*abcbcbcbcbcd*d",

".*acbcbcbcbcbd*d",

"..*acbcbcbcbb*dd",

"..*************d",

"...ddddddddddddd"};

#define STREAM_IMPL(TYPE) \

    QFETCH(QString, device); \

    if (device == "bytearray") { \

	    QByteArray ba; \

	    QDataStream sout(&ba, QIODevice::WriteOnly); \

	    write##TYPE(&sout); \

	    QDataStream sin(&ba, QIODevice::ReadOnly); \

	    read##TYPE(&sin); \

    } else if (device == "file") { \

	    QString fileName = "qdatastream.out"; \

	    QFile fOut(fileName); \

	    QVERIFY(fOut.open(QIODevice::WriteOnly)); \

	    QDataStream sout(&fOut); \

	    write##TYPE(&sout); \

	    fOut.close(); \

	    QFile fIn(fileName); \

	    QVERIFY(fIn.open(QIODevice::ReadOnly)); \

	    QDataStream sin(&fIn); \

	    read##TYPE(&sin); \

	    fIn.close(); \

    } else if (device == "buffer") { \

	    QByteArray ba(10000, '\0'); \

	    QBuffer bOut(&ba); \

	    bOut.open(QIODevice::WriteOnly); \

	    QDataStream sout(&bOut); \

	    write##TYPE(&sout); \

	    bOut.close(); \

	    QBuffer bIn(&ba); \

	    bIn.open(QIODevice::ReadOnly); \

	    QDataStream sin(&bIn); \

	    read##TYPE(&sin); \

	    bIn.close(); \

    }

// ************************************

static QString QStringData(int index)

{

    switch (index)

    {

	case 0: return QString();

	case 1: return QString("");

	case 2: return QString("A");

	case 3: return QString("ABCDE FGHI");

	case 4: return QString("This is a long string");

	case 5: return QString("And again a string with a \nCRLF");

	case 6: return QString("abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRESTUVWXYZ 1234567890 ~`!@#$%^&*()_-+={[}]|\\:;\"'<,>.?/");

    }

    return QString("foo");

}

#define MAX_QSTRING_DATA 7

void tst_QDataStream::stream_QString_data()

{

    stream_data(MAX_QSTRING_DATA);

}

void tst_QDataStream::stream_QString()

{

    STREAM_IMPL(QString);

}

void tst_QDataStream::writeQString(QDataStream* s)

{

    QString test(QStringData(dataIndex(QTest::currentDataTag())));

    *s << test;

    *s << QString("Her er det noe tekst");

    *s << test;

    *s << QString();

    *s << test;

    *s << QString("");

    *s << test;

    *s << QString("nonempty");

    *s << test;

}

void tst_QDataStream::readQString(QDataStream *s)

{

    QString S;

    QString test(QStringData(dataIndex(QTest::currentDataTag())));

    *s >> S;

    QCOMPARE(S, test);

    *s >> S;

    QCOMPARE(S, QString("Her er det noe tekst"));

    *s >> S;

    QCOMPARE(S, test);

    *s >> S;

    QVERIFY(S.isNull());

    *s >> S;

    QCOMPARE(S, test);

    *s >> S;

    QVERIFY(S.isEmpty());

    *s >> S;

    QCOMPARE(S, test);

    *s >> S;

    QCOMPARE(S, QString("nonempty"));

    *s >> S;

    QCOMPARE(S, test);

}

// ************************************

static QRegExp QRegExpData(int index)

{

    switch (index)

    {

	case 0: return QRegExp();

	case 1: return QRegExp("");

	case 2: return QRegExp("A", Qt::CaseInsensitive);

	case 3: return QRegExp("ABCDE FGHI", Qt::CaseSensitive, QRegExp::Wildcard);

	case 4: return QRegExp("This is a long string", Qt::CaseInsensitive, QRegExp::FixedString);

	case 5: return QRegExp("And again a string with a \nCRLF", Qt::CaseInsensitive, QRegExp::RegExp);

	case 6: {

            QRegExp rx("abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRESTUVWXYZ 1234567890 ~`!@#$%^&*()_-+={[}]|\\:;\"'<,>.?/");