tst_QNetworkReply: update and speed up httpConnectionCount

Because we will do a small wait after the final connection (to see
if there are any unexpected extra connections) we can save some time
by reducing _how long_ we wait for it.
In general we only need an extra long wait for the first connection,
subsequent connections are faster.
So we change the loop structure from looping until we hit 20(!)
connections, when anything larger than 6 will fail the test anyway!
And use qWaitFor instead of repeatedly calling enterLoop and checking
the state of an ElapsedTimer, the total wait time is not super
interesting, and made it a guarantee that the test would take 10
seconds.

While we are here, update the attribute we use to test HTTP/2
connections. We were previously enabling http/2, but this is the new
default so it's not needed. We do, however, need to enable h2c if we
want to see it trying to upgrade to http/2 over cleartext.

Not a big issue, so we don't pick it very far back.

Pick-to: 6.7
Change-Id: Ia314ae2827ab8a8baaa4af2c5136c5e531bcb1f8
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>

1 files changed, 28 insertions, 15 deletions

diff --git a/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp b/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
index 2ecccb0019..5df2c52c76 100644
--- a/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
+++ b/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
@@ -6528,7 +6528,6 @@ void tst_QNetworkReply::httpConnectionCount()
     }
 
     QVERIFY(server->listen());
-    QCoreApplication::instance()->processEvents();
 
     QUrl url("http://127.0.0.1:" + QString::number(server->serverPort()) + QLatin1Char('/'));
     if (encrypted)
@@ -6539,7 +6538,7 @@ void tst_QNetworkReply::httpConnectionCount()
         QUrl urlCopy = url;
         urlCopy.setPath(u'/' + QString::number(i)); // Differentiate the requests a bit
         QNetworkRequest request(urlCopy);
-        request.setAttribute(QNetworkRequest::Http2AllowedAttribute, http2Enabled);
+        request.setAttribute(QNetworkRequest::Http2CleartextAllowedAttribute, http2Enabled);
         QNetworkReply* reply = manager.get(request);
         reply->setParent(server.data());
         if (encrypted)
@@ -6547,26 +6546,40 @@ void tst_QNetworkReply::httpConnectionCount()
     }
 
     int pendingConnectionCount = 0;
-    QElapsedTimer timer;
-    timer.start();
 
-    while(pendingConnectionCount <= 20) {
-        QTestEventLoop::instance().enterLoop(1);
+    using namespace std::chrono_literals;
+    const auto newPendingConnection = [&server]() { return server->hasPendingConnections(); };
+    // If we have http2 enabled then the second connection will take a little
+    // longer to be established because we will wait for the first one to finish
+    // to see if we should upgrade:
+    const int rampDown = http2Enabled ? 2 : 1;
+    while (pendingConnectionCount <= 6) {
+        if (!QTest::qWaitFor(newPendingConnection, pendingConnectionCount >= rampDown ? 1s : 5s))
+            break;
         QTcpSocket *socket = server->nextPendingConnection();
-        while (socket != 0) {
-            if (pendingConnectionCount == 0) {
-                // respond to the first connection so we know to transition to HTTP/1.1 when using
-                // HTTP/2
-                socket->write(httpEmpty200Response);
+        while (socket) {
+            if (pendingConnectionCount == 0 && http2Enabled) {
+                // Respond to the first connection so we know to transition to HTTP/1.1 when using
+                // HTTP/2.
+                // Because of some internal state machinery we need to wait until the request has
+                // actually been written to the server before we can reply.
+                auto connection = std::make_shared<QMetaObject::Connection>();
+                auto replyOnRequest = [=, buffer = QByteArray()]() mutable {
+                    buffer += socket->readAll();
+                    if (!buffer.contains("\r\n\r\n"))
+                        return;
+                    socket->write(httpEmpty200Response);
+                    QObject::disconnect(*connection);
+                };
+                *connection = QObject::connect(socket, &QTcpSocket::readyRead, socket,
+                                               std::move(replyOnRequest));
+                if (socket->bytesAvailable()) // If we already have data, check it now
+                    emit socket->readyRead();
             }
             pendingConnectionCount++;
             socket->setParent(server.data());
             socket = server->nextPendingConnection();
         }
-
-        // at max. wait 10 sec
-        if (timer.elapsed() > 10000)
-            break;
     }
 
     QCOMPARE(pendingConnectionCount, 6);