Network: Use QHttpHeaders in QHttpHeaderParser

QHttpHeaderParser::headers() method is changed to return QHttpHeaders.
QAuthenticatorPrivate::parseHttpResponse() method is changed to work with QHttpHeaders.
QHttpNetworkHeader::header() method is updated to return QHttpHeaders.
Tests are updated.

Task-number: QTBUG-120133
Change-Id: I20a18b509acd7a8b8d93884cff8349519d64293e
Reviewed-by: Ievgenii Meshcheriakov <ievgenii.meshcheriakov@qt.io>
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
Reviewed-by: Øystein Heskestad <oystein.heskestad@qt.io>

6 files changed, 102 insertions, 88 deletions

diff --git a/tests/auto/network/access/hsts/tst_qhsts.cpp b/tests/auto/network/access/hsts/tst_qhsts.cpp
index 97a2d2889e..d81bc3e3e3 100644
--- a/tests/auto/network/access/hsts/tst_qhsts.cpp
+++ b/tests/auto/network/access/hsts/tst_qhsts.cpp
@@ -9,6 +9,7 @@
 #include <QtCore/qpair.h>
 #include <QtCore/qurl.h>
 
+#include <QtNetwork/qhttpheaders.h>
 #include <QtNetwork/private/qhstsstore_p.h>
 #include <QtNetwork/private/qhsts_p.h>
 
