Merge remote-tracking branch 'origin/5.12' into 5.13

Change-Id: Ic34021fbb87d689ee23a5d1b3f50617ada9ec9b9

3 files changed, 208 insertions, 30 deletions

diff --git a/tests/auto/corelib/serialization/qcborstreamreader/tst_qcborstreamreader.cpp b/tests/auto/corelib/serialization/qcborstreamreader/tst_qcborstreamreader.cpp
index 3dd4b5114c..28d29168fb 100644
--- a/tests/auto/corelib/serialization/qcborstreamreader/tst_qcborstreamreader.cpp
+++ b/tests/auto/corelib/serialization/qcborstreamreader/tst_qcborstreamreader.cpp
@@ -80,6 +80,11 @@ private Q_SLOTS:
     void addData_singleElement();
     void addData_complex_data() { arrays_data(); }
     void addData_complex();
+
+    void duplicatedData_data() { arrays_data(); }
+    void duplicatedData();
+    void extraData_data() { arrays_data(); }
+    void extraData();
 };
 
 #define FOR_CBOR_TYPE(F) \
@@ -480,6 +485,28 @@ static QString parseOne(QCborStreamReader &reader)
     return result;
 }
 
+static QString parse(QCborStreamReader &reader, const QByteArray &data)
+{
+    qint64 oldPos = 0;
+    if (QIODevice *dev = reader.device())
+        oldPos = dev->pos();
+
+    QString r = parseOne(reader);
+    if (r.isEmpty())
+        return r;
+
+    if (reader.currentOffset() - oldPos != data.size())
+        r = QString("Number of parsed bytes (%1) not expected (%2)")
+                .arg(reader.currentOffset()).arg(data.size());
+    if (QIODevice *dev = reader.device()) {
+        if (dev->pos() - oldPos != data.size())
+            r = QString("QIODevice not advanced (%1) as expected (%2)")
+                    .arg(dev->pos()).arg(data.size());
+    }
+
+    return r;
+}
+
 bool parseNonRecursive(QString &result, bool &printingStringChunks, QCborStreamReader &reader)
 {
     while (reader.lastError() == QCborError::NoError) {
@@ -612,13 +639,13 @@ void tst_QCborStreamReader::fixed()
     }
     QVERIFY(reader.isValid());
     QCOMPARE(reader.lastError(), QCborError::NoError);
-    QCOMPARE(parseOne(reader), expected);
+    QCOMPARE(parse(reader, data), expected);
 
     // verify that we can re-read
     reader.reset();
     QVERIFY(reader.isValid());
     QCOMPARE(reader.lastError(), QCborError::NoError);
-    QCOMPARE(parseOne(reader), expected);
+    QCOMPARE(parse(reader, data), expected);
 }
 
 void tst_QCborStreamReader::strings_data()
@@ -721,7 +748,7 @@ void tst_QCborStreamReader::emptyContainers()
     QCOMPARE(reader.lastError(), QCborError::NoError);
     if (reader.isLengthKnown())
         QCOMPARE(reader.length(), 0U);
-    QCOMPARE(parseOne(reader), expected);
+    QCOMPARE(parse(reader, data), expected);
 
     // verify that we can re-read
     reader.reset();
@@ -729,7 +756,7 @@ void tst_QCborStreamReader::emptyContainers()
     QCOMPARE(reader.lastError(), QCborError::NoError);
     if (reader.isLengthKnown())
         QCOMPARE(reader.length(), 0U);
-    QCOMPARE(parseOne(reader), expected);
+    QCOMPARE(parse(reader, data), expected);
 }
 
 void tst_QCborStreamReader::arrays_data()
@@ -758,7 +785,7 @@ static void checkContainer(int len, const QByteArray &data, const QString &expec
         QVERIFY(reader.isLengthKnown());
         QCOMPARE(reader.length(), uint(len));
     }
-    QCOMPARE(parseOne(reader), expected);
+    QCOMPARE(parse(reader, data), expected);
 
     // verify that we can re-read
     reader.reset();
@@ -768,7 +795,7 @@ static void checkContainer(int len, const QByteArray &data, const QString &expec
         QVERIFY(reader.isLengthKnown());
         QCOMPARE(reader.length(), uint(len));
     }
-    QCOMPARE(parseOne(reader), expected);
+    QCOMPARE(parse(reader, data), expected);
 }
 
 void tst_QCborStreamReader::arrays()
