Merge remote-tracking branch 'origin/5.15' into dev

Change-Id: I469b0501cc65fc5ce4d797a69ae89405cc69c7f8

27 files changed, 684 insertions, 313 deletions

diff --git a/tests/auto/corelib/io/qsettings/tst_qsettings.cpp b/tests/auto/corelib/io/qsettings/tst_qsettings.cpp
index c969e72c18..427ce1a424 100644
--- a/tests/auto/corelib/io/qsettings/tst_qsettings.cpp
+++ b/tests/auto/corelib/io/qsettings/tst_qsettings.cpp
@@ -2335,14 +2335,15 @@ void tst_QSettings::testRegistry32And64Bit()
 
 void tst_QSettings::trailingWhitespace()
 {
+    const QString path = settingsPath("trailingWhitespace");
     {
-        QSettings s("tst_QSettings_trailingWhitespace");
+        QSettings s(path, QSettings::IniFormat);
         s.setValue("trailingSpace", "x  ");
         s.setValue("trailingTab", "x\t");
         s.setValue("trailingNewline", "x\n");
     }
     {
-        QSettings s("tst_QSettings_trailingWhitespace");
+        QSettings s(path, QSettings::IniFormat);
         QCOMPARE(s.value("trailingSpace").toString(), QLatin1String("x  "));
         QCOMPARE(s.value("trailingTab").toString(), QLatin1String("x\t"));
         QCOMPARE(s.value("trailingNewline").toString(), QLatin1String("x\n"));
diff --git a/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp b/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp
index 4e105d7dc7..35c5e7cb75 100644
--- a/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp
+++ b/tests/auto/corelib/kernel/qdeadlinetimer/tst_qdeadlinetimer.cpp
@@ -580,11 +580,26 @@ void tst_QDeadlineTimer::stdchrono()
     auto now = QDeadlineTimer::current(timerType);
     QTest::qSleep(minResolution);
 
+    auto sampling_start = steady_clock::now();
+    auto steady_deadline = now.deadline<steady_clock>();
+    auto system_deadline = now.deadline<system_clock>();
     auto steady_after = steady_clock::now();
     auto system_after = system_clock::now();
+    auto sampling_end = steady_clock::now();
+
+    auto sampling_diff = duration_cast<milliseconds>(sampling_end - sampling_start).count();
+    if (sampling_diff > minResolution/2) {
+        qWarning() << "Sampling clock took" << sampling_diff << "ms";
+        QSKIP("Sampling clock took too long, aborting test", Abort);
+    }
+    auto total_diff = duration_cast<milliseconds>(steady_after - steady_before).count();
+    if (total_diff >= 3*minResolution) {
+        qWarning() << "Measurement took" << total_diff << "ms";
+        QSKIP("Measurement took too long, aborting test", Abort);
+    }
 
     {
-        auto diff = duration_cast<milliseconds>(steady_after - now.deadline<steady_clock>());
+        auto diff = duration_cast<milliseconds>(steady_after - steady_deadline);
         QVERIFY2(diff.count() > minResolution/2, QByteArray::number(qint64(diff.count())));
         QVERIFY2(diff.count() < 3*minResolution/2, QByteArray::number(qint64(diff.count())));
         QDeadlineTimer dt_after(steady_after, timerType);
@@ -592,7 +607,7 @@ void tst_QDeadlineTimer::stdchrono()
                  ("now = " + QLocale().toString(now.deadlineNSecs()) +
                  "; after = " + QLocale().toString(dt_after.deadlineNSecs())).toLatin1());
 
-        diff = duration_cast<milliseconds>(now.deadline<steady_clock>() - steady_before);
+        diff = duration_cast<milliseconds>(steady_deadline - steady_before);
         QVERIFY2(diff.count() > minResolution/2, QByteArray::number(qint64(diff.count())));
         QVERIFY2(diff.count() < 3*minResolution/2, QByteArray::number(qint64(diff.count())));
         QDeadlineTimer dt_before(steady_before, timerType);
@@ -601,7 +616,7 @@ void tst_QDeadlineTimer::stdchrono()
                  "; before = " + QLocale().toString(dt_before.deadlineNSecs())).toLatin1());
     }
     {
-        auto diff = duration_cast<milliseconds>(system_after - now.deadline<system_clock>());
+        auto diff = duration_cast<milliseconds>(system_after - system_deadline);
         QVERIFY2(diff.count() > minResolution/2, QByteArray::number(qint64(diff.count())));
         QVERIFY2(diff.count() < 3*minResolution/2, QByteArray::number(qint64(diff.count())));
         QDeadlineTimer dt_after(system_after, timerType);
@@ -609,7 +624,7 @@ void tst_QDeadlineTimer::stdchrono()
                  ("now = " + QLocale().toString(now.deadlineNSecs()) +
                  "; after = " + QLocale().toString(dt_after.deadlineNSecs())).toLatin1());
 
-        diff = duration_cast<milliseconds>(now.deadline<system_clock>() - system_before);
+        diff = duration_cast<milliseconds>(system_deadline - system_before);
         QVERIFY2(diff.count() > minResolution/2, QByteArray::number(qint64(diff.count())));
         QVERIFY2(diff.count() < 3*minResolution/2, QByteArray::number(qint64(diff.count())));
         QDeadlineTimer dt_before(system_before, timerType);
diff --git a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
index b1d3ea19d6..05599f9585 100644
--- a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
+++ b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
@@ -7416,6 +7416,12 @@ void tst_QObject::checkArgumentsForNarrowing()
     FITS(bool, const QObject *&);
     FITS(int (*)(bool), void (QObject::*)());
 
+    {
+        // wg21.link/P1957
+        NARROWS(char*, bool);
+        NARROWS(void (QObject::*)(), bool);
+    }
+
 #undef IS_UNSCOPED_ENUM_SIGNED
 
 #undef NARROWS_IF
diff --git a/tests/auto/corelib/serialization/qxmlstream/tst_qxmlstream.cpp b/tests/auto/corelib/serialization/qxmlstream/tst_qxmlstream.cpp
index 12279133a2..28922574b8 100644
--- a/tests/auto/corelib/serialization/qxmlstream/tst_qxmlstream.cpp
+++ b/tests/auto/corelib/serialization/qxmlstream/tst_qxmlstream.cpp
@@ -397,8 +397,6 @@ public:
                 return true;
             }
 
-            QXmlStreamReader reader(&inputFile);
-
             /* See testcases.dtd which reads: 'Nonvalidating parsers
              * must also accept "invalid" testcases, but validating ones must reject them.' */
             if(type == QLatin1String("invalid") || type == QLatin1String("valid"))
@@ -583,6 +581,8 @@ private slots:
     void roundTrip() const;
     void roundTrip_data() const;
 
+    void entityExpansionLimit() const;
+
 private:
     static QByteArray readFile(const QString &filename);
 
@@ -1755,6 +1755,46 @@ void tst_QXmlStream::roundTrip_data() const
         "</root>\n";
 }
 
+void tst_QXmlStream::entityExpansionLimit() const
+{
+    QString xml = QStringLiteral("<?xml version=\"1.0\"?>"
+                                 "<!DOCTYPE foo ["
+                                 "<!ENTITY a \"0123456789\" >"
+                                 "<!ENTITY b \"&a;&a;&a;&a;&a;&a;&a;&a;&a;&a;\" >"
+                                 "<!ENTITY c \"&b;&b;&b;&b;&b;&b;&b;&b;&b;&b;\" >"
+                                 "<!ENTITY d \"&c;&c;&c;&c;&c;&c;&c;&c;&c;&c;\" >"
+                                 "]>"
+                                 "<foo>&d;&d;&d;</foo>");
+    {
+        QXmlStreamReader reader(xml);
+        QCOMPARE(reader.entityExpansionLimit(), 4096);
+        do {
+            reader.readNext();
+        } while (!reader.atEnd());
+        QCOMPARE(reader.error(), QXmlStreamReader::NotWellFormedError);
+    }
+
+    // &d; expands to 10k characters, minus the 3 removed (&d;) means it should fail
+    // with a limit of 9996 chars and pass with 9997
+    {
+        QXmlStreamReader reader(xml);
+        reader.setEntityExpansionLimit(9996);
+        do {
+            reader.readNext();
+        } while (!reader.atEnd());
+
+        QCOMPARE(reader.error(), QXmlStreamReader::NotWellFormedError);
+    }
+    {
+        QXmlStreamReader reader(xml);
+        reader.setEntityExpansionLimit(9997);
+        do {
+            reader.readNext();
+        } while (!reader.atEnd());
+        QCOMPARE(reader.error(), QXmlStreamReader::NoError);
+    }
+}
+
 void tst_QXmlStream::roundTrip() const
 {
     QFETCH(QString, in);
diff --git a/tests/auto/gui/image/qimagereader/tst_qimagereader.cpp b/tests/auto/gui/image/qimagereader/tst_qimagereader.cpp
index 771a4d0a32..6001829854 100644
--- a/tests/auto/gui/image/qimagereader/tst_qimagereader.cpp
+++ b/tests/auto/gui/image/qimagereader/tst_qimagereader.cpp
@@ -1081,7 +1081,7 @@ private slots:
     void acceptNewConnection()
     {
         serverSocket = server.nextPendingConnection();
-        connect(serverSocket, SIGNAL(error(QAbstractSocket::SocketError)),
+        connect(serverSocket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)),
                 this, SLOT(remoteHostClosed()));
     }
 
diff --git a/tests/auto/gui/text/qfontmetrics/tst_qfontmetrics.cpp b/tests/auto/gui/text/qfontmetrics/tst_qfontmetrics.cpp
index a0e8525268..6fe3e20083 100644
--- a/tests/auto/gui/text/qfontmetrics/tst_qfontmetrics.cpp
+++ b/tests/auto/gui/text/qfontmetrics/tst_qfontmetrics.cpp
@@ -59,6 +59,7 @@ private slots:
     void mnemonicTextWidth();
     void leadingBelowLine();
     void elidedMetrics();
+    void zeroWidthMetrics();
 };
 
 void tst_QFontMetrics::same()
@@ -358,5 +359,28 @@ void tst_QFontMetrics::elidedMetrics()
     QFontDatabase::removeApplicationFont(id);
 }
 
+void tst_QFontMetrics::zeroWidthMetrics()
+{
+    QString zwnj(QChar(0x200c));
+    QString zwsp(QChar(0x200b));
+
+    QFont font;
+    QFontMetricsF fm(font);
+    QCOMPARE(fm.horizontalAdvance(zwnj), 0);
+    QCOMPARE(fm.horizontalAdvance(zwsp), 0);
+    QCOMPARE(fm.boundingRect(zwnj).width(), 0);
+    QCOMPARE(fm.boundingRect(zwsp).width(), 0);
+
+    QString string1 = QStringLiteral("(") + zwnj + QStringLiteral(")");
+    QString string2 = QStringLiteral("(") + zwnj + zwnj + QStringLiteral(")");
+    QString string3 = QStringLiteral("(") + zwsp + QStringLiteral(")");
+    QString string4 = QStringLiteral("(") + zwsp + zwsp + QStringLiteral(")");
+
+    QCOMPARE(fm.horizontalAdvance(string1), fm.horizontalAdvance(string2));
+    QCOMPARE(fm.horizontalAdvance(string3), fm.horizontalAdvance(string4));
+    QCOMPARE(fm.boundingRect(string1).width(), fm.boundingRect(string2).width());
+    QCOMPARE(fm.boundingRect(string3).width(), fm.boundingRect(string4).width());
+}
+
 QTEST_MAIN(tst_QFontMetrics)
 #include "tst_qfontmetrics.moc"
diff --git a/tests/auto/network-settings.h b/tests/auto/network-settings.h
index 641bf1d672..4dd6ce897b 100644
--- a/tests/auto/network-settings.h
+++ b/tests/auto/network-settings.h
@@ -190,7 +190,7 @@ public:
         if (!s.peerAddress().isNull())
             debug << ", peer=" << s.peerAddress().toString() << ':' << s.peerPort();
         debug << ", type=" << s.socketType() << ", state=" << s.state()
-            << ", error=" << s.socketError() << ": " << s.errorString();
+            << ", error=" << s.error() << ": " << s.errorString();
        return result.toLocal8Bit();
     }
 #endif // QT_NETWORK_LIB
diff --git a/tests/auto/network/access/http2/tst_http2.cpp b/tests/auto/network/access/http2/tst_http2.cpp
index 38db74e52c..904cfd52b0 100644
--- a/tests/auto/network/access/http2/tst_http2.cpp
+++ b/tests/auto/network/access/http2/tst_http2.cpp
@@ -279,7 +279,7 @@ void tst_Http2::singleRequest()
     QVERIFY(prefaceOK);
     QVERIFY(serverGotSettingsACK);
 
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QVERIFY(reply->isFinished());
 }
 
@@ -444,7 +444,7 @@ void tst_Http2::pushPromise()
     QVERIFY(prefaceOK);
     QVERIFY(serverGotSettingsACK);
 
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QVERIFY(reply->isFinished());
 
     // Now, the most interesting part!
@@ -466,7 +466,7 @@ void tst_Http2::pushPromise()
     QCOMPARE(nSentRequests, 0);
     // Decreased by replyFinished():
     QCOMPARE(nRequests, 0);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QVERIFY(reply->isFinished());
 }
 
@@ -511,7 +511,7 @@ void tst_Http2::goaway()
         QNetworkRequest request(url);
         request.setAttribute(QNetworkRequest::Http2AllowedAttribute, QVariant(true));
         replies[i] = manager->get(request);
-        QCOMPARE(replies[i]->networkError(), QNetworkReply::NoError);
+        QCOMPARE(replies[i]->error(), QNetworkReply::NoError);
         void (QNetworkReply::*errorSignal)(QNetworkReply::NetworkError) =
             &QNetworkReply::error;
         connect(replies[i], errorSignal, this, &tst_Http2::replyFinishedWithError);
@@ -671,7 +671,7 @@ void tst_Http2::connectToHost()
     connect(reply, &QNetworkReply::finished, [this, reply]() {
         --nRequests;
         eventLoop.exitLoop();
-        QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+        QCOMPARE(reply->error(), QNetworkReply::NoError);
         QVERIFY(reply->isFinished());
         // Nothing received back:
         QVERIFY(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).isNull());
@@ -698,7 +698,7 @@ void tst_Http2::connectToHost()
     QVERIFY(prefaceOK);
     QVERIFY(serverGotSettingsACK);
 
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QVERIFY(reply->isFinished());
 }
 
@@ -927,10 +927,10 @@ void tst_Http2::replyFinished()
     QVERIFY(nRequests);
 
     if (const auto reply = qobject_cast<QNetworkReply *>(sender())) {
-        if (reply->networkError() != QNetworkReply::NoError)
+        if (reply->error() != QNetworkReply::NoError)
             stopEventLoop();
 
-        QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+        QCOMPARE(reply->error(), QNetworkReply::NoError);
 
         const QVariant http2Used(reply->attribute(QNetworkRequest::Http2WasUsedAttribute));
         if (!http2Used.isValid() || !http2Used.toBool())
@@ -960,9 +960,9 @@ 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->networkError() == QNetworkReply::NoError)
+        if (reply->error() == QNetworkReply::NoError)
             stopEventLoop();
-        QVERIFY(reply->networkError() != QNetworkReply::NoError);
+        QVERIFY(reply->error() != QNetworkReply::NoError);
     }
 
     --nRequests;
