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

Change-Id: I469b0501cc65fc5ce4d797a69ae89405cc69c7f8

1 files changed, 170 insertions, 165 deletions

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);
 }