@@ -189,110 +190,108 @@ void tst_QHsts::testPolicyExpiration()
 void tst_QHsts::testSTSHeaderParser()
 {
     QHstsHeaderParser parser;
-    using Header = QPair<QByteArray, QByteArray>;
-    using Headers = QList<Header>;
 
     QVERIFY(!parser.includeSubDomains());
     QVERIFY(!parser.expirationDate().isValid());
-    Headers list;
-    QVERIFY(!parser.parse(list));
+    QHttpHeaders headers;
+    QVERIFY(!parser.parse(headers));
     QVERIFY(!parser.includeSubDomains());
     QVERIFY(!parser.expirationDate().isValid());
 
-    list << Header("Strict-Transport-security", "200");
-    QVERIFY(!parser.parse(list));
+    headers.append("Strict-Transport-security", "200");
+    QVERIFY(!parser.parse(headers));
     QVERIFY(!parser.includeSubDomains());
     QVERIFY(!parser.expirationDate().isValid());
 
     // This header is missing REQUIRED max-age directive, so we'll ignore it:
-    list << Header("Strict-Transport-Security", "includeSubDomains");
-    QVERIFY(!parser.parse(list));
+    headers.append("Strict-Transport-Security", "includeSubDomains");
+    QVERIFY(!parser.parse(headers));
     QVERIFY(!parser.includeSubDomains());
     QVERIFY(!parser.expirationDate().isValid());
 
-    list.pop_back();
-    list << Header("Strict-Transport-Security", "includeSubDomains;max-age=1000");
-    QVERIFY(parser.parse(list));
+    headers.removeAt(headers.size() - 1);
+    headers.append("Strict-Transport-Security", "includeSubDomains;max-age=1000");
+    QVERIFY(parser.parse(headers));
     QVERIFY(parser.expirationDate() > QDateTime::currentDateTimeUtc());
     QVERIFY(parser.includeSubDomains());
 
-    list.pop_back();
-    list << Header("strict-transport-security", "includeSubDomains;max-age=1000");
-    QVERIFY(parser.parse(list));
+    headers.removeAt(headers.size() - 1);
+    headers.append("strict-transport-security", "includeSubDomains;max-age=1000");
+    QVERIFY(parser.parse(headers));
     QVERIFY(parser.expirationDate() > QDateTime::currentDateTimeUtc());
     QVERIFY(parser.includeSubDomains());
 
-    list.pop_back();
+    headers.removeAt(headers.size() - 1);
     // Invalid (includeSubDomains twice):
-    list << Header("Strict-Transport-Security", "max-age = 1000 ; includeSubDomains;includeSubDomains");
-    QVERIFY(!parser.parse(list));
+    headers.append("Strict-Transport-Security", "max-age = 1000 ; includeSubDomains;includeSubDomains");
+    QVERIFY(!parser.parse(headers));
     QVERIFY(!parser.includeSubDomains());
     QVERIFY(!parser.expirationDate().isValid());
 
-    list.pop_back();
+    headers.removeAt(headers.size() - 1);
     // Invalid (weird number of seconds):
-    list << Header("Strict-Transport-Security", "max-age=-1000   ; includeSubDomains");
-    QVERIFY(!parser.parse(list));
+    headers.append("Strict-Transport-Security", "max-age=-1000   ; includeSubDomains");
+    QVERIFY(!parser.parse(headers));
     QVERIFY(!parser.includeSubDomains());
     QVERIFY(!parser.expirationDate().isValid());
 
-    list.pop_back();
+    headers.removeAt(headers.size() - 1);
     // Note, directives are case-insensitive + we should ignore unknown directive.
-    list << Header("Strict-Transport-Security", ";max-age=1000 ;includesubdomains;;"
+    headers.append("Strict-Transport-Security", ";max-age=1000 ;includesubdomains;;"
                    "nowsomeunknownheader=\"somevaluewithescapes\\;\"");
-    QVERIFY(parser.parse(list));
+    QVERIFY(parser.parse(headers));
     QVERIFY(parser.includeSubDomains());
     QVERIFY(parser.expirationDate().isValid());
 
-    list.pop_back();
+    headers.removeAt(headers.size() - 1);
     // Check that we know how to unescape max-age:
-    list << Header("Strict-Transport-Security", "max-age=\"1000\"");
-    QVERIFY(parser.parse(list));
+    headers.append("Strict-Transport-Security", "max-age=\"1000\"");
+    QVERIFY(parser.parse(headers));
     QVERIFY(!parser.includeSubDomains());
     QVERIFY(parser.expirationDate().isValid());
 
-    list.pop_back();
+    headers.removeAt(headers.size() - 1);
     // The only STS header, with invalid syntax though, to be ignored:
-    list << Header("Strict-Transport-Security", "max-age; max-age=15768000");
-    QVERIFY(!parser.parse(list));
+    headers.append("Strict-Transport-Security", "max-age; max-age=15768000");
+    QVERIFY(!parser.parse(headers));
     QVERIFY(!parser.includeSubDomains());
     QVERIFY(!parser.expirationDate().isValid());
 
     // Now we check that our parse chosses the first valid STS header and ignores
     // others:
-    list.clear();
-    list << Header("Strict-Transport-Security", "includeSubdomains; max-age=\"hehehe\";");
-    list << Header("Strict-Transport-Security", "max-age=10101");
-    QVERIFY(parser.parse(list));
+    headers.clear();
+    headers.append("Strict-Transport-Security", "includeSubdomains; max-age=\"hehehe\";");
+    headers.append("Strict-Transport-Security", "max-age=10101");
+    QVERIFY(parser.parse(headers));
     QVERIFY(!parser.includeSubDomains());
     QVERIFY(parser.expirationDate().isValid());
 
 
-    list.clear();
-    list << Header("Strict-Transport-Security", "max-age=0");
-    QVERIFY(parser.parse(list));
+    headers.clear();
+    headers.append("Strict-Transport-Security", "max-age=0");
+    QVERIFY(parser.parse(headers));
     QVERIFY(!parser.includeSubDomains());
     QVERIFY(parser.expirationDate() <= QDateTime::currentDateTimeUtc());
 
     // Parsing is case-insensitive:
-    list.pop_back();
-    list << Header("Strict-Transport-Security", "Max-aGE=1000; InclUdesUbdomains");
-    QVERIFY(parser.parse(list));
+    headers.removeAt(headers.size() - 1);
+    headers.append("Strict-Transport-Security", "Max-aGE=1000; InclUdesUbdomains");
+    QVERIFY(parser.parse(headers));
     QVERIFY(parser.includeSubDomains());
     QVERIFY(parser.expirationDate().isValid());
 
     // Grammar of STS header is quite permissive, let's check we can parse
     // some weird but valid header:
-    list.pop_back();
-    list << Header("Strict-Transport-Security", ";;; max-age = 17; ; ; ; ;;; ;;"
+    headers.removeAt(headers.size() - 1);
+    headers.append("Strict-Transport-Security", ";;; max-age = 17; ; ; ; ;;; ;;"
                     ";;; ; includeSubdomains ;;thisIsUnknownDirective;;;;");
-    QVERIFY(parser.parse(list));
+    QVERIFY(parser.parse(headers));
     QVERIFY(parser.includeSubDomains());
     QVERIFY(parser.expirationDate().isValid());
 
-    list.pop_back();
-    list << Header("Strict-Transport-Security", "max-age=1000; includeSubDomains bogon");
-    QVERIFY(!parser.parse(list));
+    headers.removeAt(headers.size() - 1);
+    headers.append("Strict-Transport-Security", "max-age=1000; includeSubDomains bogon");
+    QVERIFY(!parser.parse(headers));
     QVERIFY(!parser.includeSubDomains());
     QVERIFY(!parser.expirationDate().isValid());
 }
diff --git a/tests/auto/network/access/http2/http2srv.cpp b/tests/auto/network/access/http2/http2srv.cpp
index d7c8c2fd8e..f98fed0322 100644
--- a/tests/auto/network/access/http2/http2srv.cpp
+++ b/tests/auto/network/access/http2/http2srv.cpp
@@ -377,16 +377,12 @@ bool Http2Server::verifyProtocolUpgradeRequest()
     bool settingsOk = false;
 
     QHttpNetworkReplyPrivate *firstRequestReader = protocolUpgradeHandler->d_func();
+    const auto headers = firstRequestReader->headers();
 
     // That's how we append them, that's what I expect to find:
-    for (const auto &header : firstRequestReader->headers()) {
-        if (header.first == "Connection")
-            connectionOk = header.second.contains("Upgrade, HTTP2-Settings");
-        else if (header.first == "Upgrade")
-            upgradeOk = header.second.contains("h2c");
-        else if (header.first == "HTTP2-Settings")
-            settingsOk = true;
-    }
+    connectionOk = headers.combinedValue(QHttpHeaders::WellKnownHeader::Connection).contains("Upgrade, HTTP2-Settings");
+    upgradeOk = headers.combinedValue(QHttpHeaders::WellKnownHeader::Upgrade).contains("h2c");
+    settingsOk = headers.contains("HTTP2-Settings");
 
     return connectionOk && upgradeOk && settingsOk;
 }
diff --git a/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp b/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
index 099cf1b047..8cdd15a5f9 100644
--- a/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
+++ b/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
@@ -731,11 +731,11 @@ private:
 
     void parseContentLength()
     {
-        int index = receivedData.indexOf("Content-Length:");
+        int index = receivedData.indexOf("content-length:");
         if (index == -1)
             return;
 
-        index += sizeof("Content-Length:") - 1;
+        index += sizeof("content-length:") - 1;
         const auto end = std::find(receivedData.cbegin() + index, receivedData.cend(), '\r');
         auto num = receivedData.mid(index, std::distance(receivedData.cbegin() + index, end));
         bool ok;
@@ -3451,7 +3451,7 @@ void tst_QNetworkReply::connectToIPv6Address()
     if (!QtNetworkSettings::hasIPv6())
         QSKIP("system doesn't support ipv6!");
 
-    QByteArray httpResponse = QByteArray("HTTP/1.0 200 OK\r\nContent-Length: ");
+    QByteArray httpResponse = QByteArray("HTTP/1.0 200 OK\r\ncontent-length: ");
     httpResponse += QByteArray::number(dataToSend.size());
     httpResponse += "\r\n\r\n";
     httpResponse += dataToSend;
@@ -3466,7 +3466,7 @@ void tst_QNetworkReply::connectToIPv6Address()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
     QByteArray content = reply->readAll();
     //qDebug() << server.receivedData;
-    QByteArray hostinfo = "\r\nHost: " + hostfield + ':' + QByteArray::number(server.serverPort()) + "\r\n";
+    QByteArray hostinfo = "\r\nhost: " + hostfield + ':' + QByteArray::number(server.serverPort()) + "\r\n";
     QVERIFY(server.receivedData.contains(hostinfo));
     QCOMPARE(content, dataToSend);
     QCOMPARE(reply->url(), request.url());
@@ -6275,7 +6275,7 @@ void tst_QNetworkReply::httpProxyCommands()
 
     manager.setProxy(proxy);
     QNetworkRequest request(url);
-    request.setRawHeader("User-Agent", "QNetworkReplyAutoTest/1.0");
+    request.setRawHeader("user-agent", "QNetworkReplyAutoTest/1.0");
     QNetworkReplyPtr reply(manager.get(request));
 
     // wait for the finished signal
@@ -6292,10 +6292,11 @@ void tst_QNetworkReply::httpProxyCommands()
     QCOMPARE(receivedHeader, expectedCommand);
 
     //QTBUG-17223 - make sure the user agent from the request is sent to proxy server even for CONNECT
-    int uapos = proxyServer.receivedData.indexOf("User-Agent");
+    const QByteArray cUserAgent = "user-agent: ";
+    int uapos = proxyServer.receivedData.toLower().indexOf(cUserAgent) + cUserAgent.size();
     int uaend = proxyServer.receivedData.indexOf("\r\n", uapos);
     QByteArray uaheader = proxyServer.receivedData.mid(uapos, uaend - uapos);
-    QCOMPARE(uaheader, QByteArray("User-Agent: QNetworkReplyAutoTest/1.0"));
+    QCOMPARE(uaheader, QByteArray("QNetworkReplyAutoTest/1.0"));
 }
 
 class ProxyChangeHelper : public QObject
@@ -8513,7 +8514,7 @@ void tst_QNetworkReply::httpUserAgent()
 
     QVERIFY(reply->isFinished());
     QCOMPARE(reply->error(), QNetworkReply::NoError);
-    QVERIFY(server.receivedData.contains("\r\nUser-Agent: abcDEFghi\r\n"));
+    QVERIFY(server.receivedData.contains("\r\nuser-agent: abcDEFghi\r\n"));
 }
 
 void tst_QNetworkReply::synchronousAuthenticationCache()