diff --git a/tests/auto/network/access/qabstractnetworkcache/tst_qabstractnetworkcache.cpp b/tests/auto/network/access/qabstractnetworkcache/tst_qabstractnetworkcache.cpp
index 4b6e04f467..182e3e9547 100644
--- a/tests/auto/network/access/qabstractnetworkcache/tst_qabstractnetworkcache.cpp
+++ b/tests/auto/network/access/qabstractnetworkcache/tst_qabstractnetworkcache.cpp
@@ -322,10 +322,10 @@ void tst_QAbstractNetworkCache::runTest()
 
     QByteArray secondData = reply2->readAll();
     if (!fetchFromCache && cacheLoadControl == QNetworkRequest::AlwaysCache) {
-        QCOMPARE(reply2->networkError(), QNetworkReply::ContentNotFoundError);
+        QCOMPARE(reply2->error(), QNetworkReply::ContentNotFoundError);
         QCOMPARE(secondData, QByteArray());
     } else {
-        QCOMPARE(reply2->networkError(), QNetworkReply::NoError);
+        QCOMPARE(reply2->error(), QNetworkReply::NoError);
         QCOMPARE(QString(secondData), QString(goodData));
         QCOMPARE(secondData, goodData);
         QCOMPARE(reply2->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
@@ -375,12 +375,12 @@ void tst_QAbstractNetworkCache::checkSynchronous()
 
     QByteArray secondData = reply2->readAll();
     if (!fetchFromCache && cacheLoadControl == QNetworkRequest::AlwaysCache) {
-        QCOMPARE(reply2->networkError(), QNetworkReply::ContentNotFoundError);
+        QCOMPARE(reply2->error(), QNetworkReply::ContentNotFoundError);
         QCOMPARE(secondData, QByteArray());
     } else {
-        if (reply2->networkError() != QNetworkReply::NoError)
+        if (reply2->error() != QNetworkReply::NoError)
             qDebug() << reply2->errorString();
-        QCOMPARE(reply2->networkError(), QNetworkReply::NoError);
+        QCOMPARE(reply2->error(), QNetworkReply::NoError);
         QCOMPARE(QString(secondData), QString(goodData));
         QCOMPARE(secondData, goodData);
         QCOMPARE(reply2->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
diff --git a/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp b/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
index 5ddcc5ae37..5d46002a7c 100644
--- a/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
+++ b/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
@@ -684,7 +684,7 @@ private:
         //qDebug() << "connectSocketSignals" << client;
         connect(client.data(), SIGNAL(readyRead()), this, SLOT(readyReadSlot()));
         connect(client.data(), SIGNAL(bytesWritten(qint64)), this, SLOT(bytesWrittenSlot()));
-        connect(client.data(), SIGNAL(error(QAbstractSocket::SocketError)),
+        connect(client.data(), SIGNAL(errorOccurred(QAbstractSocket::SocketError)),
                 this, SLOT(slotError(QAbstractSocket::SocketError)));
     }
 
@@ -1121,7 +1121,7 @@ protected:
 
         // get the "request" packet
         if (!client->waitForReadyRead(2000)) {
-            qDebug() << "FastSender:" << client->socketError() << "waiting for \"request\" packet";
+            qDebug() << "FastSender:" << client->error() << "waiting for \"request\" packet";
             return;
         }
         client->readAll();      // we're not interested in the actual contents (e.g. HTTP request)
@@ -1158,7 +1158,7 @@ protected:
         while (client->bytesToWrite() > 0) {
             qDebug() << "Still having" << client->bytesToWrite() << "bytes to write, doing that now";
             if (!client->waitForBytesWritten(10000)) {
-                qDebug() << "ERROR: FastSender:" << client->socketError() << "cleaning up residue";
+                qDebug() << "ERROR: FastSender:" << client->error() << "cleaning up residue";
                 return;
             }
         }
@@ -1178,7 +1178,7 @@ protected:
 
             while (client->bytesToWrite() > 0) {
                 if (!client->waitForBytesWritten(10000)) {
-                    qDebug() << "ERROR: FastSender:" << client->socketError() << "during blocking write";
+                    qDebug() << "ERROR: FastSender:" << client->error() << "during blocking write";
                     return;
                 }
             }
@@ -1436,7 +1436,7 @@ QString tst_QNetworkReply::runSimpleRequest(QNetworkAccessManager::Operation op,
 
     if (request.attribute(QNetworkRequest::SynchronousRequestAttribute).toBool()) {
         if (reply->isFinished())
-            code = reply->networkError() != QNetworkReply::NoError ? Failure : Success;
+            code = reply->error() != QNetworkReply::NoError ? Failure : Success;
         else
             code = Failure;
     } else {
@@ -1501,10 +1501,10 @@ static QByteArray msgWaitForFinished(QNetworkReplyPtr &reply)
     debug << reply->url();
     if (!reply->isFinished())
         debug << "timed out.";
-    else if (reply->networkError() == QNetworkReply::NoError)
+    else if (reply->error() == QNetworkReply::NoError)
         debug << "finished.";
     else
-        debug << "failed: #" << reply->networkError() << reply->errorString();
+        debug << "failed: #" << reply->error() << reply->errorString();
     return result.toLocal8Bit();
 }
 
@@ -1652,7 +1652,7 @@ void tst_QNetworkReply::stateChecking()
     QCOMPARE(int(reply->operation()), int(QNetworkAccessManager::GetOperation));
     // error and not error are OK since we might change underlying behaviour again
     if (!reply->isFinished())
-        QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+        QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->url(), url);
 
     reply->abort();
@@ -1669,7 +1669,7 @@ void tst_QNetworkReply::invalidProtocol()
     QCOMPARE(result, errorMsg);
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::ProtocolUnknownError);
+    QCOMPARE(reply->error(), QNetworkReply::ProtocolUnknownError);
 }
 
 void tst_QNetworkReply::getFromData_data()
@@ -1761,7 +1761,7 @@ void tst_QNetworkReply::getFromData()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::GetOperation, req, reply));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->header(QNetworkRequest::ContentTypeHeader).toString(), mimeType);
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), qint64(expected.size()));
@@ -1800,7 +1800,7 @@ void tst_QNetworkReply::getFromFile()
     QVERIFY(waitForFinish(reply) != Timeout);
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), file.size());
     QCOMPARE(reply->readAll(), data);
@@ -1817,7 +1817,7 @@ void tst_QNetworkReply::getFromFile()
 
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::GetOperation, request, reply));
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), file.size());
     QCOMPARE(qint64(reply->readAll().size()), file.size());
@@ -1856,7 +1856,7 @@ void tst_QNetworkReply::getFromFileSpecial()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::GetOperation, request, reply));
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), resource.size());
     QCOMPARE(reply->readAll(), resource.readAll());
@@ -1890,7 +1890,7 @@ void tst_QNetworkReply::getFromFtp()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::GetOperation, request, reply));
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), reference.size());
     QCOMPARE(reply->readAll(), reference.readAll());
@@ -1903,7 +1903,7 @@ void tst_QNetworkReply::getFromFtpAfterError()
     invalidReply.reset(manager.get(invalidRequest));
     QSignalSpy spy(invalidReply.data(), SIGNAL(error(QNetworkReply::NetworkError)));
     QVERIFY(spy.wait());
-    QCOMPARE(invalidReply->networkError(), QNetworkReply::ContentNotFoundError);
+    QCOMPARE(invalidReply->error(), QNetworkReply::ContentNotFoundError);
 
     QFile reference(testDataDir + "/rfc3252.txt");
     QVERIFY(reference.open(QIODevice::ReadOnly));
@@ -1911,7 +1911,7 @@ void tst_QNetworkReply::getFromFtpAfterError()
     QNetworkReplyPtr validReply;
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::GetOperation, validRequest, validReply));
     QCOMPARE(validReply->url(), validRequest.url());
-    QCOMPARE(validReply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(validReply->error(), QNetworkReply::NoError);
     QCOMPARE(validReply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), reference.size());
     QCOMPARE(validReply->readAll(), reference.readAll());
 }
@@ -1944,7 +1944,7 @@ void tst_QNetworkReply::getFromHttp()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::GetOperation, request, reply));
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
     QCOMPARE(reply->size(), reference.size());
     // only compare when the header is set.
@@ -2039,7 +2039,7 @@ void tst_QNetworkReply::headFromHttp()
     QVERIFY(time.elapsed() < 8000); //check authentication didn't wait for the server to timeout the http connection (15s on qt test server)
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
     // only compare when the header is set.
     if (reply->header(QNetworkRequest::ContentLengthHeader).isValid() && referenceSize >= 0)
@@ -2115,8 +2115,8 @@ static QByteArray msgGetErrors(int waitResult, const QNetworkReplyPtr &reply)
     QByteArray result ="waitResult=" + QByteArray::number(waitResult);
     if (reply->isFinished())
         result += ", finished";
-    if (reply->networkError() != QNetworkReply::NoError)
-        result += ", error: " + QByteArray::number(int(reply->networkError()));
+    if (reply->error() != QNetworkReply::NoError)
+        result += ", error: " + QByteArray::number(int(reply->error()));
     return result;
 }
 
@@ -2146,7 +2146,7 @@ void tst_QNetworkReply::getErrors()
     reply->setParent(this);     // we have expect-fails
 
     if (!reply->isFinished())
-        QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+        QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     // now run the request:
     const int waitResult = waitForFinish(reply);
@@ -2158,7 +2158,7 @@ void tst_QNetworkReply::getErrors()
     // the line below is not necessary
     QEXPECT_FAIL("ftp-dir-not-readable", "QFtp cannot provide enough detail", Abort);
 #endif
-    QCOMPARE(reply->networkError(), QNetworkReply::NetworkError(error));
+    QCOMPARE(reply->error(), QNetworkReply::NetworkError(error));
 
     QTEST(reply->readAll().isEmpty(), "dataIsEmpty");
 
@@ -2217,7 +2217,7 @@ void tst_QNetworkReply::putToFile()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::PutOperation, request, reply, data));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), Q_INT64_C(0));
     QVERIFY(reply->readAll().isEmpty());
 
@@ -2248,7 +2248,7 @@ void tst_QNetworkReply::putToFtp()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::PutOperation, request, reply, data));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), Q_INT64_C(0));
     QVERIFY(reply->readAll().isEmpty());
 
@@ -2296,7 +2296,7 @@ void tst_QNetworkReply::putToFtpWithInvalidCredentials()
 
         QVERIFY(r->isFinished());
         QCOMPARE(r->url(), url);
-        QCOMPARE(r->networkError(), QNetworkReply::AuthenticationRequiredError);
+        QCOMPARE(r->error(), QNetworkReply::AuthenticationRequiredError);
         r->close();
     }
 }
@@ -2322,7 +2322,7 @@ void tst_QNetworkReply::putToHttp()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::PutOperation, request, reply, data));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 201); // 201 Created
 
@@ -2363,7 +2363,7 @@ void tst_QNetworkReply::putToHttpSynchronous()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::PutOperation, request, reply, data));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 201); // 201 Created
 
@@ -2397,7 +2397,7 @@ void tst_QNetworkReply::postToHttp()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::PostOperation, request, reply, data));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200); // 200 Ok
 
@@ -2429,7 +2429,7 @@ void tst_QNetworkReply::postToHttpSynchronous()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::PostOperation, request, reply, data));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200); // 200 Ok
 
@@ -2692,7 +2692,7 @@ void tst_QNetworkReply::postToHttpMultipart()
     multiPart->deleteLater();
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200); // 200 Ok
 
@@ -2734,7 +2734,7 @@ void tst_QNetworkReply::multipartSkipIndices() // QTBUG-32534
     QNetworkReplyPtr reply;
     RUN_REQUEST(runMultipartRequest(request, reply, multiPart, "POST"));
 
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200); // 200 Ok
     QByteArray line;
@@ -2780,7 +2780,7 @@ void tst_QNetworkReply::putToHttpMultipart()
     multiPart->deleteLater();
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200); // 200 Ok
 
@@ -2819,7 +2819,7 @@ void tst_QNetworkReply::putToHttps()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::PutOperation, request, reply, data));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 201); // 201 Created
 
@@ -2864,7 +2864,7 @@ void tst_QNetworkReply::putToHttpsSynchronous()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::PutOperation, request, reply, data));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 201); // 201 Created
 
@@ -2902,7 +2902,7 @@ void tst_QNetworkReply::postToHttps()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::PostOperation, request, reply, data));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200); // 200 Ok
 
@@ -2938,7 +2938,7 @@ void tst_QNetworkReply::postToHttpsSynchronous()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::PostOperation, request, reply, data));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200); // 200 Ok
 
@@ -2983,7 +2983,7 @@ void tst_QNetworkReply::postToHttpsMultipart()
     multiPart->deleteLater();
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200); // 200 Ok
 
@@ -3036,7 +3036,7 @@ void tst_QNetworkReply::deleteFromHttp()
     QNetworkReplyPtr reply;
     runSimpleRequest(QNetworkAccessManager::DeleteOperation, request, reply, 0);
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), error);
+    QCOMPARE(reply->error(), error);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), resultCode);
 }
 
@@ -3086,19 +3086,19 @@ void tst_QNetworkReply::putGetDeleteGetFromHttp()
     QNetworkReplyPtr reply;
 
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::PutOperation, putRequest, reply, 0));
-    QCOMPARE(reply->networkError(), putError);
+    QCOMPARE(reply->error(), putError);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), putResultCode);
 
     runSimpleRequest(QNetworkAccessManager::GetOperation, putRequest, reply, 0);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
 
     runSimpleRequest(QNetworkAccessManager::DeleteOperation, deleteRequest, reply, 0);
-    QCOMPARE(reply->networkError(), deleteError);
+    QCOMPARE(reply->error(), deleteError);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), deleteResultCode);
 
     runSimpleRequest(QNetworkAccessManager::GetOperation, get2Request, reply, 0);
-    QCOMPARE(reply->networkError(), get2Error);
+    QCOMPARE(reply->error(), get2Error);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), get2ResultCode);
 
 }
@@ -3143,7 +3143,7 @@ void tst_QNetworkReply::connectToIPv6Address()
     QVERIFY(server.receivedData.contains(hostinfo));
     QCOMPARE(content, dataToSend);
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), error);
+    QCOMPARE(reply->error(), error);
 }
 
 void tst_QNetworkReply::sendCustomRequestToHttp_data()
@@ -3189,7 +3189,7 @@ void tst_QNetworkReply::sendCustomRequestToHttp()
     runCustomRequest(request, reply, verb, device);
     QCOMPARE(reply->url(), url);
     QFETCH(QNetworkReply::NetworkError, error);
-    QCOMPARE(reply->networkError(), error);
+    QCOMPARE(reply->error(), error);
     QFETCH(int, resultCode);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), resultCode);
     QFETCH(QByteArray, expectedContent);
@@ -3225,7 +3225,7 @@ void tst_QNetworkReply::ioGetFromData()
     QVERIFY(!QTestEventLoop::instance().timeout());
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QFETCH(QByteArray, data);
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toInt(), data.size());
@@ -3261,7 +3261,7 @@ void tst_QNetworkReply::ioGetFromFileSpecial()
     QVERIFY(!QTestEventLoop::instance().timeout());
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), resource.size());
     QCOMPARE(qint64(reader.data.size()), resource.size());
@@ -3294,7 +3294,7 @@ void tst_QNetworkReply::ioGetFromFile()
     QVERIFY(!QTestEventLoop::instance().timeout());
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), file.size());
     QCOMPARE(qint64(reader.data.size()), file.size());
@@ -3326,7 +3326,7 @@ void tst_QNetworkReply::ioGetFromFtp()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QFETCH(qint64, expectedSize);
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), expectedSize);
@@ -3356,8 +3356,8 @@ void tst_QNetworkReply::ioGetFromFtpWithReuse()
 
     QCOMPARE(reply1->url(), request.url());
     QCOMPARE(reply2->url(), request.url());
-    QCOMPARE(reply1->networkError(), QNetworkReply::NoError);
-    QCOMPARE(reply2->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply1->error(), QNetworkReply::NoError);
+    QCOMPARE(reply2->error(), QNetworkReply::NoError);
 
     QCOMPARE(qint64(reader1.data.size()), reference.size());
     QCOMPARE(qint64(reader2.data.size()), reference.size());
@@ -3382,7 +3382,7 @@ void tst_QNetworkReply::ioGetFromHttp()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
 
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), reference.size());
@@ -3408,8 +3408,8 @@ void tst_QNetworkReply::ioGetFromHttpWithReuseParallel()
 
     QCOMPARE(reply1->url(), request.url());
     QCOMPARE(reply2->url(), request.url());
-    QCOMPARE(reply1->networkError(), QNetworkReply::NoError);
-    QCOMPARE(reply2->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply1->error(), QNetworkReply::NoError);
+    QCOMPARE(reply2->error(), QNetworkReply::NoError);
     QCOMPARE(reply1->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
     QCOMPARE(reply2->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
 
@@ -3436,7 +3436,7 @@ void tst_QNetworkReply::ioGetFromHttpWithReuseSequential()
         QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
         QCOMPARE(reply->url(), request.url());
-        QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+        QCOMPARE(reply->error(), QNetworkReply::NoError);
         QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
 
         QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), reference.size());
@@ -3454,7 +3454,7 @@ void tst_QNetworkReply::ioGetFromHttpWithReuseSequential()
         QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
         QCOMPARE(reply->url(), request.url());
-        QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+        QCOMPARE(reply->error(), QNetworkReply::NoError);
         QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
 
         QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), reference.size());
@@ -3577,7 +3577,7 @@ void tst_QNetworkReply::ioGetFromHttpWithAuth()
         QVERIFY(replySync->isFinished()); // synchronous
         if (expectedAuth) {
             // bad credentials in a synchronous request should just fail
-            QCOMPARE(replySync->networkError(), QNetworkReply::AuthenticationRequiredError);
+            QCOMPARE(replySync->error(), QNetworkReply::AuthenticationRequiredError);
         } else {
             QCOMPARE(authspy.count(), 0);
 
@@ -3603,7 +3603,7 @@ void tst_QNetworkReply::ioGetFromHttpWithAuth()
         QVERIFY(replySync->isFinished()); // synchronous
         if (expectedAuth) {
             // bad credentials in a synchronous request should just fail
-            QCOMPARE(replySync->networkError(), QNetworkReply::AuthenticationRequiredError);
+            QCOMPARE(replySync->error(), QNetworkReply::AuthenticationRequiredError);
         } else {
             QCOMPARE(authspy.count(), 0);
 
@@ -3630,7 +3630,7 @@ void tst_QNetworkReply::ioGetFromHttpWithAuthSynchronous()
     QSignalSpy authspy(&manager, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)));
     QNetworkReplyPtr replySync(manager.get(request));
     QVERIFY(replySync->isFinished()); // synchronous
-    QCOMPARE(replySync->networkError(), QNetworkReply::AuthenticationRequiredError);
+    QCOMPARE(replySync->error(), QNetworkReply::AuthenticationRequiredError);
     QCOMPARE(authspy.count(), 0);
     QCOMPARE(replySync->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 401);
 }
