1 files changed, 110 insertions, 17 deletions

diff --git a/tests/auto/corelib/serialization/qdatastream/tst_qdatastream.cpp b/tests/auto/corelib/serialization/qdatastream/tst_qdatastream.cpp
index 085a638eb7..19cdd42a74 100644
--- a/tests/auto/corelib/serialization/qdatastream/tst_qdatastream.cpp
+++ b/tests/auto/corelib/serialization/qdatastream/tst_qdatastream.cpp
@@ -181,6 +181,8 @@ private slots:
 
     void streamRealDataTypes();
 
+    void enumTest();
+
     void floatingPointPrecision();
 
     void compatibility_Qt3();
@@ -2352,25 +2354,22 @@ void tst_QDataStream::setVersion()
     }
 }
 
-class SequentialBuffer : public QBuffer
+class SequentialBuffer : public QIODevice
 {
 public:
-    SequentialBuffer(QByteArray *data) : QBuffer(data) { offset = 0; }
+    SequentialBuffer(QByteArray *data) : QIODevice() { buf.setBuffer(data); }
 
-    bool isSequential() const { return true; }
-    bool seek(qint64 pos) { offset = pos; return QBuffer::seek(pos); }
-    qint64 pos() const { return qint64(offset); }
+    bool isSequential() const override { return true; }
+    bool open(OpenMode mode) override { return buf.open(mode) && QIODevice::open(mode | QIODevice::Unbuffered); }
+    void close() override { buf.close(); QIODevice::close(); }
+    qint64 bytesAvailable() const override { return QIODevice::bytesAvailable() + buf.bytesAvailable(); }
 
 protected:
-    qint64 readData(char *data, qint64 maxSize)
-    {
-        qint64 ret = QBuffer::readData(data, maxSize);
-        offset += ret;
-        return ret;
-    }
+    qint64 readData(char *data, qint64 maxSize) override { return buf.read(data, maxSize); }
+    qint64 writeData(const char *data, qint64 maxSize) override { return buf.write(data, maxSize); }
 
 private:
-    int offset;
+    QBuffer buf;
 };
 
 void tst_QDataStream::skipRawData_data()
@@ -3412,6 +3411,90 @@ void tst_QDataStream::floatingPointNaN()
     }
 }
 