@@ -892,7 +919,7 @@ void tst_QCborStreamReader::validation()
         buffer.open(QIODevice::ReadOnly);
         reader.setDevice(&buffer);
     }
-    parseOne(reader);
+    parse(reader, data);
     QVERIFY(reader.lastError() != QCborError::NoError);
 
     // next() should fail
@@ -997,7 +1024,7 @@ void tst_QCborStreamReader::addData_singleElement()
             reader.addData(data.constData() + i, 1);
         }
 
-        parseOne(reader);
+        parse(reader, data);
         QCOMPARE(reader.lastError(), QCborError::EndOfFile);
     }
 
@@ -1009,7 +1036,7 @@ void tst_QCborStreamReader::addData_singleElement()
         reader.addData(data.right(1));
     }
     QCOMPARE(reader.lastError(), QCborError::NoError);
-    QCOMPARE(parseOne(reader), expected);
+    QCOMPARE(parse(reader, data), expected);
 }
 
 void tst_QCborStreamReader::addData_complex()
@@ -1085,6 +1112,69 @@ void tst_QCborStreamReader::addData_complex()
              "{1, [" + expected + ", " + expected + "]}");
 }
 
+void tst_QCborStreamReader::duplicatedData()
+{
+    QFETCH_GLOBAL(bool, useDevice);
+    QFETCH(QByteArray, data);
+    QFETCH(QString, expected);
+    removeIndicators(expected);
+
+    // double the data up
+    QByteArray doubledata = data + data;
+
+    QBuffer buffer(&doubledata);
+    QCborStreamReader reader(doubledata);
+    if (useDevice) {
+        buffer.open(QIODevice::ReadOnly);
+        reader.setDevice(&buffer);
+    }
+    QVERIFY(reader.isValid());
+    QCOMPARE(reader.lastError(), QCborError::NoError);
+    QCOMPARE(parse(reader, data), expected);     // yes, data
+
+    QVERIFY(reader.currentOffset() < doubledata.size());
+    if (useDevice) {
+        reader.setDevice(&buffer);
+        QVERIFY(reader.isValid());
+        QCOMPARE(reader.lastError(), QCborError::NoError);
+        QCOMPARE(parse(reader, data), expected);
+        QCOMPARE(buffer.pos(), doubledata.size());
+    } else {
+        // there's no reader.setData()
+    }
+}
+
+void tst_QCborStreamReader::extraData()
+{
+    QFETCH_GLOBAL(bool, useDevice);
+    QFETCH(QByteArray, data);
+    QFETCH(QString, expected);
+    removeIndicators(expected);
+
+    QByteArray extension(9, '\0');
+
+    // stress test everything with extra bytes (just one byte changing;
+    // TinyCBOR used to have a bug where the next byte got sometimes read)
+    for (int c = '\0'; c < 0x100; ++c) {
+        extension[0] = c;
+        QByteArray extendeddata = data + extension;
+
+        QBuffer buffer(&extendeddata);
+        QCborStreamReader reader(extendeddata);
+        if (useDevice) {
+            buffer.open(QIODevice::ReadOnly);
+            reader.setDevice(&buffer);
+        }
+        QVERIFY(reader.isValid());
+        QCOMPARE(reader.lastError(), QCborError::NoError);
+        QCOMPARE(parse(reader, data), expected);     // yes, data
+
+        // if we were a parser, we could parse the next payload
+        if (useDevice)
+            QCOMPARE(buffer.readAll(), extension);
+    }
+}
+
 
 QTEST_MAIN(tst_QCborStreamReader)
 
diff --git a/tests/auto/corelib/serialization/qcborvalue/tst_qcborvalue.cpp b/tests/auto/corelib/serialization/qcborvalue/tst_qcborvalue.cpp
index f69ce4120d..6fa82ea681 100644
--- a/tests/auto/corelib/serialization/qcborvalue/tst_qcborvalue.cpp
+++ b/tests/auto/corelib/serialization/qcborvalue/tst_qcborvalue.cpp
@@ -91,8 +91,14 @@ private slots:
 
     void toCbor_data();
     void toCbor();
+    void toCborStreamWriter_data() { toCbor_data(); }
+    void toCborStreamWriter();
     void fromCbor_data();
     void fromCbor();