@@ -3735,7 +3735,7 @@ void tst_QNetworkReply::ioGetFromHttpWithProxyAuthSynchronous()
     QNetworkReplyPtr replySync(manager.get(request));
     manager.setProxy(QNetworkProxy()); // reset
     QVERIFY(replySync->isFinished()); // synchronous
-    QCOMPARE(replySync->networkError(), QNetworkReply::ProxyAuthenticationRequiredError);
+    QCOMPARE(replySync->error(), QNetworkReply::ProxyAuthenticationRequiredError);
     QCOMPARE(authspy.count(), 0);
     QCOMPARE(replySync->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 407);
 }
@@ -3791,9 +3791,9 @@ void tst_QNetworkReply::ioGetFromHttpWithSocksProxy()
         QVERIFY(!reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).isValid());
         QVERIFY(reader.data.isEmpty());
 
-        QVERIFY(int(reply->networkError()) > 0);
+        QVERIFY(int(reply->error()) > 0);
         QEXPECT_FAIL("", "QTcpSocket doesn't return enough information yet", Continue);
-        QCOMPARE(int(reply->networkError()), int(QNetworkReply::ProxyConnectionRefusedError));
+        QCOMPARE(int(reply->error()), int(QNetworkReply::ProxyConnectionRefusedError));
 
         QCOMPARE(authspy.count(), 0);
     }
@@ -3873,7 +3873,7 @@ void tst_QNetworkReply::ioGetFromHttpsWithSslHandshakeError()
 
     QCOMPARE(waitForFinish(reply), int(Failure));
 
-    QCOMPARE(reply->networkError(), QNetworkReply::SslHandshakeFailedError);
+    QCOMPARE(reply->error(), QNetworkReply::SslHandshakeFailedError);
     QCOMPARE(sslspy.count(), 0);
 }
 #endif
@@ -3933,7 +3933,7 @@ void tst_QNetworkReply::ioGetFromHttpBrokenServer()
 
     QCOMPARE(reply->url(), request.url());
     QCOMPARE(spy.count(), 1);
-    QVERIFY(reply->networkError() != QNetworkReply::NoError);
+    QVERIFY(reply->error() != QNetworkReply::NoError);
 }
 
 void tst_QNetworkReply::ioGetFromHttpStatus100_data()
@@ -3962,7 +3962,7 @@ void tst_QNetworkReply::ioGetFromHttpStatus100()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), statusCode);
     QVERIFY(reply->rawHeader("bla").isNull());
 }
@@ -3985,7 +3985,7 @@ void tst_QNetworkReply::ioGetFromHttpNoHeaders()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
 }
 
@@ -4432,7 +4432,7 @@ void tst_QNetworkReply::ioGetWithManyProxies()
 #if QT_CONFIG(ftp)
     QEXPECT_FAIL("ftp-on-socks", "QFtp is too limited and won't accept non-FTP proxies", Abort);
 #endif
-    QCOMPARE(reply->networkError(), expectedError);
+    QCOMPARE(reply->error(), expectedError);
 
     // Verify that the factory was called properly
     QCOMPARE(proxyFactory->callCount, 1);
@@ -4486,7 +4486,7 @@ void tst_QNetworkReply::ioPutToFileFromFile()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), Q_INT64_C(0));
     QVERIFY(reply->readAll().isEmpty());
 
@@ -4519,10 +4519,10 @@ void tst_QNetworkReply::ioPutToFileFromSocket()
     socketpair.endPoints[0]->close();
 
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), Q_INT64_C(0));
     QVERIFY(reply->readAll().isEmpty());
 
@@ -4567,10 +4567,10 @@ void tst_QNetworkReply::ioPutToFileFromLocalSocket()
         QEXPECT_FAIL("", "QTBUG-18385", Abort);
 #endif
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), Q_INT64_C(0));
     QVERIFY(reply->readAll().isEmpty());
 
@@ -4619,7 +4619,7 @@ void tst_QNetworkReply::ioPutToFileFromProcess()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), Q_INT64_C(0));
     QVERIFY(reply->readAll().isEmpty());
 
@@ -4654,7 +4654,7 @@ void tst_QNetworkReply::ioPutToFtpFromFile()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), Q_INT64_C(0));
     QVERIFY(reply->readAll().isEmpty());
 
@@ -4704,7 +4704,7 @@ void tst_QNetworkReply::ioPutToHttpFromFile()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     // verify that the HTTP status code is 201 Created
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 201);
@@ -4719,7 +4719,7 @@ void tst_QNetworkReply::ioPutToHttpFromFile()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200); // 200 Ok
 
     QCOMPARE(reply->readAll(), sourceFile.readAll());
@@ -4745,7 +4745,7 @@ void tst_QNetworkReply::ioPostToHttpFromFile()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     // verify that the HTTP status code is 200 Ok
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
@@ -4835,10 +4835,10 @@ void tst_QNetworkReply::ioPostToHttpFromSocket()
                this, SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));
     disconnect(&manager, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)),
                this, SLOT(authenticationRequired(QNetworkReply*,QAuthenticator*)));
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     // verify that the HTTP status code is 200 Ok
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
 
@@ -4898,10 +4898,10 @@ void tst_QNetworkReply::ioPostToHttpFromSocketSynchronous()
     QVERIFY(reply->isFinished());
     socketpair.endPoints[0]->close();
 
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     // verify that the HTTP status code is 200 Ok
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
 
@@ -5021,7 +5021,7 @@ void tst_QNetworkReply::ioPostToHttpNoBufferFlag()
                this, SLOT(authenticationRequired(QNetworkReply*,QAuthenticator*)));
 
     // verify: error code is QNetworkReply::ContentReSendError
-    QCOMPARE(reply->networkError(), QNetworkReply::ContentReSendError);
+    QCOMPARE(reply->error(), QNetworkReply::ContentReSendError);
 }
 
 #ifndef QT_NO_SSL
@@ -5203,7 +5203,7 @@ void tst_QNetworkReply::ioGetFromBuiltinHttp()
              << "(it received" << reader.totalBytesRead << "bytes in" << elapsedTime << "ms)";
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
 
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), (qint64)testData.size());
@@ -5439,7 +5439,7 @@ void tst_QNetworkReply::httpCanReadLine()
 
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QVERIFY(reply->canReadLine());
     QVERIFY(!reply->readAll().isEmpty());
@@ -5498,7 +5498,7 @@ void tst_QNetworkReply::rateControl()
     sender.wait();
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QVERIFY(sender.transferRate != -1);
     int minRate = rate * 1024 * 9 / 10;
@@ -5648,11 +5648,11 @@ void tst_QNetworkReply::chaining()
     QCOMPARE(waitForFinish(putReply), int(Success));
 
     QCOMPARE(getReply->url(), QUrl::fromLocalFile(sourceFile.fileName()));
-    QCOMPARE(getReply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(getReply->error(), QNetworkReply::NoError);
     QCOMPARE(getReply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), sourceFile.size());
 
     QCOMPARE(putReply->url(), url);
-    QCOMPARE(putReply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(putReply->error(), QNetworkReply::NoError);
     QCOMPARE(putReply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), Q_INT64_C(0));
     QVERIFY(putReply->readAll().isEmpty());
 
@@ -5723,7 +5723,7 @@ void tst_QNetworkReply::receiveCookiesFromHttp()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::PostOperation, request, reply, data));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200); // 200 Ok
 
@@ -5755,7 +5755,7 @@ void tst_QNetworkReply::receiveCookiesFromHttpSynchronous()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::PostOperation, request, reply, data));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200); // 200 Ok
 
@@ -5818,7 +5818,7 @@ void tst_QNetworkReply::sendCookies()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::GetOperation, request, reply));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200); // 200 Ok
 
@@ -5847,7 +5847,7 @@ void tst_QNetworkReply::sendCookiesSynchronous()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::GetOperation, request, reply));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200); // 200 Ok
 
@@ -5940,6 +5940,9 @@ void tst_QNetworkReply::httpProxyCommands()
     // wait for the finished signal
     QVERIFY(waitForFinish(reply) != Timeout);
 
+    //qDebug() << reply->error() << reply->errorString();
+    //qDebug() << proxyServer.receivedData;
+
     // we don't really care if the request succeeded
     // especially since it won't succeed in the HTTPS case
     // so just check that the command was correct
@@ -6022,6 +6025,8 @@ void tst_QNetworkReply::httpProxyCommandsSynchronous()
     QVERIFY(reply->isFinished()); // synchronous
     manager.setProxy(QNetworkProxy());
 
+    //qDebug() << reply->error() << reply->errorString();
+
     // we don't really care if the request succeeded
     // especially since it won't succeed in the HTTPS case
     // so just check that the command was correct
@@ -6061,11 +6066,11 @@ void tst_QNetworkReply::proxyChange()
     QVERIFY(!QTestEventLoop::instance().timeout());
 
     // verify that the replies succeeded
-    QCOMPARE(reply1->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply1->error(), QNetworkReply::NoError);
     QCOMPARE(reply1->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
     QCOMPARE(reply1->size(), 1);
 
-    QCOMPARE(reply2->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply2->error(), QNetworkReply::NoError);
     QCOMPARE(reply2->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
     QVERIFY(reply2->size() > 1);
 
@@ -6082,7 +6087,7 @@ void tst_QNetworkReply::proxyChange()
 
     QCOMPARE(waitForFinish(reply3), int(Failure));
 
-    QVERIFY(int(reply3->networkError()) > 0);
+    QVERIFY(int(reply3->error()) > 0);
 }
 #endif // !QT_NO_NETWORKPROXY
 
@@ -6115,7 +6120,7 @@ void tst_QNetworkReply::authorizationError()
     QNetworkRequest request(url);
     QNetworkReplyPtr reply(manager.get(request));
 
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QSignalSpy errorSpy(reply.data(), SIGNAL(error(QNetworkReply::NetworkError)));
     QSignalSpy finishedSpy(reply.data(), SIGNAL(finished()));
@@ -6127,7 +6132,7 @@ void tst_QNetworkReply::authorizationError()
     QFETCH(int, finishedSignalCount);
     QCOMPARE(finishedSpy.count(), finishedSignalCount);
     QFETCH(int, error);
-    QCOMPARE(reply->networkError(), QNetworkReply::NetworkError(error));
+    QCOMPARE(reply->error(), QNetworkReply::NetworkError(error));
 
     QFETCH(int, httpStatusCode);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), httpStatusCode);
@@ -6195,7 +6200,7 @@ void tst_QNetworkReply::httpReUsingConnectionSequential()
     connect(reply1, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
     QTestEventLoop::instance().enterLoop(2);
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QVERIFY(!reply1->networkError());
+    QVERIFY(!reply1->error());
     int reply1port = server.client->peerPort();
 
     if (doDeleteLater)
@@ -6206,7 +6211,7 @@ void tst_QNetworkReply::httpReUsingConnectionSequential()
     connect(reply2, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
     QTestEventLoop::instance().enterLoop(2);
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QVERIFY(!reply2->networkError());
+    QVERIFY(!reply2->error());
     int reply2port = server.client->peerPort(); // should still be the same object
 
     QVERIFY(reply1port > 0);
@@ -6229,7 +6234,7 @@ public:
 public slots:
     void finishedSlot()
     {
-        QVERIFY(!reply1->networkError());
+        QVERIFY(!reply1->error());
 
         QFETCH(bool, doDeleteLater);
         if (doDeleteLater) {
@@ -6271,7 +6276,7 @@ void tst_QNetworkReply::httpReUsingConnectionFromFinishedSlot()
     QVERIFY(!QTestEventLoop::instance().timeout());
 
     QVERIFY(helper.reply2);
-    QVERIFY(!helper.reply2->networkError());
+    QVERIFY(!helper.reply2->error());
 
     QCOMPARE(server.totalConnections, 1);
 }
@@ -6298,7 +6303,7 @@ public slots:
         requestsFinishedCount++;
 
         QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender());
-        QVERIFY(!reply->networkError());
+        QVERIFY(!reply->error());
         QCOMPARE(reply->bytesAvailable(), 27906);
 
         if (requestsFinishedCount == 60) {
@@ -6316,7 +6321,7 @@ public slots:
     void readyReadSlot()
     {
         QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender());
-        QVERIFY(!reply->networkError());
+        QVERIFY(!reply->error());
 
         if (requestsStartedCount_readyRead < 30 && reply->bytesAvailable() > 27906/2) {
             startOne();
@@ -6378,7 +6383,7 @@ void tst_QNetworkReply::ignoreSslErrorsList()
     QVERIFY(waitForFinish(reply) != Timeout);
 
     QFETCH(QNetworkReply::NetworkError, expectedNetworkError);
-    QCOMPARE(reply->networkError(), expectedNetworkError);
+    QCOMPARE(reply->error(), expectedNetworkError);
 }
 
 void tst_QNetworkReply::ignoreSslErrorsListWithSlot_data()
@@ -6409,7 +6414,7 @@ void tst_QNetworkReply::ignoreSslErrorsListWithSlot()
     QVERIFY(waitForFinish(reply) != Timeout);
 
     QFETCH(QNetworkReply::NetworkError, expectedNetworkError);
-    QCOMPARE(reply->networkError(), expectedNetworkError);
+    QCOMPARE(reply->error(), expectedNetworkError);
 }
 
 void tst_QNetworkReply::sslConfiguration_data()
@@ -6488,7 +6493,7 @@ void tst_QNetworkReply::sslConfiguration()
 
     QFETCH(bool, works);
     QNetworkReply::NetworkError expectedError = works ? QNetworkReply::NoError : QNetworkReply::SslHandshakeFailedError;
-    QCOMPARE(reply->networkError(), expectedError);
+    QCOMPARE(reply->error(), expectedError);
 }
 
 #ifdef QT_BUILD_INTERNAL
@@ -6523,7 +6528,7 @@ void tst_QNetworkReply::sslSessionSharing()
     connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
     QTestEventLoop::instance().enterLoop(20);
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     reply->deleteLater();
 
     // now send several requests at the same time, so we open more sockets and reuse the SSL session
@@ -6548,7 +6553,7 @@ void tst_QNetworkReply::sslSessionSharingHelperSlot()
         sslSessionSharingWasUsed = true;
 
     QString urlQueryString = reply->url().query();
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     count++;
 
@@ -6589,7 +6594,7 @@ void tst_QNetworkReply::sslSessionSharingFromPersistentSession()
     connect(warmupReply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
     QTestEventLoop::instance().enterLoop(20);
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QCOMPARE(warmupReply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(warmupReply->error(), QNetworkReply::NoError);
     QByteArray sslSession = warmupReply->sslConfiguration().sessionTicket();
     QCOMPARE(!sslSession.isEmpty(), sessionPersistenceEnabled);
 
@@ -6617,7 +6622,7 @@ void tst_QNetworkReply::sslSessionSharingFromPersistentSession()
     connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
     QTestEventLoop::instance().enterLoop(20);
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     bool sslSessionSharingWasUsedInReply = QSslConfigurationPrivate::peerSessionWasShared(
                 reply->sslConfiguration());
@@ -6671,7 +6676,7 @@ void tst_QNetworkReply::symbianOpenCDataUrlCrash()
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::GetOperation, req, reply));
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), qint64(598));
 }
@@ -6891,7 +6896,7 @@ void tst_QNetworkReply::getFromHttpIntoBuffer2()
 
     connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()), Qt::QueuedConnection);
     QTestEventLoop::instance().enterLoop(40);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QVERIFY(!QTestEventLoop::instance().timeout());
 }
 
@@ -6909,7 +6914,7 @@ void tst_QNetworkReply::getFromHttpIntoBufferCanReadLine()
 
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QVERIFY(reply->canReadLine());
     QCOMPARE(reply->read(1), QByteArray("x"));
     QVERIFY(reply->canReadLine());
@@ -6935,7 +6940,7 @@ void tst_QNetworkReply::ioGetFromHttpWithoutContentLength()
 
     QCOMPARE(reply->url(), request.url());
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 }
 
 // Is handled somewhere else too, introduced this special test to have it more accessible
@@ -6957,7 +6962,7 @@ void tst_QNetworkReply::ioGetFromHttpBrokenChunkedEncoding()
     QVERIFY(!QTestEventLoop::instance().timeout());
     QEXPECT_FAIL(0, "We should close the socket and not just do nothing", Continue);
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 }
 
 // TODO:
@@ -6981,7 +6986,7 @@ void tst_QNetworkReply::qtbug12908compressedHttpReply()
 
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->size(), qint64(16384));
     QCOMPARE(reply->readAll(), QByteArray(16384, '\0'));
 }
@@ -7004,7 +7009,7 @@ void tst_QNetworkReply::compressedHttpReplyBrokenGzip()
 
     QCOMPARE(waitForFinish(reply), int(Failure));
 
-    QCOMPARE(reply->networkError(), QNetworkReply::ProtocolFailure);
+    QCOMPARE(reply->error(), QNetworkReply::ProtocolFailure);
 }
 
 // TODO add similar test for FTP
@@ -7059,7 +7064,7 @@ void tst_QNetworkReply::getFromUnreachableIp()
 
     QCOMPARE(waitForFinish(reply), int(Failure));
 