+void tst_QDataStream::enumTest()
+{
+    QByteArray ba;
+
+    enum class E1 : qint8
+    {
+        A,
+        B,
+        C
+    };
+    {
+        QDataStream stream(&ba, QIODevice::WriteOnly);
+        stream << E1::A;
+        QCOMPARE(ba.size(), int(sizeof(E1)));
+    }
+    {
+        QDataStream stream(ba);
+        E1 e;
+        stream >> e;
+        QCOMPARE(e, E1::A);
+    }
+    ba.clear();
+
+    enum class E2 : qint16
+    {
+        A,
+        B,
+        C
+    };
+    {
+        QDataStream stream(&ba, QIODevice::WriteOnly);
+        stream << E2::B;
+        QCOMPARE(ba.size(), int(sizeof(E2)));
+    }
+    {
+        QDataStream stream(ba);
+        E2 e;
+        stream >> e;
+        QCOMPARE(e, E2::B);
+    }
+    ba.clear();
+
+    enum class E4 : qint32
+    {
+        A,
+        B,
+        C
+    };
+    {
+        QDataStream stream(&ba, QIODevice::WriteOnly);
+        stream << E4::C;
+        QCOMPARE(ba.size(), int(sizeof(E4)));
+    }
+    {
+        QDataStream stream(ba);
+        E4 e;
+        stream >> e;
+        QCOMPARE(e, E4::C);
+    }
+    ba.clear();
+
+
+    enum E
+    {
+        A,
+        B,
+        C,
+        D
+    };
+    {
+        QDataStream stream(&ba, QIODevice::WriteOnly);
+        stream << E::D;
+        QCOMPARE(ba.size(), 4);
+    }
+    {
+        QDataStream stream(ba);
+        E e;
+        stream >> e;
+        QCOMPARE(e, E::D);
+    }
+    ba.clear();
+
+}
+
 void tst_QDataStream::floatingPointPrecision()
 {
     QByteArray ba;
@@ -3470,15 +3553,21 @@ void tst_QDataStream::transaction_data()
     QTest::addColumn<bool>("bData");
     QTest::addColumn<float>("fData");
     QTest::addColumn<double>("dData");
+    QTest::addColumn<QImage>("imgData");
     QTest::addColumn<QByteArray>("strData");
     QTest::addColumn<QByteArray>("rawData");
 
+    QImage img1(open_xpm);
+    QImage img2;
+    QImage img3(50, 50, QImage::Format_ARGB32);
+    img3.fill(qRgba(12, 34, 56, 78));
+
     QTest::newRow("1") << qint8(1) << qint16(2) << qint32(3) << qint64(4) << true << 5.0f
-                       << double(6.0) << QByteArray("Hello world!") << QByteArray("Qt rocks!");
+                       << double(6.0) << img1 << QByteArray("Hello world!") << QByteArray("Qt rocks!");
     QTest::newRow("2") << qint8(1 << 6) << qint16(1 << 14) << qint32(1 << 30) << qint64Data(3) << false << 123.0f
-                       << double(234.0) << stringData(5).toUtf8() << stringData(6).toUtf8();
+                       << double(234.0) << img2 << stringData(5).toUtf8() << stringData(6).toUtf8();
     QTest::newRow("3") << qint8(-1) << qint16(-2) << qint32(-3) << qint64(-4) << true << -123.0f
-                       << double(-234.0) << stringData(3).toUtf8() << stringData(4).toUtf8();
+                       << double(-234.0) << img3 << stringData(3).toUtf8() << stringData(4).toUtf8();
 }
 
 void tst_QDataStream::transaction()
@@ -3492,6 +3581,7 @@ void tst_QDataStream::transaction()
     QFETCH(bool, bData);
     QFETCH(float, fData);
     QFETCH(double, dData);
+    QFETCH(QImage, imgData);
     QFETCH(QByteArray, strData);
     QFETCH(QByteArray, rawData);
 
@@ -3499,12 +3589,13 @@ void tst_QDataStream::transaction()
         QDataStream stream(&testBuffer, QIODevice::WriteOnly);
 
         stream << i8Data << i16Data << i32Data << i64Data
-               << bData << fData << dData << strData.constData();
+               << bData << fData << dData << imgData << strData.constData();
         stream.writeRawData(rawData.constData(), rawData.size());
     }
 
     for (int splitPos = 0; splitPos <= testBuffer.size(); ++splitPos) {
         QByteArray readBuffer(testBuffer.left(splitPos));
+
         SequentialBuffer dev(&readBuffer);
         dev.open(QIODevice::ReadOnly);
         QDataStream stream(&dev);
@@ -3516,12 +3607,13 @@ void tst_QDataStream::transaction()
         bool b;
         float f;
         double d;
+        QImage img;
         char *str;
         QByteArray raw(rawData.size(), 0);
 
         forever {
             stream.startTransaction();
-            stream >> i8 >> i16 >> i32 >> i64 >> b >> f >> d >> str;
+            stream >> i8 >> i16 >> i32 >> i64 >> b >> f >> d >> img >> str;
             stream.readRawData(raw.data(), raw.size());
 
             if (stream.commitTransaction())
@@ -3543,6 +3635,7 @@ void tst_QDataStream::transaction()
         QCOMPARE(b, bData);
         QCOMPARE(f, fData);
         QCOMPARE(d, dData);
+        QCOMPARE(img, imgData);
         QVERIFY(strData == str);
         delete [] str;
         QCOMPARE(raw, rawData);