+    void fromCborStreamReaderByteArray_data() { fromCbor_data(); }
+    void fromCborStreamReaderByteArray();
+    void fromCborStreamReaderIODevice_data() { fromCbor_data(); }
+    void fromCborStreamReaderIODevice();
     void validation_data();
     void validation();
     void toDiagnosticNotation_data();
@@ -1454,6 +1460,22 @@ void tst_QCborValue::toCbor()
              "\xa1\x01\xd9\xd9\xf7" + result);
 }
 
+void tst_QCborValue::toCborStreamWriter()
+{
+    QFETCH(QCborValue, v);
+    QFETCH(QByteArray, result);
+    QFETCH(QCborValue::EncodingOptions, options);
+
+    QByteArray output;
+    QBuffer buffer(&output);
+    buffer.open(QIODevice::WriteOnly);
+    QCborStreamWriter writer(&buffer);
+
+    v.toCbor(writer, options);
+    QCOMPARE(buffer.pos(), result.size());
+    QCOMPARE(output, result);
+}
+
 void tst_QCborValue::fromCbor_data()
 {
     addCommonCborData();
@@ -1484,20 +1506,11 @@ void tst_QCborValue::fromCbor_data()
                                    << raw("\xd8\x25\x51" "\1\2\3\4""\4\3\2\0""\0\0\0\0""\0\0\0\1""\2");
 }
 
-void tst_QCborValue::fromCbor()
+void fromCbor_common(void (*doCheck)(const QCborValue &, const QByteArray &))
 {
     QFETCH(QCborValue, v);
     QFETCH(QByteArray, result);
 
-    auto doCheck = [](const QCborValue &v, const QByteArray &result) {
-        QCborParserError error;
-        QCborValue decoded = QCborValue::fromCbor(result, &error);
-        QVERIFY2(error.error == QCborError(), qPrintable(error.errorString()));
-        QCOMPARE(error.offset, result.size());
-        QVERIFY(decoded == v);
-        QVERIFY(v == decoded);
-    };
-
     doCheck(v, result);
     if (QTest::currentTestFailed())
         return;
@@ -1548,6 +1561,52 @@ void tst_QCborValue::fromCbor()
         return;
 }
 
+void tst_QCborValue::fromCbor()
+{
+    auto doCheck = [](const QCborValue &v, const QByteArray &result) {
+        QCborParserError error;
+        QCborValue decoded = QCborValue::fromCbor(result, &error);
+        QVERIFY2(error.error == QCborError(), qPrintable(error.errorString()));
+        QCOMPARE(error.offset, result.size());
+        QVERIFY(decoded == v);
+        QVERIFY(v == decoded);
+    };
+
+    fromCbor_common(doCheck);
+}
+
+void tst_QCborValue::fromCborStreamReaderByteArray()
+{
+    auto doCheck = [](const QCborValue &expected, const QByteArray &data) {
+        QCborStreamReader reader(data);
+        QCborValue decoded = QCborValue::fromCbor(reader);
+        QCOMPARE(reader.lastError(), QCborError());
+        QCOMPARE(reader.currentOffset(), data.size());
+        QVERIFY(decoded == expected);
+        QVERIFY(expected == decoded);
+    };
+
+    fromCbor_common(doCheck);
+}
+
+void tst_QCborValue::fromCborStreamReaderIODevice()
+{
+    auto doCheck = [](const QCborValue &expected, const QByteArray &data) {
+        QBuffer buffer;
+        buffer.setData(data);
+        buffer.open(QIODevice::ReadOnly);
+        QCborStreamReader reader(&buffer);
+        QCborValue decoded = QCborValue::fromCbor(reader);
+        QCOMPARE(reader.lastError(), QCborError());
+        QCOMPARE(reader.currentOffset(), data.size());
+        QVERIFY(decoded == expected);
+        QVERIFY(expected == decoded);
+        QCOMPARE(buffer.pos(), reader.currentOffset());
+    };
+
+    fromCbor_common(doCheck);
+}
+
 void tst_QCborValue::validation_data()
 {
     addValidationColumns();
diff --git a/tests/auto/network/access/http2/tst_http2.cpp b/tests/auto/network/access/http2/tst_http2.cpp
index 95fee23fe3..502ffba3de 100644
--- a/tests/auto/network/access/http2/tst_http2.cpp
+++ b/tests/auto/network/access/http2/tst_http2.cpp
@@ -46,6 +46,7 @@
 #endif // NO_SSL
 
 #include <cstdlib>
+#include <memory>
 #include <string>
 
 #include "emulationdetector.h"
@@ -117,7 +118,7 @@ private:
 
     quint16 serverPort = 0;
     QThread *workerThread = nullptr;
-    QNetworkAccessManager manager;
+    std::unique_ptr<QNetworkAccessManager> manager;
 
     QTestEventLoop eventLoop;
 
@@ -131,6 +132,10 @@ private:
     static const Http2::RawSettings defaultServerSettings;
 };
 