-    QVERIFY(reply->networkError() != QNetworkReply::NoError);
+    QVERIFY(reply->error() != QNetworkReply::NoError);
 }
 
 void tst_QNetworkReply::qtbug4121unknownAuthentication()
@@ -7083,7 +7088,7 @@ void tst_QNetworkReply::qtbug4121unknownAuthentication()
     QCOMPARE(finishedSpy.count(), 1);
     QCOMPARE(errorSpy.count(), 1);
 
-    QCOMPARE(reply->networkError(), QNetworkReply::AuthenticationRequiredError);
+    QCOMPARE(reply->error(), QNetworkReply::AuthenticationRequiredError);
 }
 
 #ifndef QT_NO_NETWORKPROXY
@@ -7174,7 +7179,7 @@ void tst_QNetworkReply::authenticationCacheAfterCancel()
         QTestEventLoop::instance().enterLoop(10);
         QVERIFY(!QTestEventLoop::instance().timeout());
 
-        QCOMPARE(reply->networkError(), QNetworkReply::ProxyAuthenticationRequiredError);
+        QCOMPARE(reply->error(), QNetworkReply::ProxyAuthenticationRequiredError);
         QCOMPARE(authSpy.count(), 0);
         QCOMPARE(proxyAuthSpy.count(), 1);
         proxyAuthSpy.clear();
@@ -7188,8 +7193,8 @@ void tst_QNetworkReply::authenticationCacheAfterCancel()
         QVERIFY(!QTestEventLoop::instance().timeout());
 
         // Work round known quirk in the old test server (danted -v < v1.1.19):
-        if (reply->networkError() != QNetworkReply::HostNotFoundError)
-            QCOMPARE(reply->networkError(), QNetworkReply::ProxyAuthenticationRequiredError);
+        if (reply->error() != QNetworkReply::HostNotFoundError)
+            QCOMPARE(reply->error(), QNetworkReply::ProxyAuthenticationRequiredError);
         QCOMPARE(authSpy.count(), 0);
         QVERIFY(proxyAuthSpy.count() > 0);
         proxyAuthSpy.clear();
@@ -7215,7 +7220,7 @@ void tst_QNetworkReply::authenticationCacheAfterCancel()
     QTestEventLoop::instance().enterLoop(10);
     QVERIFY(!QTestEventLoop::instance().timeout());
 
-    QCOMPARE(reply->networkError(), QNetworkReply::AuthenticationRequiredError);
+    QCOMPARE(reply->error(), QNetworkReply::AuthenticationRequiredError);
     QVERIFY(authSpy.count() > 0);
     authSpy.clear();
     if (proxyAuth) {
@@ -7231,7 +7236,7 @@ void tst_QNetworkReply::authenticationCacheAfterCancel()
     QTestEventLoop::instance().enterLoop(10);
     QVERIFY(!QTestEventLoop::instance().timeout());
 
-    QCOMPARE(reply->networkError(), QNetworkReply::AuthenticationRequiredError);
+    QCOMPARE(reply->error(), QNetworkReply::AuthenticationRequiredError);
     QVERIFY(authSpy.count() > 0);
     authSpy.clear();
     if (proxyAuth) {
@@ -7249,7 +7254,7 @@ void tst_QNetworkReply::authenticationCacheAfterCancel()
     QTestEventLoop::instance().enterLoop(10);
     QVERIFY(!QTestEventLoop::instance().timeout());
 
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QVERIFY(authSpy.count() > 0);
     authSpy.clear();
     if (proxyAuth) {
@@ -7264,7 +7269,7 @@ void tst_QNetworkReply::authenticationCacheAfterCancel()
     QTestEventLoop::instance().enterLoop(10);
     QVERIFY(!QTestEventLoop::instance().timeout());
 
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     //should be supplied from cache
     QCOMPARE(authSpy.count(), 0);
     authSpy.clear();
@@ -7295,7 +7300,7 @@ void tst_QNetworkReply::authenticationWithDifferentRealm()
     connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()), Qt::QueuedConnection);
     QTestEventLoop::instance().enterLoop(10);
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     helper.httpUserName = "httptest";
     helper.httpPassword = "httptest";
@@ -7305,7 +7310,7 @@ void tst_QNetworkReply::authenticationWithDifferentRealm()
     connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()), Qt::QueuedConnection);
     QTestEventLoop::instance().enterLoop(10);
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 }
 #endif // !QT_NO_NETWORKPROXY
 
@@ -7356,7 +7361,7 @@ void tst_QNetworkReply::qtbug13431replyThrottling()
     QTestEventLoop::instance().enterLoop(30);
     QVERIFY(!QTestEventLoop::instance().timeout());
     QVERIFY(helper.m_reply->isFinished());
-    QCOMPARE(helper.m_reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(helper.m_reply->error(), QNetworkReply::NoError);
 }
 
 void tst_QNetworkReply::httpWithNoCredentialUsage()
@@ -7405,7 +7410,7 @@ void tst_QNetworkReply::httpWithNoCredentialUsage()
         QCOMPARE(finishedSpy.count(), 1);
         QCOMPARE(errorSpy.count(), 1);
 
-        QCOMPARE(reply->networkError(), QNetworkReply::AuthenticationRequiredError);
+        QCOMPARE(reply->error(), QNetworkReply::AuthenticationRequiredError);
     }
 }
 
@@ -7421,7 +7426,7 @@ void tst_QNetworkReply::qtbug15311doubleContentLength()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->size(), qint64(3));
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), qint64(3));
     QCOMPARE(reply->rawHeader("Content-length"), QByteArray("3, 3"));
@@ -7440,7 +7445,7 @@ void tst_QNetworkReply::qtbug18232gzipContentLengthZero()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->size(), qint64(0));
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), qint64(0));
     QCOMPARE(reply->readAll(), QByteArray());
@@ -7461,7 +7466,7 @@ void tst_QNetworkReply::qtbug22660gzipNoContentLengthEmptyContent()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->size(), qint64(0));
     QVERIFY(!reply->header(QNetworkRequest::ContentLengthHeader).isValid());
     QCOMPARE(reply->readAll(), QByteArray());
@@ -7534,7 +7539,7 @@ void tst_QNetworkReply::qtbug27161httpHeaderMayBeDamaged(){
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->size(), qint64(3));
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), qint64(3));
     QCOMPARE(reply->rawHeader("Content-length"), QByteArray("3"));
@@ -7585,7 +7590,7 @@ void tst_QNetworkReply::qtbug28035browserDoesNotLoadQtProjectOrgCorrectly() {
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->readAll(), QByteArray("GET"));
     QCOMPARE(reply->attribute(QNetworkRequest::SourceIsFromCacheAttribute).toBool(), false);
 
@@ -7595,7 +7600,7 @@ void tst_QNetworkReply::qtbug28035browserDoesNotLoadQtProjectOrgCorrectly() {
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->readAll(), QByteArray("GET"));
     QCOMPARE(reply->attribute(QNetworkRequest::SourceIsFromCacheAttribute).toBool(), true);
 
@@ -7607,7 +7612,7 @@ void tst_QNetworkReply::qtbug28035browserDoesNotLoadQtProjectOrgCorrectly() {
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->rawHeader("Content-length"), QByteArray("4"));
     QCOMPARE(reply->readAll(), QByteArray("POST"));
     QCOMPARE(reply->attribute(QNetworkRequest::SourceIsFromCacheAttribute).toBool(), false);
@@ -7619,7 +7624,7 @@ void tst_QNetworkReply::qtbug28035browserDoesNotLoadQtProjectOrgCorrectly() {
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->readAll(), QByteArray("GET"));
     QCOMPARE(reply->attribute(QNetworkRequest::SourceIsFromCacheAttribute).toBool(), false);
 
@@ -7630,7 +7635,7 @@ void tst_QNetworkReply::qtbug28035browserDoesNotLoadQtProjectOrgCorrectly() {
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->readAll(), QByteArray("GET"));
     QCOMPARE(reply->attribute(QNetworkRequest::SourceIsFromCacheAttribute).toBool(), true);
 
@@ -7641,7 +7646,7 @@ void tst_QNetworkReply::qtbug28035browserDoesNotLoadQtProjectOrgCorrectly() {
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->attribute(QNetworkRequest::SourceIsFromCacheAttribute).toBool(), false);
 
     server.clearHeaderParserState();
@@ -7651,7 +7656,7 @@ void tst_QNetworkReply::qtbug28035browserDoesNotLoadQtProjectOrgCorrectly() {
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->readAll(), QByteArray("GET"));
     QCOMPARE(reply->attribute(QNetworkRequest::SourceIsFromCacheAttribute).toBool(), false);
 
@@ -7662,7 +7667,7 @@ void tst_QNetworkReply::qtbug28035browserDoesNotLoadQtProjectOrgCorrectly() {
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->readAll(), QByteArray("GET"));
     QCOMPARE(reply->attribute(QNetworkRequest::SourceIsFromCacheAttribute).toBool(), true);
 }
@@ -7813,7 +7818,7 @@ void tst_QNetworkReply::synchronousRequestSslFailure()
     QSignalSpy sslErrorsSpy(&manager, SIGNAL(sslErrors(QNetworkReply*,QList<QSslError>)));
     runSimpleRequest(QNetworkAccessManager::GetOperation, request, reply, 0);
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::SslHandshakeFailedError);
+    QCOMPARE(reply->error(), QNetworkReply::SslHandshakeFailedError);
     QCOMPARE(sslErrorsSpy.count(), 0);
 }
 #endif
@@ -7855,14 +7860,14 @@ void tst_QNetworkReply::httpAbort()
     HttpAbortHelper replyHolder(reply.data());
     QTestEventLoop::instance().enterLoop(10);
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QCOMPARE(reply->networkError(), QNetworkReply::OperationCanceledError);
+    QCOMPARE(reply->error(), QNetworkReply::OperationCanceledError);
     QVERIFY(reply->isFinished());
 
     // Abort immediately after the get()
     QNetworkReplyPtr reply2(manager.get(request));
     connect(reply2, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
     reply2->abort();
-    QCOMPARE(reply2->networkError(), QNetworkReply::OperationCanceledError);
+    QCOMPARE(reply2->error(), QNetworkReply::OperationCanceledError);
     QVERIFY(reply2->isFinished());
 
     // Abort after the finished()
@@ -7873,7 +7878,7 @@ void tst_QNetworkReply::httpAbort()
 
     QVERIFY(reply3->isFinished());
     reply3->abort();
-    QCOMPARE(reply3->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply3->error(), QNetworkReply::NoError);
 }
 
 void tst_QNetworkReply::dontInsertPartialContentIntoTheCache()
@@ -7920,7 +7925,7 @@ void tst_QNetworkReply::httpUserAgent()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QVERIFY(server.receivedData.contains("\r\nUser-Agent: abcDEFghi\r\n"));
 }
 
@@ -7973,7 +7978,7 @@ void tst_QNetworkReply::synchronousAuthenticationCache()
 
         QNetworkReplyPtr reply(manager.get(request));
         QVERIFY(reply->isFinished());
-        QCOMPARE(reply->networkError(), QNetworkReply::AuthenticationRequiredError);
+        QCOMPARE(reply->error(), QNetworkReply::AuthenticationRequiredError);
     }
 
     //2)  URL with credentials, we are authenticated
@@ -7984,7 +7989,7 @@ void tst_QNetworkReply::synchronousAuthenticationCache()
 
         QNetworkReplyPtr reply(manager.get(request));
         QVERIFY(reply->isFinished());
-        QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+        QCOMPARE(reply->error(), QNetworkReply::NoError);
         QCOMPARE(reply->readAll().constData(), "OK");
     }
 
@@ -7996,7 +8001,7 @@ void tst_QNetworkReply::synchronousAuthenticationCache()
 
         QNetworkReplyPtr reply(manager.get(request));
         QVERIFY(reply->isFinished());
-        QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+        QCOMPARE(reply->error(), QNetworkReply::NoError);
         QCOMPARE(reply->readAll().constData(), "OK");
     }
 }
@@ -8093,7 +8098,7 @@ void tst_QNetworkReply::ftpAuthentication()
     runSimpleRequest(QNetworkAccessManager::GetOperation, request, reply);
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(reply->networkError(), QNetworkReply::NetworkError(error));
+    QCOMPARE(reply->error(), QNetworkReply::NetworkError(error));
 }
 #endif
 
@@ -8201,7 +8206,7 @@ void tst_QNetworkReply::backgroundRequest()
         QNetworkSessionPrivate::setUsagePolicies(*session, original);
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), error);
+    QCOMPARE(reply->error(), error);
 #endif
 }
 #endif
@@ -8282,7 +8287,7 @@ void tst_QNetworkReply::backgroundRequestInterruption()
         QNetworkSessionPrivate::setUsagePolicies(*session, original);
 
     QVERIFY(reply->isFinished());
-    QCOMPARE(reply->networkError(), error);
+    QCOMPARE(reply->error(), error);
 #endif
 }
 #endif
@@ -8433,7 +8438,7 @@ void tst_QNetworkReply::putWithRateLimiting()
     rateLimitedUploadDevice.open(QIODevice::ReadOnly);
 
     RUN_REQUEST(runCustomRequest(request, reply,QByteArray("POST"), &rateLimitedUploadDevice));
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
 
     QByteArray uploadedData = reply->readAll();
@@ -8481,7 +8486,7 @@ void tst_QNetworkReply::ioHttpSingleRedirect()
 
     // Reply url is set to the redirect url
     QCOMPARE(reply->url(), redirectUrl);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QVERIFY(validateRedirectedResponseHeaders(reply));
 }
 
@@ -8518,7 +8523,7 @@ void tst_QNetworkReply::ioHttpChangeMaxRedirects()
 
     QCOMPARE(redSpy.count(), request.maximumRedirectsAllowed());
     QCOMPARE(spy.count(), 1);
-    QCOMPARE(reply->networkError(), QNetworkReply::TooManyRedirectsError);
+    QCOMPARE(reply->error(), QNetworkReply::TooManyRedirectsError);
 
     // Increase max redirects to allow successful completion
     request.setMaximumRedirectsAllowed(3);
@@ -8530,7 +8535,7 @@ void tst_QNetworkReply::ioHttpChangeMaxRedirects()
 
     QCOMPARE(redSpy2.count(), 2);
     QCOMPARE(reply2->url(), server3Url);
-    QCOMPARE(reply2->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply2->error(), QNetworkReply::NoError);
     QVERIFY(validateRedirectedResponseHeaders(reply2));
 }
 
@@ -8588,7 +8593,7 @@ void tst_QNetworkReply::ioHttpRedirectErrors()
     watchDog.start(5000);
 
     QCOMPARE(eventLoop.exec(), int(Failure));
-    QCOMPARE(reply->networkError(), error);
+    QCOMPARE(reply->error(), error);
 }
 
 struct SameOriginRedirector : MiniHttpServer
@@ -8746,7 +8751,7 @@ void tst_QNetworkReply::ioHttpRedirectPolicyErrors()
 
     QCOMPARE(waitForFinish(reply), int(Failure));
     QCOMPARE(spy.count(), 1);
-    QCOMPARE(reply->networkError(), expectedError);
+    QCOMPARE(reply->error(), expectedError);
 }
 
 void tst_QNetworkReply::ioHttpUserVerifiedRedirect_data()
@@ -8889,7 +8894,7 @@ void tst_QNetworkReply::ioHttpRedirectFromLocalToRemote()
     QCOMPARE(waitForFinish(reply), int(Success));
 
     QCOMPARE(reply->url(), targetUrl);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), reference.size());
     QCOMPARE(reply->readAll(), reference.readAll());
 }
@@ -9008,7 +9013,7 @@ void tst_QNetworkReply::ioHttpRedirectMultipartPost()
     multiPart->deleteLater();
 
     QCOMPARE(reply->url(), url);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
 
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200); // 200 OK
 
@@ -9397,7 +9402,7 @@ void tst_QNetworkReply::getWithTimeout()
     QCOMPARE(waitForFinish(reply), int(Success));
 
     QCOMPARE(spy.count(), 0);
-    QVERIFY(reply->networkError() == QNetworkReply::NoError);
+    QVERIFY(reply->error() == QNetworkReply::NoError);
 
     request.setTransferTimeout(1000);
     server.stopTransfer = true;
@@ -9408,7 +9413,7 @@ void tst_QNetworkReply::getWithTimeout()
     QCOMPARE(waitForFinish(reply2), int(Failure));
 
     QCOMPARE(spy2.count(), 1);
-    QVERIFY(reply2->networkError() == QNetworkReply::OperationCanceledError);
+    QVERIFY(reply2->error() == QNetworkReply::OperationCanceledError);
 
     request.setTransferTimeout(0);
     manager.setTransferTimeout(1000);
@@ -9419,7 +9424,7 @@ void tst_QNetworkReply::getWithTimeout()
     QCOMPARE(waitForFinish(reply3), int(Failure));
 
     QCOMPARE(spy3.count(), 1);
-    QVERIFY(reply3->networkError() == QNetworkReply::OperationCanceledError);
+    QVERIFY(reply3->error() == QNetworkReply::OperationCanceledError);
 
     manager.setTransferTimeout(0);
 }