@@ -8533,7 +8534,7 @@ void tst_QNetworkReply::synchronousAuthenticationCache()
                 "Content-Type: text/plain\r\n"
                 "\r\n"
                 "auth";
-            QRegularExpression rx("Authorization: Basic ([^\r\n]*)\r\n");
+            QRegularExpression rx("authorization: Basic ([^\r\n]*)\r\n");
             QRegularExpressionMatch match = rx.match(receivedData);
             if (match.hasMatch()) {
                 if (QByteArray::fromBase64(match.captured(1).toLatin1()) == "login:password") {
@@ -9190,7 +9191,7 @@ void tst_QNetworkReply::ioHttpCookiesDuringRedirect()
     manager.setRedirectPolicy(oldRedirectPolicy);
 
     QVERIFY(waitForFinish(reply) == Success);
-    QVERIFY(target.receivedData.contains("\r\nCookie: hello=world\r\n"));
+    QVERIFY(target.receivedData.contains("\r\ncookie: hello=world\r\n"));
     QVERIFY(validateRedirectedResponseHeaders(reply));
 }
 
@@ -10081,7 +10082,7 @@ void tst_QNetworkReply::contentEncoding()
     QNetworkRequest request(QUrl("http://localhost:" + QString::number(server.serverPort())));
     if (!decompress) {
         // This disables decompression of the received content:
-        request.setRawHeader("Accept-Encoding", QLatin1String("%1").arg(encoding).toLatin1());
+        request.setRawHeader("accept-encoding", QLatin1String("%1").arg(encoding).toLatin1());
         // This disables the zerocopy optimization
         request.setAttribute(QNetworkRequest::MaximumDownloadBufferSizeAttribute, 0);
     }
@@ -10093,7 +10094,7 @@ void tst_QNetworkReply::contentEncoding()
     {
         // Check that we included the content encoding method in our Accept-Encoding header
         const QByteArray &receivedData = server.receivedData;
-        int start = receivedData.indexOf("Accept-Encoding");
+        int start = receivedData.indexOf("accept-encoding");
         QVERIFY(start != -1);
         int end = receivedData.indexOf("\r\n", start);
         QVERIFY(end != -1);
diff --git a/tests/auto/network/access/qrestaccessmanager/httptestserver.cpp b/tests/auto/network/access/qrestaccessmanager/httptestserver.cpp
index 089342ff8b..00995920d5 100644
--- a/tests/auto/network/access/qrestaccessmanager/httptestserver.cpp
+++ b/tests/auto/network/access/qrestaccessmanager/httptestserver.cpp
@@ -67,8 +67,9 @@ void HttpTestServer::handleDataAvailable()
     Q_ASSERT(m_handler);
     Q_ASSERT(state == State::AllDone);
 
-    if (m_request.headers.contains("Host")) {
-        const auto parts = m_request.headers["Host"].split(':');
+    if (auto values = m_request.headers.values(
+                    QHttpHeaders::WellKnownHeader::Host); !values.empty()) {
+        const auto parts = values.first().split(':');
         m_request.url.setHost(parts.at(0));
         if (parts.size() == 2)
             m_request.url.setPort(parts.at(1).toUInt());
@@ -83,8 +84,9 @@ void HttpTestServer::handleDataAvailable()
     responseMessage += QByteArray::number(response.status);
     responseMessage += CRLF;
     // Insert headers if any
-    for (const auto &[name,value] : response.headers.asKeyValueRange()) {
+    for (const auto &[name,value] : response.headers.toListOfPairs()) {
         responseMessage += name;
+        responseMessage += ": ";
         responseMessage += value;
         responseMessage += CRLF;
     }
@@ -236,7 +238,7 @@ bool HttpTestServer::readHeaders(QTcpSocket *socket)
 
                 QByteArray key = fragment.sliced(0, index).trimmed();
                 QByteArray value = fragment.sliced(index + 1).trimmed();
-                m_request.headers.insert(std::move(key), std::move(value));
+                m_request.headers.append(key, value);
                 fragment.clear();
             }
         }
@@ -247,9 +249,10 @@ bool HttpTestServer::readHeaders(QTcpSocket *socket)
 bool HttpTestServer::readBody(QTcpSocket *socket)
 {
     qint64 bytesLeft = 0;
-    if (m_request.headers.contains("Content-Length")) {
+    if (auto values = m_request.headers.values(
+                QHttpHeaders::WellKnownHeader::ContentLength); !values.empty()) {
         bool conversionResult;
-        bytesLeft = m_request.headers["Content-Length"].toInt(&conversionResult);
+        bytesLeft = values.first().toInt(&conversionResult);
         if (!conversionResult)
             return false;
         fragment.resize(bytesLeft);
diff --git a/tests/auto/network/access/qrestaccessmanager/httptestserver_p.h b/tests/auto/network/access/qrestaccessmanager/httptestserver_p.h
index 1498c4bdb7..ead6590a55 100644
--- a/tests/auto/network/access/qrestaccessmanager/httptestserver_p.h
+++ b/tests/auto/network/access/qrestaccessmanager/httptestserver_p.h
@@ -5,6 +5,7 @@
 #define QRESTACCESSSMANAGER_HTTPTESTSERVER_P_H
 
 #include <QtNetwork/qtcpserver.h>
+#include <QtNetwork/qhttpheaders.h>
 
 #include <QtCore/qmap.h>
 #include <QtCore/qurl.h>
@@ -18,7 +19,7 @@ struct HttpData {
     QByteArray method;
     quint16 port = 0;
     QPair<quint8, quint8> version;
-    QMap<QByteArray, QByteArray> headers;
+    QHttpHeaders headers;
 };
 
 struct ResponseControl
diff --git a/tests/auto/network/access/qrestaccessmanager/tst_qrestaccessmanager.cpp b/tests/auto/network/access/qrestaccessmanager/tst_qrestaccessmanager.cpp
index b619f3fcd5..d1018952bd 100644
--- a/tests/auto/network/access/qrestaccessmanager/tst_qrestaccessmanager.cpp
+++ b/tests/auto/network/access/qrestaccessmanager/tst_qrestaccessmanager.cpp
@@ -22,6 +22,8 @@
 using namespace Qt::StringLiterals;
 using namespace std::chrono_literals;
 
+using Header = QHttpHeaders::WellKnownHeader;
+
 class tst_QRestAccessManager : public QObject
 {
     Q_OBJECT
@@ -533,9 +535,9 @@ void tst_QRestAccessManager::authentication()
 
     HttpData serverSideRequest;
     server.setHandler([&](HttpData request, HttpData &response, ResponseControl&) {
-        if (!request.headers.contains("Authorization"_ba)) {
+        if (!request.headers.contains(Header::Authorization)) {
             response.status = 401;
-            response.headers.insert("WWW-Authenticate: "_ba, "Basic realm=\"secret_place\""_ba);
+            response.headers.append(Header::WWWAuthenticate, "Basic realm=\"secret_place\""_ba);
         } else {
             response.status = 200;
         }
@@ -557,7 +559,9 @@ void tst_QRestAccessManager::authentication()
     QTRY_VERIFY(replyFromServer);
     // Server and QRestAM/QNAM exchange req/res twice, but finished() should be emitted just once
     QCOMPARE(finishedCount, 1);
-    QCOMPARE(serverSideRequest.headers["Authorization"_ba], "Basic YV91c2VyOmFfcGFzc3dvcmQ="_ba);
+    const auto resultHeaders = serverSideRequest.headers.values(Header::Authorization);
+    QVERIFY(!resultHeaders.empty());
+    QCOMPARE(resultHeaders.first(), "Basic YV91c2VyOmFfcGFzc3dvcmQ="_ba);
 }
 
 void tst_QRestAccessManager::userInfo()
@@ -576,9 +580,9 @@ void tst_QRestAccessManager::userInfo()
 
     HttpData serverSideRequest;
     server.setHandler([&](HttpData request, HttpData& response, ResponseControl&) {
-        if (!request.headers.contains("Authorization"_ba)) {
+        if (!request.headers.contains(Header::Authorization)) {
             response.status = 401;
-            response.headers.insert("WWW-Authenticate: "_ba, "Basic realm=\"secret_place\""_ba);
+            response.headers.append(Header::WWWAuthenticate,"Basic realm=\"secret_place\""_ba);
         } else {
             response.status = 200;
         }
@@ -589,7 +593,9 @@ void tst_QRestAccessManager::userInfo()
     QTRY_VERIFY(reply.get()->isFinished());
     QVERIFY(reply.get()->isSuccess());
     QCOMPARE(reply.get()->httpStatus(), 200);
-    QCOMPARE(serverSideRequest.headers["Authorization"_ba], "Basic YV91c2VyOmFfcGFzc3dvcmQ="_ba);
+    const auto resultHeaders = serverSideRequest.headers.values(Header::Authorization);
+    QVERIFY(!resultHeaders.empty());
+    QCOMPARE(resultHeaders.first(), "Basic YV91c2VyOmFfcGFzc3dvcmQ="_ba);
 
     // Verify that debug output does not contain password
     QString debugOutput;
@@ -864,33 +870,38 @@ void tst_QRestAccessManager::text()
     // QString from text() should match with the original (UTF-16) QString.
 
     // Successful UTF-8
-    serverSideResponse.headers.insert("Content-Type:"_ba, "text/plain; charset=UTF-8"_ba);
+    serverSideResponse.headers.append(Header::ContentType, "text/plain; charset=UTF-8"_ba);
     serverSideResponse.body = encUTF8(sourceString);
     VERIFY_TEXT_REPLY_OK;
 
     // Successful UTF-16
-    serverSideResponse.headers.insert("Content-Type:"_ba, "text/plain; charset=UTF-16"_ba);
+    serverSideResponse.headers.removeAll(Header::ContentType);
+    serverSideResponse.headers.append(Header::ContentType, "text/plain; charset=UTF-16"_ba);
     serverSideResponse.body = encUTF16(sourceString);
     VERIFY_TEXT_REPLY_OK;
 
     // Successful UTF-16, parameter case insensitivity
-    serverSideResponse.headers.insert("Content-Type:"_ba, "text/plain; chARset=uTf-16"_ba);
+    serverSideResponse.headers.removeAll(Header::ContentType);
+    serverSideResponse.headers.append(Header::ContentType, "text/plain; chARset=uTf-16"_ba);
     serverSideResponse.body = encUTF16(sourceString);
     VERIFY_TEXT_REPLY_OK;
 
     // Successful UTF-32
-    serverSideResponse.headers.insert("Content-Type:"_ba, "text/plain; charset=UTF-32"_ba);
+    serverSideResponse.headers.removeAll(Header::ContentType);
+    serverSideResponse.headers.append(Header::ContentType, "text/plain; charset=UTF-32"_ba);
     serverSideResponse.body = encUTF32(sourceString);
     VERIFY_TEXT_REPLY_OK;
 
     // Successful UTF-32 with spec-wise allowed extra content in the Content-Type header value
-    serverSideResponse.headers.insert("Content-Type:"_ba,
+    serverSideResponse.headers.removeAll(Header::ContentType);
+    serverSideResponse.headers.append(Header::ContentType,
                                       "text/plain; charset = \"UTF-32\";extraparameter=bar"_ba);
     serverSideResponse.body = encUTF32(sourceString);
     VERIFY_TEXT_REPLY_OK;
 
     // Unsuccessful UTF-32, wrong encoding indicated (indicated charset UTF-32 but data is UTF-8)
-    serverSideResponse.headers.insert("Content-Type:"_ba, "text/plain; charset=UTF-32"_ba);
+    serverSideResponse.headers.removeAll(Header::ContentType);
+    serverSideResponse.headers.append(Header::ContentType, "text/plain; charset=UTF-32"_ba);
     serverSideResponse.body = encUTF8(sourceString);
     manager.get(request, this, [&](QRestReply *reply) { replyFromServer = reply; });
     QTRY_VERIFY(replyFromServer);
@@ -900,12 +911,14 @@ void tst_QRestAccessManager::text()
     replyFromServer = nullptr;
 
     // Unsupported encoding
-    serverSideResponse.headers.insert("Content-Type:"_ba, "text/plain; charset=foo"_ba);
+    serverSideResponse.headers.removeAll(Header::ContentType);
+    serverSideResponse.headers.append(Header::ContentType, "text/plain; charset=foo"_ba);
     serverSideResponse.body = encUTF8(sourceString);
     VERIFY_TEXT_REPLY_ERROR("text(): Charset \"foo\" is not supported")
 
     // Broken UTF-8
-    serverSideResponse.headers.insert("Content-Type:"_ba, "text/plain; charset=UTF-8"_ba);
+    serverSideResponse.headers.removeAll(Header::ContentType);
+    serverSideResponse.headers.append(Header::ContentType, "text/plain; charset=UTF-8"_ba);
     serverSideResponse.body = "\xF0\x28\x8C\x28\xA0\xB0\xC0\xD0"; // invalid characters
     VERIFY_TEXT_REPLY_ERROR("text() Decoding error occurred");
 }
@@ -925,7 +938,8 @@ void tst_QRestAccessManager::textStreaming()
     ResponseControl *responseControl = nullptr;
 
     HttpData serverSideResponse; // The response data the server responds with
-    serverSideResponse.headers.insert("Content-Type:"_ba, "text/plain; charset=UTF-8"_ba);
+    serverSideResponse.headers.removeAll(Header::ContentType);
+    serverSideResponse.headers.append(Header::ContentType, "text/plain; charset=UTF-8"_ba);
     serverSideResponse.body = encUTF8(expectedData);
     serverSideResponse.status = 200;
 
@@ -983,7 +997,7 @@ void tst_QRestAccessManager::download()
     ResponseControl *responseControl = nullptr;
     serverSideResponse.status = 200;
     // Set content-length header so that underlying QNAM is able to report bytesTotal correctly
-    serverSideResponse.headers.insert("Content-Length: ",
+    serverSideResponse.headers.append(Header::ContentType,
                                        QString::number(expectedData.size()).toLatin1());
     server.setHandler([&](HttpData, HttpData &response, ResponseControl &control) {
         response = serverSideResponse;