+#define STOP_ON_FAILURE \
+    if (QTest::currentTestFailed()) \
+        return;
+
 const Http2::RawSettings tst_Http2::defaultServerSettings{{Http2::Settings::MAX_CONCURRENT_STREAMS_ID, 100}};
 
 namespace {
@@ -178,7 +183,7 @@ tst_Http2::~tst_Http2()
 
 void tst_Http2::init()
 {
-    manager.clearConnectionCache();
+    manager.reset(new QNetworkAccessManager);
 }
 
 void tst_Http2::singleRequest_data()
@@ -235,13 +240,14 @@ void tst_Http2::singleRequest()
     QFETCH(const QNetworkRequest::Attribute, h2Attribute);
     request.setAttribute(h2Attribute, QVariant(true));
 
-    auto reply = manager.get(request);
+    auto reply = manager->get(request);
     connect(reply, &QNetworkReply::finished, this, &tst_Http2::replyFinished);
     // Since we're using self-signed certificates,
     // ignore SSL errors:
     reply->ignoreSslErrors();
 
     runEventLoop();
+    STOP_ON_FAILURE
 
     QVERIFY(nRequests == 0);
     QVERIFY(prefaceOK);
@@ -277,6 +283,7 @@ void tst_Http2::multipleRequests()
         sendRequest(i, priorities[QRandomGenerator::global()->bounded(3)]);
 
     runEventLoop();
+    STOP_ON_FAILURE
 
     QVERIFY(nRequests == 0);
     QVERIFY(prefaceOK);
@@ -306,7 +313,7 @@ void tst_Http2::flowControlClientSide()
     params.maxSessionReceiveWindowSize = Http2::defaultSessionWindowSize * 5;
     params.settingsFrameData[Settings::INITIAL_WINDOW_SIZE_ID] = Http2::defaultSessionWindowSize;
     // Inform our manager about non-default settings:
-    manager.setProperty(Http2::http2ParametersPropertyName, QVariant::fromValue(params));
+    manager->setProperty(Http2::http2ParametersPropertyName, QVariant::fromValue(params));
 
     const Http2::RawSettings serverSettings = {{Settings::MAX_CONCURRENT_STREAMS_ID, quint32(3)}};
     ServerPtr srv(newServer(serverSettings, defaultConnectionType(), params));
@@ -324,6 +331,7 @@ void tst_Http2::flowControlClientSide()
         sendRequest(i);
 
     runEventLoop(120000);
+    STOP_ON_FAILURE
 
     QVERIFY(nRequests == 0);
     QVERIFY(prefaceOK);
@@ -364,6 +372,7 @@ void tst_Http2::flowControlServerSide()
         sendRequest(i, QNetworkRequest::NormalPriority, payload);
 
     runEventLoop(120000);
+    STOP_ON_FAILURE
 
     QVERIFY(nRequests == 0);
     QVERIFY(prefaceOK);
@@ -384,7 +393,7 @@ void tst_Http2::pushPromise()
     Http2::ProtocolParameters params;
     // Defaults are good, except ENABLE_PUSH:
     params.settingsFrameData[Settings::ENABLE_PUSH_ID] = 1;
-    manager.setProperty(Http2::http2ParametersPropertyName, QVariant::fromValue(params));
+    manager->setProperty(Http2::http2ParametersPropertyName, QVariant::fromValue(params));
 
     ServerPtr srv(newServer(defaultServerSettings, defaultConnectionType(), params));
     srv->enablePushPromise(true, QByteArray("/script.js"));
@@ -400,12 +409,13 @@ void tst_Http2::pushPromise()
     QNetworkRequest request(url);
     request.setAttribute(QNetworkRequest::HTTP2AllowedAttribute, QVariant(true));
 
-    auto reply = manager.get(request);
+    auto reply = manager->get(request);
     connect(reply, &QNetworkReply::finished, this, &tst_Http2::replyFinished);
     // Since we're using self-signed certificates, ignore SSL errors:
     reply->ignoreSslErrors();
 
     runEventLoop();
+    STOP_ON_FAILURE
 
     QVERIFY(nRequests == 0);
     QVERIFY(prefaceOK);
@@ -423,7 +433,7 @@ void tst_Http2::pushPromise()
     url.setPath("/script.js");
     QNetworkRequest promisedRequest(url);
     promisedRequest.setAttribute(QNetworkRequest::HTTP2AllowedAttribute, QVariant(true));
-    reply = manager.get(promisedRequest);
+    reply = manager->get(promisedRequest);
     connect(reply, &QNetworkReply::finished, this, &tst_Http2::replyFinished);
     reply->ignoreSslErrors();
 
@@ -474,7 +484,7 @@ void tst_Http2::goaway()
         url.setPath(QString("/%1").arg(i));
         QNetworkRequest request(url);
         request.setAttribute(QNetworkRequest::HTTP2AllowedAttribute, QVariant(true));
-        replies[i] = manager.get(request);
+        replies[i] = manager->get(request);
         QCOMPARE(replies[i]->error(), QNetworkReply::NoError);
         void (QNetworkReply::*errorSignal)(QNetworkReply::NetworkError) =
             &QNetworkReply::error;
@@ -484,6 +494,7 @@ void tst_Http2::goaway()
     }
 
     runEventLoop(5000 + responseTimeoutMS);