@@ -9437,7 +9442,7 @@ void tst_QNetworkReply::postWithTimeout()
     QCOMPARE(waitForFinish(reply), int(Success));
 
     QCOMPARE(spy.count(), 0);
-    QVERIFY(reply->networkError() == QNetworkReply::NoError);
+    QVERIFY(reply->error() == QNetworkReply::NoError);
 
     request.setTransferTimeout(1000);
     server.stopTransfer = true;
@@ -9448,7 +9453,7 @@ void tst_QNetworkReply::postWithTimeout()
     QCOMPARE(waitForFinish(reply2), int(Failure));
 
     QCOMPARE(spy2.count(), 1);
-    QVERIFY(reply2->networkError() == QNetworkReply::OperationCanceledError);
+    QVERIFY(reply2->error() == QNetworkReply::OperationCanceledError);
 
     request.setTransferTimeout(0);
     manager.setTransferTimeout(1000);
@@ -9459,7 +9464,7 @@ void tst_QNetworkReply::postWithTimeout()
     QCOMPARE(waitForFinish(reply3), int(Failure));
 
     QCOMPARE(spy3.count(), 1);
-    QVERIFY(reply3->networkError() == QNetworkReply::OperationCanceledError);
+    QVERIFY(reply3->error() == QNetworkReply::OperationCanceledError);
 
     manager.setTransferTimeout(0);
 }
diff --git a/tests/auto/network/socket/qhttpsocketengine/tst_qhttpsocketengine.cpp b/tests/auto/network/socket/qhttpsocketengine/tst_qhttpsocketengine.cpp
index 1931df3d07..2d0d9f5ffc 100644
--- a/tests/auto/network/socket/qhttpsocketengine/tst_qhttpsocketengine.cpp
+++ b/tests/auto/network/socket/qhttpsocketengine/tst_qhttpsocketengine.cpp
@@ -270,12 +270,12 @@ void tst_QHttpSocketEngine::errorTest()
     socket.setProxy(QNetworkProxy(QNetworkProxy::HttpProxy, hostname, port, username, username));
     socket.connectToHost("0.1.2.3", 12345);
 
-    connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)),
+    connect(&socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)),
             &QTestEventLoop::instance(), SLOT(exitLoop()));
     QTestEventLoop::instance().enterLoop(30);
     QVERIFY(!QTestEventLoop::instance().timeout());
 
-    QCOMPARE(int(socket.socketError()), expectedError);
+    QCOMPARE(int(socket.error()), expectedError);
 }
 
 //---------------------------------------------------------------------------
diff --git a/tests/auto/network/socket/qsocks5socketengine/tst_qsocks5socketengine.cpp b/tests/auto/network/socket/qsocks5socketengine/tst_qsocks5socketengine.cpp
index da9cdee691..85eec6e783 100644
--- a/tests/auto/network/socket/qsocks5socketengine/tst_qsocks5socketengine.cpp
+++ b/tests/auto/network/socket/qsocks5socketengine/tst_qsocks5socketengine.cpp
@@ -283,12 +283,12 @@ void tst_QSocks5SocketEngine::errorTest()
     socket.setProxy(QNetworkProxy(QNetworkProxy::Socks5Proxy, hostname, port, username, username));
     socket.connectToHost("0.1.2.3", 12345);
 
-    connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)),
+    connect(&socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)),
             &QTestEventLoop::instance(), SLOT(exitLoop()));
     QTestEventLoop::instance().enterLoop(10);
     QVERIFY(!QTestEventLoop::instance().timeout());
 
-    QCOMPARE(int(socket.socketError()), expectedError);
+    QCOMPARE(int(socket.error()), expectedError);
 }
 
 //---------------------------------------------------------------------------
@@ -753,7 +753,7 @@ void tst_QSocks5SocketEngine::downloadBigFile()
                     QTestEventLoop::instance().exitLoop();
             });
 
-    connect(&socket, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::error),
+    connect(&socket, &QAbstractSocket::errorOccurred,
             [&socket, &stopWatch] (QAbstractSocket::SocketError errorCode)
             {
                 qWarning().noquote().nospace() << QTest::currentTestFunction()
@@ -1006,12 +1006,12 @@ void tst_QSocks5SocketEngine::incomplete()
 
     connect(&socket, SIGNAL(connected()),
             &QTestEventLoop::instance(), SLOT(exitLoop()));
-    connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)),
+    connect(&socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)),
             &QTestEventLoop::instance(), SLOT(exitLoop()));
     QTestEventLoop::instance().enterLoop(70);
     QVERIFY(!QTestEventLoop::instance().timeout());
 
-    QCOMPARE(socket.socketError(), QAbstractSocket::ProxyConnectionClosedError);
+    QCOMPARE(socket.error(), QAbstractSocket::ProxyConnectionClosedError);
 }
 
 //----------------------------------------------------------------------------------
diff --git a/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp b/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp
index 099aa5fb51..6dd390ccbd 100644
--- a/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp
+++ b/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp
@@ -493,7 +493,7 @@ void tst_QTcpSocket::constructing()
     QCOMPARE(socket->peerAddress(), QHostAddress());
     QCOMPARE(socket->readChannelCount(), 0);
     QCOMPARE(socket->writeChannelCount(), 0);
-    QCOMPARE(socket->socketError(), QTcpSocket::UnknownSocketError);
+    QCOMPARE(socket->error(), QTcpSocket::UnknownSocketError);
     QCOMPARE(socket->errorString(), QString("Unknown error"));
 
     // Check the state of the socket layer?
@@ -603,7 +603,7 @@ void tst_QTcpSocket::bind()
             }
 
             bool bindSuccess = socket->bind(addr, port);
-            if (!bindSuccess && randomPort && socket->socketError() == QTcpSocket::AddressInUseError) {
+            if (!bindSuccess && randomPort && socket->error() == QTcpSocket::AddressInUseError) {
                 // we may have been unlucky and hit an already open port, so try another
                 --attemptsLeft;
                 continue;
@@ -730,7 +730,7 @@ void tst_QTcpSocket::setInvalidSocketDescriptor()
     QVERIFY(!socket->setSocketDescriptor(-5, QTcpSocket::UnconnectedState));
     QCOMPARE(socket->socketDescriptor(), (qintptr)-1);
 
-    QCOMPARE(socket->socketError(), QTcpSocket::UnsupportedSocketOperationError);
+    QCOMPARE(socket->error(), QTcpSocket::UnsupportedSocketOperationError);
 
     delete socket;
 }
@@ -893,7 +893,7 @@ void tst_QTcpSocket::hostNotFound()
                          "when we expect 404", Continue);
     }
 #endif
-    QCOMPARE(int(socket->socketError()), int(QTcpSocket::HostNotFoundError));
+    QCOMPARE(int(socket->error()), int(QTcpSocket::HostNotFoundError));
 
     delete socket;
 }
@@ -919,7 +919,7 @@ void tst_QTcpSocket::timeoutConnect()
     QVERIFY(timer.elapsed() < 150);
     QVERIFY(!socket->waitForConnected(1000)); //200ms is too short when using SOCKS proxy authentication
     QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
-    QCOMPARE(int(socket->socketError()), int(QTcpSocket::SocketTimeoutError));
+    QCOMPARE(int(socket->error()), int(QTcpSocket::SocketTimeoutError));
     QCOMPARE(socket->readChannelCount(), 0);
     QCOMPARE(socket->writeChannelCount(), 0);
 
@@ -1238,7 +1238,7 @@ void tst_QTcpSocket::openCloseOpenClose()
         QCOMPARE(socket->localAddress(), QHostAddress());
         QCOMPARE((int) socket->peerPort(), 0);
         QCOMPARE(socket->peerAddress(), QHostAddress());
-        QCOMPARE(socket->socketError(), QTcpSocket::UnknownSocketError);
+        QCOMPARE(socket->error(), QTcpSocket::UnknownSocketError);
         QCOMPARE(socket->errorString(), QString("Unknown error"));
 
         QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
@@ -1392,7 +1392,7 @@ protected:
         while (!quit) {
             if (socket->waitForDisconnected(500))
                 break;
-            if (socket->socketError() != QAbstractSocket::SocketTimeoutError)
+            if (socket->error() != QAbstractSocket::SocketTimeoutError)
                 return;
         }
 
@@ -1628,8 +1628,8 @@ void tst_QTcpSocket::readLine()
 
     QVERIFY(!socket->waitForReadyRead(100));
     QCOMPARE(socket->readLine(buffer, sizeof(buffer)), qint64(0));
-    QVERIFY(socket->socketError() == QAbstractSocket::SocketTimeoutError
-            || socket->socketError() == QAbstractSocket::RemoteHostClosedError);
+    QVERIFY(socket->error() == QAbstractSocket::SocketTimeoutError
+            || socket->error() == QAbstractSocket::RemoteHostClosedError);
     QCOMPARE(socket->bytesAvailable(), qint64(0));
 
     socket->close();
@@ -1778,11 +1778,11 @@ void tst_QTcpSocket::dontCloseOnTimeout()
     QTcpSocket *socket = newSocket();
     socket->connectToHost(serverAddress, server.serverPort());
     QVERIFY(!socket->waitForReadyRead(100));
-    QCOMPARE(socket->socketError(), QTcpSocket::SocketTimeoutError);
+    QCOMPARE(socket->error(), QTcpSocket::SocketTimeoutError);
     QVERIFY(socket->isOpen());
 
     QVERIFY(!socket->waitForDisconnected(100));
-    QCOMPARE(socket->socketError(), QTcpSocket::SocketTimeoutError);
+    QCOMPARE(socket->error(), QTcpSocket::SocketTimeoutError);
     QVERIFY(socket->isOpen());
 
     delete socket;
@@ -2019,14 +2019,14 @@ void tst_QTcpSocket::remoteCloseError()
     QCOMPARE(clientSocket->bytesAvailable(), qint64(5));
 
     qRegisterMetaType<QAbstractSocket::SocketError>("QAbstractSocket::SocketError");
-    QSignalSpy errorSpy(clientSocket, SIGNAL(error(QAbstractSocket::SocketError)));
+    QSignalSpy errorSpy(clientSocket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)));
     QSignalSpy disconnectedSpy(clientSocket, SIGNAL(disconnected()));
 
     clientSocket->write("World");
     serverSocket->disconnectFromHost();
 
     tmpSocket = clientSocket;
-    connect(clientSocket, SIGNAL(error(QAbstractSocket::SocketError)),
+    connect(clientSocket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)),
             this, SLOT(remoteCloseErrorSlot()));
 
     enterLoop(30);
@@ -2034,7 +2034,7 @@ void tst_QTcpSocket::remoteCloseError()
 
     QCOMPARE(disconnectedSpy.count(), 1);
     QCOMPARE(errorSpy.count(), 1);
-    QCOMPARE(clientSocket->socketError(), QAbstractSocket::RemoteHostClosedError);
+    QCOMPARE(clientSocket->error(), QAbstractSocket::RemoteHostClosedError);
 
     delete serverSocket;
 
@@ -2079,7 +2079,7 @@ void tst_QTcpSocket::nestedEventLoopInErrorSlot()
 {
     QTcpSocket *socket = newSocket();
     QPointer<QTcpSocket> p(socket);
-    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(enterLoopSlot()));
+    connect(socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), this, SLOT(enterLoopSlot()));
 
     socket->connectToHost("hostnotfoundhostnotfound.qt-project.org", 9999);
     enterLoop(30);
@@ -2109,7 +2109,7 @@ void tst_QTcpSocket::connectToHostError()
     QFETCH(int, port);
     QFETCH(QAbstractSocket::SocketError, expectedError);
 
-    connect(socket, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::error),[&](QAbstractSocket::SocketError socketError){
+    connect(socket, &QAbstractSocket::errorOccurred, [&](QAbstractSocket::SocketError socketError){
         error = socketError;
     });
     socket->connectToHost(host, port); // no service running here, one suspects
@@ -2326,7 +2326,7 @@ void tst_QTcpSocket::abortiveClose()
 
     qRegisterMetaType<QAbstractSocket::SocketError>("QAbstractSocket::SocketError");
     QSignalSpy readyReadSpy(clientSocket, SIGNAL(readyRead()));
-    QSignalSpy errorSpy(clientSocket, SIGNAL(error(QAbstractSocket::SocketError)));
+    QSignalSpy errorSpy(clientSocket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)));
 
     connect(clientSocket, SIGNAL(disconnected()), this, SLOT(exitLoopSlot()));
     QTimer::singleShot(0, this, SLOT(abortiveClose_abortSlot()));
@@ -2402,7 +2402,7 @@ void tst_QTcpSocket::zeroAndMinusOneReturns()
 
     socket->write("GET / HTTP/1.0\r\n\r\n");
     QVERIFY(socket->waitForDisconnected(15000));
-    QCOMPARE(socket->socketError(), QAbstractSocket::RemoteHostClosedError);
+    QCOMPARE(socket->error(), QAbstractSocket::RemoteHostClosedError);
 
     QCOMPARE(socket->write("BLUBBER"), qint64(-1));
     QVERIFY(socket->getChar(c));
@@ -2439,19 +2439,19 @@ void tst_QTcpSocket::connectionRefused()
 
     QTcpSocket *socket = newSocket();
     QSignalSpy stateSpy(socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)));
-    QSignalSpy errorSpy(socket, SIGNAL(error(QAbstractSocket::SocketError)));
-    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)),
+    QSignalSpy errorSpy(socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)));
+    connect(socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)),
             &QTestEventLoop::instance(), SLOT(exitLoop()));
 
     socket->connectToHost(QtNetworkSettings::httpServerName(), 144);
 
     enterLoop(10);
-    disconnect(socket, SIGNAL(error(QAbstractSocket::SocketError)),
+    disconnect(socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)),
                &QTestEventLoop::instance(), SLOT(exitLoop()));
     QVERIFY2(!timeout(), "Network timeout");
 
     QCOMPARE(socket->state(), QAbstractSocket::UnconnectedState);
-    QCOMPARE(socket->socketError(), QAbstractSocket::ConnectionRefusedError);
+    QCOMPARE(socket->error(), QAbstractSocket::ConnectionRefusedError);
 
     QCOMPARE(stateSpy.count(), 3);
     QCOMPARE(qvariant_cast<QAbstractSocket::SocketState>(stateSpy.at(0).at(0)), QAbstractSocket::HostLookupState);
@@ -2574,7 +2574,7 @@ void tst_QTcpSocket::connectToMultiIP()
     socket->connectToHost("multi.dev.qt-project.org", 81);
     QVERIFY(!socket->waitForConnected(2000));
     QVERIFY(stopWatch.elapsed() < 2000);
-    QCOMPARE(socket->socketError(), QAbstractSocket::SocketTimeoutError);
+    QCOMPARE(socket->error(), QAbstractSocket::SocketTimeoutError);
 
     delete socket;
 #endif
@@ -2760,7 +2760,7 @@ void tst_QTcpSocket::taskQtBug5799ConnectionErrorWaitForConnected()
     socket.waitForConnected(10000);
     QVERIFY2(timer.elapsed() < 9900, "Connection to closed port timed out instead of refusing, something is wrong");
     QVERIFY2(socket.state() == QAbstractSocket::UnconnectedState, "Socket connected unexpectedly!");
-    QVERIFY2(socket.socketError() == QAbstractSocket::ConnectionRefusedError,
+    QVERIFY2(socket.error() == QAbstractSocket::ConnectionRefusedError,
              QString("Could not reach server: %1").arg(socket.errorString()).toLocal8Bit());
 }
 
@@ -2773,13 +2773,13 @@ void tst_QTcpSocket::taskQtBug5799ConnectionErrorEventLoop()
     // check that we get a proper error connecting to port 12346
     // This testcase uses an event loop
     QTcpSocket socket;
-    connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), &QTestEventLoop::instance(), SLOT(exitLoop()));
+    connect(&socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), &QTestEventLoop::instance(), SLOT(exitLoop()));
     socket.connectToHost(QtNetworkSettings::httpServerName(), 12346);
 
     QTestEventLoop::instance().enterLoop(10);
     QVERIFY2(!QTestEventLoop::instance().timeout(), "Connection to closed port timed out instead of refusing, something is wrong");
     QVERIFY2(socket.state() == QAbstractSocket::UnconnectedState, "Socket connected unexpectedly!");
-    QVERIFY2(socket.socketError() == QAbstractSocket::ConnectionRefusedError,
+    QVERIFY2(socket.error() == QAbstractSocket::ConnectionRefusedError,
              QString("Could not reach server: %1").arg(socket.errorString()).toLocal8Bit());
 }
 
@@ -2789,12 +2789,12 @@ void tst_QTcpSocket::taskQtBug7054TimeoutErrorResetting()
 
     socket->connectToHost(QtNetworkSettings::httpServerName(), 443);
     QVERIFY(socket->waitForConnected(5*1000));
-    QCOMPARE(socket->socketError(), QAbstractSocket::UnknownSocketError);
+    QCOMPARE(socket->error(), QAbstractSocket::UnknownSocketError);
 
     // We connected to the HTTPS port. Wait two seconds to receive data. We will receive
     // nothing because we would need to start the SSL handshake
     QVERIFY(!socket->waitForReadyRead(2*1000));