+    STOP_ON_FAILURE
 
     // No request processed, no 'replyFinished' slot calls:
     QCOMPARE(nRequests, 0);
@@ -527,6 +538,7 @@ void tst_Http2::earlyResponse()
     sendRequest(1, QNetworkRequest::NormalPriority, {1000000, Qt::Uninitialized});
 
     runEventLoop();
+    STOP_ON_FAILURE
 
     QVERIFY(nRequests == 0);
     QVERIFY(prefaceOK);
@@ -544,7 +556,7 @@ void tst_Http2::clearHTTP2State()
     windowUpdates = 0;
     prefaceOK = false;
     serverGotSettingsACK = false;
-    manager.setProperty(Http2::http2ParametersPropertyName, QVariant());
+    manager->setProperty(Http2::http2ParametersPropertyName, QVariant());
 }
 
 void tst_Http2::runEventLoop(int ms)
@@ -597,9 +609,9 @@ void tst_Http2::sendRequest(int streamNumber,
 
     QNetworkReply *reply = nullptr;
     if (payload.size())
-        reply = manager.post(request, payload);
+        reply = manager->post(request, payload);
     else
-        reply = manager.get(request);
+        reply = manager->get(request);
 
     reply->ignoreSslErrors();
     connect(reply, &QNetworkReply::finished, this, &tst_Http2::replyFinished);
@@ -691,14 +703,29 @@ void tst_Http2::replyFinished()
     QVERIFY(nRequests);
 
     if (const auto reply = qobject_cast<QNetworkReply *>(sender())) {
+        if (reply->error() != QNetworkReply::NoError)
+            stopEventLoop();
+
         QCOMPARE(reply->error(), QNetworkReply::NoError);
+
         const QVariant http2Used(reply->attribute(QNetworkRequest::HTTP2WasUsedAttribute));
+        if (!http2Used.isValid() || !http2Used.toBool())
+            stopEventLoop();
+
         QVERIFY(http2Used.isValid());
         QVERIFY(http2Used.toBool());
+
         const QVariant spdyUsed(reply->attribute(QNetworkRequest::SpdyWasUsedAttribute));
+        if (!spdyUsed.isValid() || spdyUsed.toBool())
+            stopEventLoop();
+
         QVERIFY(spdyUsed.isValid());
         QVERIFY(!spdyUsed.toBool());
+
         const QVariant code(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute));
+        if (!code.isValid() || !code.canConvert<int>() || code.value<int>() != 200)
+            stopEventLoop();
+
         QVERIFY(code.isValid());
         QVERIFY(code.canConvert<int>());
         QCOMPARE(code.value<int>(), 200);
@@ -716,6 +743,8 @@ void tst_Http2::replyFinishedWithError()
     if (const auto reply = qobject_cast<QNetworkReply *>(sender())) {
         // For now this is a 'generic' code, it just verifies some error was
         // reported without testing its type.
+        if (reply->error() == QNetworkReply::NoError)
+            stopEventLoop();
         QVERIFY(reply->error() != QNetworkReply::NoError);
     }