-    QCOMPARE(socket->socketError(), QAbstractSocket::SocketTimeoutError);
+    QCOMPARE(socket->error(), QAbstractSocket::SocketTimeoutError);
 
     // Now write some crap to make the server disconnect us. 4 lines are enough.
     socket->write("a\r\nb\r\nc\r\nd\r\n");
@@ -2804,7 +2804,7 @@ void tst_QTcpSocket::taskQtBug7054TimeoutErrorResetting()
     // should get a better error since the server disconnected us
     QVERIFY(!socket->waitForReadyRead(2*1000));
     // It must NOT be the SocketTimeoutError that had been set before
-    QCOMPARE(socket->socketError(), QAbstractSocket::RemoteHostClosedError);
+    QCOMPARE(socket->error(), QAbstractSocket::RemoteHostClosedError);
 }
 
 #ifndef QT_NO_NETWORKPROXY
@@ -2862,7 +2862,7 @@ void tst_QTcpSocket::invalidProxy()
 
     // note: the following test is not a hard failure.
     // Sometimes, error codes change for the better
-    QTEST(int(socket->socketError()), "expectedError");
+    QTEST(int(socket->error()), "expectedError");
 
     delete socket;
 }
@@ -2982,7 +2982,7 @@ void tst_QTcpSocket::proxyFactory()
 
     // note: the following test is not a hard failure.
     // Sometimes, error codes change for the better
-    QTEST(int(socket->socketError()), "expectedError");
+    QTEST(int(socket->error()), "expectedError");
 
     delete socket;
 }
@@ -3209,7 +3209,7 @@ void tst_QTcpSocket::readNotificationsAfterBind()
     QAbstractSocket socket(QAbstractSocket::TcpSocket, nullptr);
     QVERIFY2(socket.bind(), "Bind error!");
 
-    connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), &QTestEventLoop::instance(), SLOT(exitLoop()));
+    connect(&socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), &QTestEventLoop::instance(), SLOT(exitLoop()));
     QSignalSpy spyReadyRead(&socket, SIGNAL(readyRead()));
     socket.connectToHost(QtNetworkSettings::serverName(), 12346);
 
diff --git a/tests/auto/network/socket/qudpsocket/tst_qudpsocket.cpp b/tests/auto/network/socket/qudpsocket/tst_qudpsocket.cpp
index 88898cd8a8..cc41260d59 100644
--- a/tests/auto/network/socket/qudpsocket/tst_qudpsocket.cpp
+++ b/tests/auto/network/socket/qudpsocket/tst_qudpsocket.cpp
@@ -337,7 +337,7 @@ void tst_QUdpSocket::constructing()
     QCOMPARE(socket.canReadLine(), false);
     QCOMPARE(socket.readLine(), QByteArray());
     QCOMPARE(socket.socketDescriptor(), (qintptr)-1);
-    QCOMPARE(socket.socketError(), QUdpSocket::UnknownSocketError);
+    QCOMPARE(socket.error(), QUdpSocket::UnknownSocketError);
     QCOMPARE(socket.errorString(), QString("Unknown error"));
 
     // Check the state of the socket api
@@ -575,7 +575,7 @@ void tst_QUdpSocket::ipv6Loop()
     int paulPort;
 
     if (!peter.bind(QHostAddress(QHostAddress::LocalHostIPv6), 0)) {
-        QCOMPARE(peter.socketError(), QUdpSocket::UnsupportedSocketOperationError);
+        QCOMPARE(peter.error(), QUdpSocket::UnsupportedSocketOperationError);
         return;
     }
 
@@ -883,7 +883,7 @@ void tst_QUdpSocket::writeDatagram()
     qRegisterMetaType<QAbstractSocket::SocketError>("QAbstractSocket::SocketError");
 
     for(int i=0;;i++) {
-        QSignalSpy errorspy(&client, SIGNAL(error(QAbstractSocket::SocketError)));
+        QSignalSpy errorspy(&client, SIGNAL(errorOccurred(QAbstractSocket::SocketError)));
         QSignalSpy bytesspy(&client, SIGNAL(bytesWritten(qint64)));
 
         qint64 written = client.writeDatagram(QByteArray(i * 1024, 'w'), serverAddress,
@@ -897,7 +897,7 @@ void tst_QUdpSocket::writeDatagram()
             QCOMPARE(errorspy.count(), 1);
             QCOMPARE(*static_cast<const int *>(errorspy.at(0).at(0).constData()),
                     int(QUdpSocket::DatagramTooLargeError));
-            QCOMPARE(client.socketError(), QUdpSocket::DatagramTooLargeError);
+            QCOMPARE(client.error(), QUdpSocket::DatagramTooLargeError);
             break;
         }
         QCOMPARE(bytesspy.count(), 1);
@@ -1044,7 +1044,7 @@ void tst_QUdpSocket::writeToNonExistingPeer()
 
     QUdpSocket sConnected;
     QSignalSpy sConnectedReadyReadSpy(&sConnected, SIGNAL(readyRead()));
-    QSignalSpy sConnectedErrorSpy(&sConnected, SIGNAL(error(QAbstractSocket::SocketError)));
+    QSignalSpy sConnectedErrorSpy(&sConnected, SIGNAL(errorOccurred(QAbstractSocket::SocketError)));
     sConnected.connectToHost(peerAddress, peerPort, QIODevice::ReadWrite);
     QVERIFY(sConnected.waitForConnected(10000));
 
@@ -1054,14 +1054,14 @@ void tst_QUdpSocket::writeToNonExistingPeer()
     // the second one should fail!
     QTest::qSleep(1000);                   // do not process events
     QCOMPARE(sConnected.write("", 1), qint64(-1));
-    QCOMPARE(int(sConnected.socketError()), int(QUdpSocket::ConnectionRefusedError));
+    QCOMPARE(int(sConnected.error()), int(QUdpSocket::ConnectionRefusedError));
 
     // the third one will succeed...
     QCOMPARE(sConnected.write("", 1), qint64(1));
     QTestEventLoop::instance().enterLoop(1);
     QCOMPARE(sConnectedReadyReadSpy.count(), 0);
     QCOMPARE(sConnectedErrorSpy.count(), 1);
-    QCOMPARE(int(sConnected.socketError()), int(QUdpSocket::ConnectionRefusedError));
+    QCOMPARE(int(sConnected.error()), int(QUdpSocket::ConnectionRefusedError));
 
     // we should now get a read error
     QCOMPARE(sConnected.write("", 1), qint64(1));
@@ -1071,12 +1071,12 @@ void tst_QUdpSocket::writeToNonExistingPeer()
     QCOMPARE(sConnected.bytesAvailable(), Q_INT64_C(0));
     QCOMPARE(sConnected.pendingDatagramSize(), Q_INT64_C(-1));
     QCOMPARE(sConnected.readDatagram(buf, 2), Q_INT64_C(-1));
-    QCOMPARE(int(sConnected.socketError()), int(QUdpSocket::ConnectionRefusedError));
+    QCOMPARE(int(sConnected.error()), int(QUdpSocket::ConnectionRefusedError));
 
     QCOMPARE(sConnected.write("", 1), qint64(1));
     QTest::qSleep(1000);                   // do not process events
     QCOMPARE(sConnected.read(buf, 2), Q_INT64_C(0));
-    QCOMPARE(int(sConnected.socketError()), int(QUdpSocket::ConnectionRefusedError));
+    QCOMPARE(int(sConnected.error()), int(QUdpSocket::ConnectionRefusedError));
 
     // we should still be connected
     QCOMPARE(int(sConnected.state()), int(QUdpSocket::ConnectedState));
diff --git a/tests/auto/network/ssl/qocsp/tst_qocsp.cpp b/tests/auto/network/ssl/qocsp/tst_qocsp.cpp
index 8e579f7b5e..27476f451e 100644
--- a/tests/auto/network/ssl/qocsp/tst_qocsp.cpp
+++ b/tests/auto/network/ssl/qocsp/tst_qocsp.cpp
@@ -409,7 +409,7 @@ private:
 
     static QString certDirPath;
 
-    void (QSslSocket::*socketErrorSignal)(QAbstractSocket::SocketError) = &QAbstractSocket::error;
+    void (QSslSocket::*socketErrorSignal)(QAbstractSocket::SocketError) = &QAbstractSocket::errorOccurred;
     void (QSslSocket::*tlsErrorsSignal)(const QList<QSslError> &) = &QSslSocket::sslErrors;
     void (QTestEventLoop::*exitLoopSlot)() = &QTestEventLoop::exitLoop;
 
@@ -605,7 +605,7 @@ void tst_QOcsp::malformedResponse()
     loop.enterLoopMSecs(handshakeTimeoutMS);
 
     QVERIFY(!clientSocket.isEncrypted());
-    QCOMPARE(clientSocket.socketError(), QAbstractSocket::SslHandshakeFailedError);
+    QCOMPARE(clientSocket.error(), QAbstractSocket::SslHandshakeFailedError);
 }
 
 void tst_QOcsp::expiredResponse_data()
diff --git a/tests/auto/network/ssl/qsslsocket/tst_qsslsocket.cpp b/tests/auto/network/ssl/qsslsocket/tst_qsslsocket.cpp
index 18b449a953..c793a6a98b 100644
--- a/tests/auto/network/ssl/qsslsocket/tst_qsslsocket.cpp
+++ b/tests/auto/network/ssl/qsslsocket/tst_qsslsocket.cpp
@@ -533,7 +533,7 @@ void tst_QSslSocket::constructing()
     QCOMPARE(socket.write(0, 0), qint64(-1));
     QTest::ignoreMessage(QtWarningMsg, writeNotOpenMessage);
     QCOMPARE(socket.write(QByteArray()), qint64(-1));
-    QCOMPARE(socket.socketError(), QAbstractSocket::UnknownSocketError);
+    QCOMPARE(socket.error(), QAbstractSocket::UnknownSocketError);
     QVERIFY(!socket.flush());
     QVERIFY(!socket.isValid());
     QCOMPARE(socket.localAddress(), QHostAddress());
@@ -1229,7 +1229,7 @@ protected:
         configuration.setProtocol(protocol);
         if (ignoreSslErrors)
             connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
-        connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SIGNAL(socketError(QAbstractSocket::SocketError)));
+        connect(socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), this, SIGNAL(socketError(QAbstractSocket::SocketError)));
         connect(socket, &QSslSocket::alertReceived, this, &SslServer::gotAlert);
         connect(socket, &QSslSocket::alertSent, this, &SslServer::alertSent);
 
@@ -1360,8 +1360,8 @@ void tst_QSslSocket::protocolServerSide()
     socket = &client;
     QFETCH(QSsl::SslProtocol, clientProtocol);
     socket->setProtocol(clientProtocol);
-    // upon SSL wrong version error, error will be triggered, not sslErrors
-    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
+    // upon SSL wrong version error, errorOccurred will be triggered, not sslErrors
+    connect(socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
@@ -1373,16 +1373,16 @@ void tst_QSslSocket::protocolServerSide()
     QAbstractSocket::SocketState expectedState = (works) ? QAbstractSocket::ConnectedState : QAbstractSocket::UnconnectedState;
     // Determine whether the client or the server caused the event loop
     // to quit due to a socket error, and investigate the culprit.
-    if (client.socketError() != QAbstractSocket::UnknownSocketError) {
+    if (client.error() != QAbstractSocket::UnknownSocketError) {
         // It can happen that the client, after TCP connection established, before
         // incomingConnection() slot fired, hits TLS initialization error and stops
         // the loop, so the server socket is not created yet.
         if (server.socket)
-            QVERIFY(server.socket->socketError() == QAbstractSocket::UnknownSocketError);
+            QVERIFY(server.socket->error() == QAbstractSocket::UnknownSocketError);
 
         QCOMPARE(client.state(), expectedState);
-    } else if (server.socket->socketError() != QAbstractSocket::UnknownSocketError) {
-        QVERIFY(client.socketError() == QAbstractSocket::UnknownSocketError);
+    } else if (server.socket->error() != QAbstractSocket::UnknownSocketError) {
+        QVERIFY(client.error() == QAbstractSocket::UnknownSocketError);
         QCOMPARE(server.socket->state(), expectedState);
     }
 
@@ -1421,8 +1421,8 @@ void tst_QSslSocket::serverCipherPreferences()
         sslConfig.setCiphers({QSslCipher("AES256-SHA"), QSslCipher("AES128-SHA")});
         socket->setSslConfiguration(sslConfig);
 
-        // upon SSL wrong version error, error will be triggered, not sslErrors
-        connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
+        // upon SSL wrong version error, errorOccurred will be triggered, not sslErrors
+        connect(socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
         connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
         connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
@@ -1453,8 +1453,8 @@ void tst_QSslSocket::serverCipherPreferences()
         sslConfig.setCiphers({QSslCipher("AES256-SHA"), QSslCipher("AES128-SHA")});
         socket->setSslConfiguration(sslConfig);
 
-        // upon SSL wrong version error, error will be triggered, not sslErrors
-        connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
+        // upon SSL wrong version error, errorOccurred will be triggered, not sslErrors
+        connect(socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
         connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
         connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
@@ -1544,7 +1544,7 @@ void tst_QSslSocket::setLocalCertificateChain()
     const QScopedPointer<QSslSocket, QScopedPointerDeleteLater> client(new QSslSocket);
     socket = client.data();
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
-    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
+    connect(socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
 
     socket->connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
@@ -1994,7 +1994,7 @@ void tst_QSslSocket::setEmptyKey()
     QTestEventLoop::instance().enterLoop(2);
 
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
-    QCOMPARE(socket.socketError(), QAbstractSocket::UnknownSocketError);
+    QCOMPARE(socket.error(), QAbstractSocket::UnknownSocketError);
 }
 
 void tst_QSslSocket::spontaneousWrite()
@@ -2534,8 +2534,8 @@ void tst_QSslSocket::closeWhileEmittingSocketError()
     clientConfig.setPeerVerifyMode(QSslSocket::VerifyNone);
     clientSocket.setSslConfiguration(clientConfig);
 
-    QSignalSpy socketErrorSpy(&clientSocket, SIGNAL(error(QAbstractSocket::SocketError)));
-    void (QSslSocket::*errorSignal)(QAbstractSocket::SocketError) = &QSslSocket::error;
+    QSignalSpy socketErrorSpy(&clientSocket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)));
+    void (QSslSocket::*errorSignal)(QAbstractSocket::SocketError) = &QSslSocket::errorOccurred;
     connect(&clientSocket, errorSignal, &handshake, &BrokenPskHandshake::socketError);
 
     clientSocket.connectToHostEncrypted(QStringLiteral("127.0.0.1"), handshake.serverPort());
@@ -2635,7 +2635,7 @@ void tst_QSslSocket::ignoreSslErrorsList()
     socket.ignoreSslErrors(expectedSslErrors);
 
     QFETCH(int, expectedSslErrorSignalCount);
-    QSignalSpy sslErrorsSpy(&socket, SIGNAL(error(QAbstractSocket::SocketError)));
+    QSignalSpy sslErrorsSpy(&socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)));
 
     socket.connectToHostEncrypted(QtNetworkSettings::httpServerName(), 443);
 
@@ -2766,11 +2766,11 @@ void tst_QSslSocket::writeBigChunk()
     // no better way to do this right now since the error is the same as the default error.
     if (socket->errorString().startsWith(QLatin1String("Unable to write data")))
     {
-        qWarning() << socket->socketError() << socket->errorString();
+        qWarning() << socket->error() << socket->errorString();
         QFAIL("Error while writing! Check if the OpenSSL BIO size is limited?!");
     }
     // also check the error string. If another error (than UnknownError) occurred, it should be different than before
-    QVERIFY2(errorBefore == errorAfter || socket->socketError() == QAbstractSocket::RemoteHostClosedError,
+    QVERIFY2(errorBefore == errorAfter || socket->error() == QAbstractSocket::RemoteHostClosedError,
              QByteArray("unexpected error: ").append(qPrintable(errorAfter)));
 
     // check that everything has been written to OpenSSL
@@ -2929,13 +2929,13 @@ void tst_QSslSocket::resume()
 
     QSignalSpy sslErrorSpy(&socket, SIGNAL(sslErrors(QList<QSslError>)));
     QSignalSpy encryptedSpy(&socket, SIGNAL(encrypted()));
-    QSignalSpy errorSpy(&socket, SIGNAL(error(QAbstractSocket::SocketError)));
+    QSignalSpy errorSpy(&socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)));
 
     connect(&socket, SIGNAL(sslErrors(QList<QSslError>)), &QTestEventLoop::instance(), SLOT(exitLoop()));
     connect(&socket, SIGNAL(encrypted()), &QTestEventLoop::instance(), SLOT(exitLoop()));
     connect(&socket, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
             this, SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));
-    connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), &QTestEventLoop::instance(), SLOT(exitLoop()));
+    connect(&socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), &QTestEventLoop::instance(), SLOT(exitLoop()));
 
     socket.connectToHostEncrypted(QtNetworkSettings::imapServerName(), 993);
     QTestEventLoop::instance().enterLoop(10);
@@ -2965,7 +2965,7 @@ void tst_QSslSocket::resume()
         QCOMPARE(encryptedSpy.count(), 0);
         QVERIFY(!socket.isEncrypted());
         QCOMPARE(errorSpy.count(), 1);
-        QCOMPARE(socket.socketError(), QAbstractSocket::SslHandshakeFailedError);
+        QCOMPARE(socket.error(), QAbstractSocket::SslHandshakeFailedError);
     }
 }
 
@@ -3246,7 +3246,7 @@ void tst_QSslSocket::dhServer()
 
     QSslSocket client;
     socket = &client;
-    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
+    connect(socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
@@ -3280,7 +3280,7 @@ void tst_QSslSocket::dhServerCustomParamsNull()
 
     QSslSocket client;
     socket = &client;
-    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
+    connect(socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
@@ -3325,7 +3325,7 @@ void tst_QSslSocket::dhServerCustomParams()
 
     QSslSocket client;
     socket = &client;
-    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
+    connect(socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
@@ -3360,7 +3360,7 @@ void tst_QSslSocket::ecdhServer()
 
     QSslSocket client;
     socket = &client;
-    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
+    connect(socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
@@ -3552,7 +3552,7 @@ void tst_QSslSocket::readBufferMaxSize()
 
     QSslSocketPtr client(new QSslSocket);
     socket = client.data();
-    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
+    connect(socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), &loop, SLOT(quit()));
     connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(ignoreErrorSlot()));
     connect(socket, SIGNAL(encrypted()), &loop, SLOT(quit()));
 
@@ -3813,7 +3813,7 @@ void tst_QSslSocket::simplePskConnect()
     QSignalSpy sslErrorsSpy(&socket, SIGNAL(sslErrors(QList<QSslError>)));
     QVERIFY(sslErrorsSpy.isValid());
 
-    QSignalSpy socketErrorsSpy(&socket, SIGNAL(error(QAbstractSocket::SocketError)));
+    QSignalSpy socketErrorsSpy(&socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)));
     QVERIFY(socketErrorsSpy.isValid());
 
     QSignalSpy peerVerifyErrorSpy(&socket, SIGNAL(peerVerifyError(QSslError)));
@@ -3827,7 +3827,7 @@ void tst_QSslSocket::simplePskConnect()
     connect(&socket, SIGNAL(modeChanged(QSslSocket::SslMode)), this, SLOT(exitLoop()));
     connect(&socket, SIGNAL(encrypted()), this, SLOT(exitLoop()));
     connect(&socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(exitLoop()));
-    connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(exitLoop()));
+    connect(&socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), this, SLOT(exitLoop()));
     connect(&socket, SIGNAL(peerVerifyError(QSslError)), this, SLOT(exitLoop()));
     connect(&socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(exitLoop()));
 
@@ -4095,7 +4095,7 @@ void tst_QSslSocket::pskServer()
     connect(&socket, SIGNAL(modeChanged(QSslSocket::SslMode)), this, SLOT(exitLoop()));
     connect(&socket, SIGNAL(encrypted()), this, SLOT(exitLoop()));
     connect(&socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(exitLoop()));
-    connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(exitLoop()));
+    connect(&socket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)), this, SLOT(exitLoop()));
     connect(&socket, SIGNAL(peerVerifyError(QSslError)), this, SLOT(exitLoop()));
     connect(&socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(exitLoop()));
 
@@ -4275,7 +4275,7 @@ void tst_QSslSocket::signatureAlgorithm()
 
     QEventLoop loop;
     QTimer::singleShot(5000, &loop, &QEventLoop::quit);
-    connect(socket, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::error), &loop, &QEventLoop::quit);
+    connect(socket, &QAbstractSocket::errorOccurred, &loop, &QEventLoop::quit);
     connect(socket, QOverload<const QList<QSslError> &>::of(&QSslSocket::sslErrors), this, &tst_QSslSocket::ignoreErrorSlot);
     connect(socket, &QSslSocket::encrypted, &loop, &QEventLoop::quit);
 
@@ -4333,9 +4333,9 @@ void tst_QSslSocket::unsupportedProtocols()
         // early, preventing any real connection from ever starting.
         QSslSocket socket;
         socket.setProtocol(unsupportedProtocol);
-        QCOMPARE(socket.socketError(), QAbstractSocket::UnknownSocketError);
+        QCOMPARE(socket.error(), QAbstractSocket::UnknownSocketError);
         socket.connectToHostEncrypted(QStringLiteral("doesnotmatter.org"), 1010);
-        QCOMPARE(socket.socketError(), QAbstractSocket::SslInvalidUserDataError);
+        QCOMPARE(socket.error(), QAbstractSocket::SslInvalidUserDataError);
         QCOMPARE(socket.state(), QAbstractSocket::UnconnectedState);
     }
     {
@@ -4345,14 +4345,14 @@ void tst_QSslSocket::unsupportedProtocols()
         QVERIFY(server.listen());
 
         QSslSocket socket;
-        QCOMPARE(socket.socketError(), QAbstractSocket::UnknownSocketError);
+        QCOMPARE(socket.error(), QAbstractSocket::UnknownSocketError);
 
         socket.connectToHost(QHostAddress::LocalHost, server.serverPort());
         QVERIFY(socket.waitForConnected(timeoutMS));
 
         socket.setProtocol(unsupportedProtocol);
         socket.startClientEncryption();
-        QCOMPARE(socket.socketError(), QAbstractSocket::SslInvalidUserDataError);
+        QCOMPARE(socket.error(), QAbstractSocket::SslInvalidUserDataError);
     }
     {
         // 2. waitForEncrypted: client-side, blocking API plus requires from us
@@ -4376,7 +4376,7 @@ void tst_QSslSocket::unsupportedProtocols()
         loop.enterLoopMSecs(timeoutMS);
         QVERIFY(!loop.timeout());
         QVERIFY(server.socket);
-        QCOMPARE(server.socket->socketError(), QAbstractSocket::SslInvalidUserDataError);
+        QCOMPARE(server.socket->error(), QAbstractSocket::SslInvalidUserDataError);
     }
 }
 
diff --git a/tests/auto/other/networkselftest/tst_networkselftest.cpp b/tests/auto/other/networkselftest/tst_networkselftest.cpp
index 0f50718328..396e23da0c 100644
--- a/tests/auto/other/networkselftest/tst_networkselftest.cpp
+++ b/tests/auto/other/networkselftest/tst_networkselftest.cpp
@@ -428,7 +428,7 @@ void tst_NetworkSelfTest::serverReachability()
     QVERIFY2(timer.elapsed() < 9900, "Connection to closed port timed out instead of refusing, something is wrong");
 
     QVERIFY2(socket.state() == QAbstractSocket::UnconnectedState, "Socket connected unexpectedly!");
-    QVERIFY2(socket.socketError() == QAbstractSocket::ConnectionRefusedError,
+    QVERIFY2(socket.error() == QAbstractSocket::ConnectionRefusedError,
              QString("Could not reach server: %1").arg(socket.errorString()).toLocal8Bit());
 }
 
@@ -458,7 +458,7 @@ void tst_NetworkSelfTest::remotePortsOpen()
     socket.connectToHost(QtNetworkSettings::serverName(), portNumber);
 
     if (!socket.waitForConnected(10000)) {
-        if (socket.socketError() == QAbstractSocket::SocketTimeoutError)
+        if (socket.error() == QAbstractSocket::SocketTimeoutError)
             QFAIL(QString("Network timeout connecting to the server on port %1").arg(portNumber).toLocal8Bit());
         else
             QFAIL(QString("Error connecting to server on port %1: %2").arg(portNumber).arg(socket.errorString()).toLocal8Bit());
diff --git a/tests/auto/widgets/dialogs/qwizard/tst_qwizard.cpp b/tests/auto/widgets/dialogs/qwizard/tst_qwizard.cpp
index dae274a8b6..5b7ded0ecb 100644
--- a/tests/auto/widgets/dialogs/qwizard/tst_qwizard.cpp
+++ b/tests/auto/widgets/dialogs/qwizard/tst_qwizard.cpp
@@ -586,7 +586,7 @@ void tst_QWizard::addPage()
 #define CHECK_VISITED(wizard, list) \
     do { \
         QList<int> myList = list; \
-        QCOMPARE((wizard).visitedPages(), myList); \
+        QCOMPARE((wizard).visitedIds(), myList); \
         Q_FOREACH(int id, myList) \
             QVERIFY((wizard).hasVisitedPage(id)); \
     } while (0)
@@ -2293,7 +2293,7 @@ void tst_QWizard::removePage()
 
     wizard.restart();
     QCOMPARE(wizard.pageIds().size(), 4);
-    QCOMPARE(wizard.visitedPages().size(), 1);
+    QCOMPARE(wizard.visitedIds().size(), 1);
     QCOMPARE(spy.count(), 0);
 
     // Removing a non-existent page
@@ -2331,14 +2331,14 @@ void tst_QWizard::removePage()
     wizard.setPage(2, page2); // restore
     wizard.restart();
     wizard.next();
-    QCOMPARE(wizard.visitedPages().size(), 2);
+    QCOMPARE(wizard.visitedIds().size(), 2);
     QCOMPARE(wizard.currentPage(), page1);
     QCOMPARE(spy.count(), 0);
     wizard.removePage(2);
     QCOMPARE(spy.count(), 1);
     arguments = spy.takeFirst();
     QCOMPARE(arguments.at(0).toInt(), 2);
-    QCOMPARE(wizard.visitedPages().size(), 2);
+    QCOMPARE(wizard.visitedIds().size(), 2);
     QVERIFY(!wizard.pageIds().contains(2));
     QCOMPARE(wizard.currentPage(), page1);
 
@@ -2347,14 +2347,14 @@ void tst_QWizard::removePage()
     wizard.restart();
     wizard.next();
     QCOMPARE(spy.count(), 0);
-    QCOMPARE(wizard.visitedPages().size(), 2);
+    QCOMPARE(wizard.visitedIds().size(), 2);
     QCOMPARE(wizard.currentPage(), page1);
     wizard.removePage(0);
     QCOMPARE(spy.count(), 1);
     arguments = spy.takeFirst();
     QCOMPARE(arguments.at(0).toInt(), 0);
-    QCOMPARE(wizard.visitedPages().size(), 1);
-    QVERIFY(!wizard.visitedPages().contains(0));
+    QCOMPARE(wizard.visitedIds().size(), 1);
+    QVERIFY(!wizard.visitedIds().contains(0));
     QVERIFY(!wizard.pageIds().contains(0));
     QCOMPARE(wizard.currentPage(), page1);
 
@@ -2363,14 +2363,14 @@ void tst_QWizard::removePage()
     wizard.restart();
     wizard.next();
     QCOMPARE(spy.count(), 0);
-    QCOMPARE(wizard.visitedPages().size(), 2);
+    QCOMPARE(wizard.visitedIds().size(), 2);
     QCOMPARE(wizard.currentPage(), page1);
     wizard.removePage(1);
     QCOMPARE(spy.count(), 1);
     arguments = spy.takeFirst();
     QCOMPARE(arguments.at(0).toInt(), 1);
-    QCOMPARE(wizard.visitedPages().size(), 1);
-    QVERIFY(!wizard.visitedPages().contains(1));
+    QCOMPARE(wizard.visitedIds().size(), 1);
+    QVERIFY(!wizard.visitedIds().contains(1));
     QVERIFY(!wizard.pageIds().contains(1));
     QCOMPARE(wizard.currentPage(), page0);
 
@@ -2379,8 +2379,8 @@ void tst_QWizard::removePage()
     QCOMPARE(spy.count(), 1);
     arguments = spy.takeFirst();
     QCOMPARE(arguments.at(0).toInt(), 0);
-    QCOMPARE(wizard.visitedPages().size(), 1);
-    QVERIFY(!wizard.visitedPages().contains(0));
+    QCOMPARE(wizard.visitedIds().size(), 1);
+    QVERIFY(!wizard.visitedIds().contains(0));
     QCOMPARE(wizard.pageIds().size(), 2);
     QVERIFY(!wizard.pageIds().contains(0));
     QCOMPARE(wizard.currentPage(), page2);
@@ -2389,8 +2389,8 @@ void tst_QWizard::removePage()
     QCOMPARE(spy.count(), 1);
     arguments = spy.takeFirst();
     QCOMPARE(arguments.at(0).toInt(), 2);
-    QCOMPARE(wizard.visitedPages().size(), 1);
-    QVERIFY(!wizard.visitedPages().contains(2));
+    QCOMPARE(wizard.visitedIds().size(), 1);
+    QVERIFY(!wizard.visitedIds().contains(2));
     QCOMPARE(wizard.pageIds().size(), 1);
     QVERIFY(!wizard.pageIds().contains(2));
     QCOMPARE(wizard.currentPage(), page3);
@@ -2399,7 +2399,7 @@ void tst_QWizard::removePage()
     QCOMPARE(spy.count(), 1);
     arguments = spy.takeFirst();
     QCOMPARE(arguments.at(0).toInt(), 3);
-    QVERIFY(wizard.visitedPages().empty());
+    QVERIFY(wizard.visitedIds().empty());
     QVERIFY(wizard.pageIds().empty());
     QCOMPARE(wizard.currentPage(), nullptr);
 }
diff --git a/tests/auto/widgets/kernel/qwidget/BLACKLIST b/tests/auto/widgets/kernel/qwidget/BLACKLIST
index cf35491ec0..70ea8433a6 100644
--- a/tests/auto/widgets/kernel/qwidget/BLACKLIST
+++ b/tests/auto/widgets/kernel/qwidget/BLACKLIST
@@ -8,11 +8,6 @@ b2qt
 opensuse-42.3
 [restoreVersion1Geometry]
 ubuntu-16.04
-[updateWhileMinimized]
-ubuntu-18.04
-rhel-7.4
-ubuntu-16.04
-rhel-7.6
 [focusProxyAndInputMethods]
 rhel-7.6
 opensuse-leap
diff --git a/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp b/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
index f0c490b598..1f2060942b 100644
--- a/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
+++ b/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
@@ -8074,7 +8074,17 @@ void tst_QWidget::updateWhileMinimized()
     QTest::qWait(10);
     if (m_platform == QStringLiteral("winrt"))
         QEXPECT_FAIL("", "WinRT: This fails. QTBUG-68297.", Abort);
-    QCOMPARE(widget.numPaintEvents, 0);
+    int count = 0;
+    // mutter/GNOME Shell doesn't unmap when minimizing window.
+    // More details at https://gitlab.gnome.org/GNOME/mutter/issues/185
+    if (m_platform == QStringLiteral("xcb")) {
+        const QString desktop = qgetenv("XDG_CURRENT_DESKTOP");
+        qDebug() << "xcb: XDG_CURRENT_DESKTOP=" << desktop;
+        if (desktop == QStringLiteral("ubuntu:GNOME")
+            || desktop == QStringLiteral("GNOME-Classic:GNOME"))
+            count = 1;
+    }
+    QCOMPARE(widget.numPaintEvents, count);
 
     // Restore window.
     widget.showNormal();
diff --git a/tests/auto/widgets/widgets/qdatetimeedit/tst_qdatetimeedit.cpp b/tests/auto/widgets/widgets/qdatetimeedit/tst_qdatetimeedit.cpp
index 9eae1f10ea..9659d89833 100644
--- a/tests/auto/widgets/widgets/qdatetimeedit/tst_qdatetimeedit.cpp
+++ b/tests/auto/widgets/widgets/qdatetimeedit/tst_qdatetimeedit.cpp
@@ -296,6 +296,13 @@ private slots:
 
     void stepModifierPressAndHold_data();
     void stepModifierPressAndHold();
+
+    void springForward_data();
+    void springForward();
+
+    void stepIntoDSTGap_data();
+    void stepIntoDSTGap();
+
 private:
     EditorDateEdit* testWidget;
     QWidget *testFocusWidget;
@@ -4387,5 +4394,229 @@ void tst_QDateTimeEdit::stepModifierPressAndHold()
     QCOMPARE(value.toDate(), expectedDate);
 }
 
+/*
+    The following tests verify correct handling of the spring forward gap; which
+    hour is skipped, and on which day, depends on the local time zone. We try to
+    make it reasonably robust by discovering the first day of spring in a given
+    year, but we won't try to handle every situation.
+
+    If this function returns an invalid QDateTime, then the tests should be skipped.
+*/
+static QDateTime findSpring(int year, const QTimeZone &timeZone)
+{
+    if (!timeZone.hasTransitions())
+        return QDateTime();
+
+    // Southern hemisphere spring is after midsummer
+    const QDateTime midSummer = QDate(year, 6, 21).startOfDay();
+    const QTimeZone::OffsetData transition =
+        midSummer.isDaylightTime() ? timeZone.previousTransition(midSummer)
+                                   : timeZone.nextTransition(midSummer);
+    const QDateTime spring = transition.atUtc.toLocalTime();
+    // there might have been DST at some point, but not in the year we care about
+    if (spring.date().year() != year || !spring.isDaylightTime())
+        return QDateTime();
+
+    return spring;
+};
+
+/*!
+    Test that typing in a time that is invalid due to spring forward gap
+    produces reasonable results.
+*/
+void tst_QDateTimeEdit::springForward_data()
+{
+    QTest::addColumn<QDateTime>("start");
+    QTest::addColumn<QAbstractSpinBox::CorrectionMode>("correctionMode");
+    QTest::addColumn<QTime>("inputTime");
+    QTest::addColumn<QDateTime>("expected");
+
+    const QTimeZone timeZone = QTimeZone::systemTimeZone();
+    if (!timeZone.hasDaylightTime())
+        QSKIP("This test needs to run in a timezone that observes DST!");
+
+    const QDateTime springTransition = findSpring(2019, timeZone);
+    if (!springTransition.isValid())
+        QSKIP("Failed to obtain valid spring forward datetime for 2019!");
+
+    const QDate springDate = springTransition.date();
+    const int gapWidth = timeZone.daylightTimeOffset(springTransition.addDays(1));
+    const QTime springGap = springTransition.time().addSecs(-gapWidth);
+    const QTime springGapMiddle = springTransition.time().addSecs(-gapWidth/2);
+
+    QTest::addRow("forward to %s, correct to previous", qPrintable(springGap.toString("hh:mm")))
+        << QDateTime(springDate, springGap.addSecs(-gapWidth))
+        << QAbstractSpinBox::CorrectToPreviousValue
+        << springGap
+        << QDateTime(springDate, springGap.addSecs(-gapWidth));
+
+    QTest::addRow("back to %s, correct to previous", qPrintable(springGap.toString("hh:mm")))
+        << springTransition
+        << QAbstractSpinBox::CorrectToPreviousValue
+        << springGap
+        << springTransition;
+
+    QTest::addRow("forward to %s, correct to nearest", qPrintable(springGap.toString("hh:mm")))
+        << QDateTime(springDate, springGap.addSecs(-gapWidth))
+        << QAbstractSpinBox::CorrectToNearestValue
+        << springGapMiddle
+        << springTransition;
+
+    QTest::addRow("back to %s, correct to nearest", qPrintable(springGap.toString("hh:mm")))
+        << springTransition
+        << QAbstractSpinBox::CorrectToNearestValue
+        << springGapMiddle
+        << springTransition;
+
+    QTest::addRow("jump to %s, correct to nearest", qPrintable(springGapMiddle.toString("hh:mm")))
+        << QDateTime(QDate(1980, 5, 10), springGap)
+        << QAbstractSpinBox::CorrectToNearestValue
+        << springGapMiddle
+        << springTransition;
+}
+
+void tst_QDateTimeEdit::springForward()
+{
+    QFETCH(QDateTime, start);
+    QFETCH(QAbstractSpinBox::CorrectionMode, correctionMode);
+    QFETCH(QTime, inputTime);
+    QFETCH(QDateTime, expected);
+
+    QDateTimeEdit edit;
+    edit.setDisplayFormat(QLatin1String("dd.MM.yyyy hh:mm"));
+    edit.setCorrectionMode(correctionMode);
+
+    // we always want to start with a valid time
+    QVERIFY(start.isValid());
+    edit.setDateTime(start);
+
+    edit.setSelectedSection(QDateTimeEdit::DaySection);
+    const QDate date = expected.date();
+    const QString day = QString::number(date.day()).rightJustified(2, QLatin1Char('0'));
+    const QString month = QString::number(date.month()).rightJustified(2, QLatin1Char('0'));
+    const QString year = QString::number(date.year());
+    const QString hour = QString::number(inputTime.hour()).rightJustified(2, QLatin1Char('0'));
+    const QString minute = QString::number(inputTime.minute()).rightJustified(2, QLatin1Char('0'));
+    QTest::keyClicks(&edit, day);
+    QTest::keyClicks(&edit, month);
+    QTest::keyClicks(&edit, year);
+    QTest::keyClicks(&edit, hour);
+    QTest::keyClicks(&edit, minute);
+    QTest::keyClick(&edit, Qt::Key_Return, {});
+
+    QCOMPARE(edit.dateTime(), expected);
+}
+
+/*!
+    Test that using the up/down spinners to modify a valid time into a time that
+    is invalid due to daylight-saving changes produces reasonable results.
+
+    2007 is a year in which the DST transition in most tested places was not on the
+    last or first day of the month, which allows us to test the various steps.
+*/
+void tst_QDateTimeEdit::stepIntoDSTGap_data()
+{
+    QTest::addColumn<QDateTime>("start");
+    QTest::addColumn<QDateTimeEdit::Section>("section");
+    QTest::addColumn<int>("steps");
+    QTest::addColumn<QDateTime>("end");
+
+    const QTimeZone timeZone = QTimeZone::systemTimeZone();
+    if (!timeZone.hasDaylightTime())
+        QSKIP("This test needs to run in a timezone that observes DST!");
+
+    const QDateTime springTransition = findSpring(2007, timeZone);
+    if (!springTransition.isValid())
+        QSKIP("Failed to obtain valid spring forward datetime for 2007!");
+
+    const QDate spring = springTransition.date();
+    const int gapWidth = timeZone.daylightTimeOffset(springTransition.addDays(1));
+    const QTime springGap = springTransition.time().addSecs(-gapWidth);
+
+    // change hour
+    if (springGap.hour() != 0) {
+        QTest::addRow("hour up into %s gap", qPrintable(springGap.toString("hh:mm")))
+            << QDateTime(spring, springGap.addSecs(-3600))
+            << QDateTimeEdit::HourSection
+            << +1
+            << springTransition;
+
+        // 3:00:10 into 2:00:10 should get us to 1:00:10
+        QTest::addRow("hour down into %s gap", qPrintable(springGap.toString("hh:mm")))
+            << QDateTime(spring, springGap.addSecs(3610))
+            << QDateTimeEdit::HourSection
+            << -1
+            << QDateTime(spring, springGap.addSecs(-3590));
+    }
+
+    // change day
+    if (spring.day() != 1) {
+        // today's 2:05 is tomorrow's 3:05
+        QTest::addRow("day up into %s gap", qPrintable(springGap.toString("hh:mm")))
+            << QDateTime(spring.addDays(-1), springGap.addSecs(300))
+            << QDateTimeEdit::DaySection
+            << +1
+            << springTransition.addSecs(300);
+    }
+
+    if (spring.day() != spring.daysInMonth()) {
+        QTest::addRow("day down into %s gap", qPrintable(springGap.toString("hh:mm")))
+            << QDateTime(spring.addDays(1), springGap)
+            << QDateTimeEdit::DaySection
+            << -1
+            << springTransition;
+    }
+
+    // 2018-03-25 - change month
+    QTest::addRow("month up into %s gap", qPrintable(springGap.toString("hh:mm")))
+        << QDateTime(spring.addMonths(-1), springGap)
+        << QDateTimeEdit::MonthSection
+        << +1
+        << springTransition;
+    QTest::addRow("month down into %s gap", qPrintable(springGap.toString("hh:mm")))
+        << QDateTime(spring.addMonths(1), springGap)
+        << QDateTimeEdit::MonthSection
+        << -1
+        << springTransition;
+
+    // 2018-03-25 - change year
+    QTest::addRow("year up into %s gap", qPrintable(springGap.toString("hh:mm")))
+        << QDateTime(spring.addYears(-1), springGap)
+        << QDateTimeEdit::YearSection
+        << +1
+        << springTransition;
+    QTest::addRow("year down into %s gap", qPrintable(springGap.toString("hh:mm")))
+        << QDateTime(spring.addYears(1), springGap)
+        << QDateTimeEdit::YearSection
+        << -1
+        << springTransition;
+}
+
+void tst_QDateTimeEdit::stepIntoDSTGap()
+{
+    QFETCH(QDateTime, start);
+    QFETCH(QDateTimeEdit::Section, section);
+    QFETCH(int, steps);
+    QFETCH(QDateTime, end);
+
+    QDateTimeEdit edit;
+    edit.setDisplayFormat(QLatin1String("dd.MM.yyyy hh:mm"));
+
+    // we always want to start with a valid time
+    QVERIFY(start.isValid());
+    edit.setDateTime(start);
+
+    edit.setSelectedSection(section);
+
+    // we want to end with a valid value
+    QVERIFY(end.isValid());
+
+    const auto stepCount = qAbs(steps);
+    for (int step = 0; step < stepCount; ++step)
+        QTest::keyClick(&edit, steps > 0 ? Qt::Key_Up : Qt::Key_Down, {});
+
+    QCOMPARE(edit.dateTime(), end);
+}
+
 QTEST_MAIN(tst_QDateTimeEdit)
 #include "tst_qdatetimeedit.moc"
diff --git a/tests/auto/xml/sax/qxmlinputsource/tst_qxmlinputsource.cpp b/tests/auto/xml/sax/qxmlinputsource/tst_qxmlinputsource.cpp
index 5dce69bd8c..afdcc825d8 100644
--- a/tests/auto/xml/sax/qxmlinputsource/tst_qxmlinputsource.cpp
+++ b/tests/auto/xml/sax/qxmlinputsource/tst_qxmlinputsource.cpp
@@ -149,7 +149,7 @@ public slots:
 
     void requestFinished(QNetworkReply *reply)
     {
-        QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+        QCOMPARE(reply->error(), QNetworkReply::NoError);
         reply->deleteLater();
     }
 
diff --git a/tests/baselineserver/shared/baselineprotocol.cpp b/tests/baselineserver/shared/baselineprotocol.cpp
index d11369f3d2..16915b7c02 100644
--- a/tests/baselineserver/shared/baselineprotocol.cpp
+++ b/tests/baselineserver/shared/baselineprotocol.cpp
@@ -545,7 +545,7 @@ bool BaselineProtocol::receiveBlock(Command *cmd, QByteArray *block)
 QString BaselineProtocol::errorMessage()
 {
     QString ret = errMsg;
-    if (socket.socketError() >= 0)
+    if (socket.error() >= 0)
         ret += QLS(" Socket state: ") + socket.errorString();
     return ret;
 }
diff --git a/tests/benchmarks/network/access/qnetworkreply/tst_qnetworkreply.cpp b/tests/benchmarks/network/access/qnetworkreply/tst_qnetworkreply.cpp
index 1a8c8de0c8..95ee094f00 100644
--- a/tests/benchmarks/network/access/qnetworkreply/tst_qnetworkreply.cpp
+++ b/tests/benchmarks/network/access/qnetworkreply/tst_qnetworkreply.cpp
@@ -537,7 +537,7 @@ void tst_qnetworkreply::echoPerformance()
         connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()), Qt::QueuedConnection);
         QTestEventLoop::instance().enterLoop(5);
         QVERIFY(!QTestEventLoop::instance().timeout());
-        QVERIFY(reply->networkError() == QNetworkReply::NoError);
+        QVERIFY(reply->error() == QNetworkReply::NoError);
         delete reply;
     }
 }
@@ -562,7 +562,7 @@ void tst_qnetworkreply::preConnectEncrypted()
     QPair<QNetworkReply *, qint64> normalResult = runGetRequest(&manager, request);
     QNetworkReply *normalReply = normalResult.first;
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QVERIFY(normalReply->networkError() == QNetworkReply::NoError);
+    QVERIFY(normalReply->error() == QNetworkReply::NoError);
     qint64 normalElapsed = normalResult.second;
 
     // clear all caches again
@@ -581,7 +581,7 @@ void tst_qnetworkreply::preConnectEncrypted()
     QPair<QNetworkReply *, qint64> preConnectResult = runGetRequest(&manager, request);
     QNetworkReply *preConnectReply = normalResult.first;
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QVERIFY(preConnectReply->networkError() == QNetworkReply::NoError);
+    QVERIFY(preConnectReply->error() == QNetworkReply::NoError);
     qint64 preConnectElapsed = preConnectResult.second;
     qDebug() << request.url().toString() << "full request:" << normalElapsed
              << "ms, pre-connect request:" << preConnectElapsed << "ms, difference:"
@@ -636,7 +636,7 @@ void tst_qnetworkreply::uploadPerformance()
       QTimer::singleShot(5000, &generator, SLOT(stop()));
 
       QTestEventLoop::instance().enterLoop(30);
-      QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+      QCOMPARE(reply->error(), QNetworkReply::NoError);
       QVERIFY(!QTestEventLoop::instance().timeout());
 }
 
@@ -662,7 +662,7 @@ void tst_qnetworkreply::httpUploadPerformance()
       reader.exit();
       reader.wait();
       QVERIFY(reply->isFinished());
-      QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+      QCOMPARE(reply->error(), QNetworkReply::NoError);
       QVERIFY(!QTestEventLoop::instance().timeout());
 
       qDebug() << "tst_QNetworkReply::httpUploadPerformance" << elapsed << "msec, "
@@ -723,7 +723,7 @@ void tst_qnetworkreply::httpDownloadPerformance()
     QTime time;
     time.start();
     QTestEventLoop::instance().enterLoop(40);
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     QVERIFY(!QTestEventLoop::instance().timeout());
 
     qint64 elapsed = time.elapsed();
@@ -805,7 +805,7 @@ void tst_qnetworkreply::httpDownloadPerformanceDownloadBuffer()
 
     QBENCHMARK_ONCE {
         QTestEventLoop::instance().enterLoop(40);
-        QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+        QCOMPARE(reply->error(), QNetworkReply::NoError);
         QVERIFY(reply->isFinished());
         QVERIFY(!QTestEventLoop::instance().timeout());
     }
@@ -840,7 +840,7 @@ public slots:
         }
         QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender());
         if (reply) {
-            QVERIFY(reply->networkError() == QNetworkReply::NoError);
+            QVERIFY(reply->error() == QNetworkReply::NoError);
             qDebug() << "time =" << timeOneRequest.elapsed() << "ms";
             timeList.append(timeOneRequest.elapsed());
         }
@@ -895,7 +895,7 @@ void tst_qnetworkreply::runHttpsUploadRequest(const QByteArray &data, const QNet
     connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
     QTestEventLoop::instance().enterLoop(15);
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QCOMPARE(reply->networkError(), QNetworkReply::NoError);
+    QCOMPARE(reply->error(), QNetworkReply::NoError);
     reply->deleteLater();
 }
 
@@ -935,7 +935,7 @@ void tst_qnetworkreply::preConnect()
     QPair<QNetworkReply *, qint64> normalResult = runGetRequest(&manager, request);
     QNetworkReply *normalReply = normalResult.first;
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QVERIFY(normalReply->networkError() == QNetworkReply::NoError);
+    QVERIFY(normalReply->error() == QNetworkReply::NoError);
     qint64 normalElapsed = normalResult.second;
 
     // clear all caches again
@@ -955,7 +955,7 @@ void tst_qnetworkreply::preConnect()
     QPair<QNetworkReply *, qint64> preConnectResult = runGetRequest(&manager, request);
     QNetworkReply *preConnectReply = normalResult.first;
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QVERIFY(preConnectReply->networkError() == QNetworkReply::NoError);
+    QVERIFY(preConnectReply->error() == QNetworkReply::NoError);
     qint64 preConnectElapsed = preConnectResult.second;
     qDebug() << request.url().toString() << "full request:" << normalElapsed
              << "ms, pre-connect request:" << preConnectElapsed << "ms, difference:"
diff --git a/tests/libfuzzer/corelib/serialization/qcborvalue/fromcbor/fromcbor.pro b/tests/libfuzzer/corelib/serialization/qcborvalue/fromcbor/fromcbor.pro
new file mode 100644
index 0000000000..6c988c2434
--- /dev/null
+++ b/tests/libfuzzer/corelib/serialization/qcborvalue/fromcbor/fromcbor.pro
@@ -0,0 +1,10 @@
+QT -= gui
+CONFIG += console
+CONFIG -= app_bundle
+SOURCES += main.cpp
+FUZZ_ENGINE = $$(LIB_FUZZING_ENGINE)
+isEmpty(FUZZ_ENGINE) {
+    QMAKE_LFLAGS += -fsanitize=fuzzer
+} else {
+    LIBS += $$FUZZ_ENGINE
+}
diff --git a/tests/libfuzzer/corelib/serialization/qcborvalue/fromcbor/main.cpp b/tests/libfuzzer/corelib/serialization/qcborvalue/fromcbor/main.cpp
new file mode 100644
index 0000000000..5e2a440d1b
--- /dev/null
+++ b/tests/libfuzzer/corelib/serialization/qcborvalue/fromcbor/main.cpp
@@ -0,0 +1,34 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QCborValue>
+
+extern "C" int LLVMFuzzerTestOneInput(const char *Data, size_t Size) {
+    QCborValue::fromCbor(QByteArray::fromRawData(Data, Size));
+    return 0;
+}
diff --git a/tests/manual/bearerex/datatransferer.cpp b/tests/manual/bearerex/datatransferer.cpp
index 0eeeb090ae..b4409ce52c 100644
--- a/tests/manual/bearerex/datatransferer.cpp
+++ b/tests/manual/bearerex/datatransferer.cpp
@@ -53,7 +53,7 @@ DataTransfererQTcp::DataTransfererQTcp(QObject* parent)
 
     connect(&m_qsocket, SIGNAL(readyRead()), this, SLOT(readyRead()));
     connect(&m_qsocket, SIGNAL(connected()), this, SLOT(connected()));
-    connect(&m_qsocket, SIGNAL(error(QAbstractSocket::SocketError)),
+    connect(&m_qsocket, SIGNAL(errorOccurred(QAbstractSocket::SocketError)),
             this, SLOT(error(QAbstractSocket::SocketError)));
 }