Port from container::count() and length() to size() - V5

This is a semantic patch using ClangTidyTransformator as in
qtbase/df9d882d41b741fef7c5beeddb0abe9d904443d8, but extended to
handle typedefs and accesses through pointers, too:

    const std::string o = "object";

    auto hasTypeIgnoringPointer = [](auto type) { return anyOf(hasType(type), hasType(pointsTo(type))); };

    auto derivedFromAnyOfClasses = [&](ArrayRef<StringRef> classes) {
        auto exprOfDeclaredType = [&](auto decl) {
            return expr(hasTypeIgnoringPointer(hasUnqualifiedDesugaredType(recordType(hasDeclaration(decl))))).bind(o);
        };
        return exprOfDeclaredType(cxxRecordDecl(isSameOrDerivedFrom(hasAnyName(classes))));
    };

    auto renameMethod = [&] (ArrayRef<StringRef> classes,
                            StringRef from, StringRef to) {
        return makeRule(cxxMemberCallExpr(on(derivedFromAnyOfClasses(classes)),
                            callee(cxxMethodDecl(hasName(from), parameterCountIs(0)))),
                        changeTo(cat(access(o, cat(to)), "()")),
                        cat("use '", to, "' instead of '", from, "'"));
    };

    renameMethod(<classes>, "count", "size");
    renameMethod(<classes>, "length", "size");

except that the on() matcher has been replaced by one that doesn't
ignoreParens().

a.k.a qt-port-to-std-compatible-api V5 with config Scope: 'Container'.

Added two NOLINTNEXTLINEs in tst_qbitarray and tst_qcontiguouscache,
to avoid porting calls that explicitly test count().

Change-Id: Icfb8808c2ff4a30187e9935a51cad26987451c22
Reviewed-by: Ivan Solovev <ivan.solovev@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>

13 files changed, 336 insertions, 336 deletions

diff --git a/tests/auto/network/access/http2/tst_http2.cpp b/tests/auto/network/access/http2/tst_http2.cpp
index 5525fd7630..0702a03541 100644
--- a/tests/auto/network/access/http2/tst_http2.cpp
+++ b/tests/auto/network/access/http2/tst_http2.cpp
@@ -292,7 +292,7 @@ void tst_Http2::singleRequest()
 
 #if QT_CONFIG(ssl)
     if (connectionType == H2Type::h2Alpn || connectionType == H2Type::h2Direct)
-        QCOMPARE(encSpy.count(), 1);
+        QCOMPARE(encSpy.size(), 1);
 #endif // QT_CONFIG(ssl)
 }
 
@@ -780,7 +780,7 @@ void tst_Http2::maxFrameSize()
 
     // Normally, with a 16kb limit, our server would split such
     // a response into 3 'DATA' frames (16kb + 16kb + 0|END_STREAM).
-    QCOMPARE(frameCounter.count(), 1);
+    QCOMPARE(frameCounter.size(), 1);
 
     QVERIFY(nRequests == 0);
     QVERIFY(prefaceOK);
diff --git a/tests/auto/network/access/qabstractnetworkcache/tst_qabstractnetworkcache.cpp b/tests/auto/network/access/qabstractnetworkcache/tst_qabstractnetworkcache.cpp
index d40411ba3d..28bbf5459a 100644
--- a/tests/auto/network/access/qabstractnetworkcache/tst_qabstractnetworkcache.cpp
+++ b/tests/auto/network/access/qabstractnetworkcache/tst_qabstractnetworkcache.cpp
@@ -265,7 +265,7 @@ void tst_QAbstractNetworkCache::runTest()
     // prime the cache
     QNetworkReply *reply = manager.get(request);
     QSignalSpy downloaded1(reply, SIGNAL(finished()));
-    QTRY_COMPARE(downloaded1.count(), 1);
+    QTRY_COMPARE(downloaded1.size(), 1);
     QCOMPARE(diskCache->gotData, false);
     QByteArray goodData = reply->readAll();
 
@@ -274,7 +274,7 @@ void tst_QAbstractNetworkCache::runTest()
     // should be in the cache now
     QNetworkReply *reply2 = manager.get(request);
     QSignalSpy downloaded2(reply2, SIGNAL(finished()));
-    QTRY_COMPARE(downloaded2.count(), 1);
+    QTRY_COMPARE(downloaded2.size(), 1);
 
     QByteArray secondData = reply2->readAll();
     if (!fetchFromCache && cacheLoadControl == QNetworkRequest::AlwaysCache) {
@@ -363,7 +363,7 @@ void tst_QAbstractNetworkCache::deleteCache()
     QNetworkReply *reply = manager.get(request);
     QSignalSpy downloaded1(reply, SIGNAL(finished()));
     manager.setCache(0);
-    QTRY_COMPARE(downloaded1.count(), 1);
+    QTRY_COMPARE(downloaded1.size(), 1);
 }
 
 
diff --git a/tests/auto/network/access/qhttpnetworkreply/tst_qhttpnetworkreply.cpp b/tests/auto/network/access/qhttpnetworkreply/tst_qhttpnetworkreply.cpp
index e36acc81da..0780ae1f0e 100644
--- a/tests/auto/network/access/qhttpnetworkreply/tst_qhttpnetworkreply.cpp
+++ b/tests/auto/network/access/qhttpnetworkreply/tst_qhttpnetworkreply.cpp
@@ -77,7 +77,7 @@ void tst_QHttpNetworkReply::parseHeader()
 
     QHttpNetworkReply reply;
     reply.parseHeader(headers);
-    for (int i = 0; i < fields.count(); ++i) {
+    for (int i = 0; i < fields.size(); ++i) {
         //qDebug() << "field" << fields.at(i) << "value" << reply.headerField(fields.at(i)) << "expected" << values.at(i);
         QString field = reply.headerField(fields.at(i).toLatin1());
         QCOMPARE(field, values.at(i));
diff --git a/tests/auto/network/access/qnetworkdiskcache/tst_qnetworkdiskcache.cpp b/tests/auto/network/access/qnetworkdiskcache/tst_qnetworkdiskcache.cpp
index 5f4a513a28..64a569e9fa 100644
--- a/tests/auto/network/access/qnetworkdiskcache/tst_qnetworkdiskcache.cpp
+++ b/tests/auto/network/access/qnetworkdiskcache/tst_qnetworkdiskcache.cpp
@@ -278,17 +278,17 @@ void tst_QNetworkDiskCache::clear()
     QVERIFY(cache.cacheSize() > qint64(0));
 
     QString cacheDirectory = cache.cacheDirectory();
-    QCOMPARE(countFiles(cacheDirectory).count(), NUM_SUBDIRECTORIES + 3);
+    QCOMPARE(countFiles(cacheDirectory).size(), NUM_SUBDIRECTORIES + 3);
     cache.clear();
-    QCOMPARE(countFiles(cacheDirectory).count(), NUM_SUBDIRECTORIES + 2);
+    QCOMPARE(countFiles(cacheDirectory).size(), NUM_SUBDIRECTORIES + 2);
 
     // don't delete files that it didn't create
     QTemporaryFile file(cacheDirectory + "/XXXXXX");
     if (file.open()) {
         file.fileName();    // make sure it exists with a name
-        QCOMPARE(countFiles(cacheDirectory).count(), NUM_SUBDIRECTORIES + 3);
+        QCOMPARE(countFiles(cacheDirectory).size(), NUM_SUBDIRECTORIES + 3);
         cache.clear();
-        QCOMPARE(countFiles(cacheDirectory).count(), NUM_SUBDIRECTORIES + 3);
+        QCOMPARE(countFiles(cacheDirectory).size(), NUM_SUBDIRECTORIES + 3);
     }
 }
 
@@ -355,9 +355,9 @@ void tst_QNetworkDiskCache::remove()
     QUrl url(EXAMPLE_URL);
     cache.setupWithOne(tempDir.path(), url);
     QString cacheDirectory = cache.cacheDirectory();
-    QCOMPARE(countFiles(cacheDirectory).count(), NUM_SUBDIRECTORIES + 3);
+    QCOMPARE(countFiles(cacheDirectory).size(), NUM_SUBDIRECTORIES + 3);
     cache.remove(url);
-    QCOMPARE(countFiles(cacheDirectory).count(), NUM_SUBDIRECTORIES + 2);
+    QCOMPARE(countFiles(cacheDirectory).size(), NUM_SUBDIRECTORIES + 2);
 }
 
 void tst_QNetworkDiskCache::accessAfterRemove() // QTBUG-17400
@@ -477,7 +477,7 @@ void tst_QNetworkDiskCache::fileMetaData()
 
     QString cacheDirectory = cache.cacheDirectory();
     QStringList list = countFiles(cacheDirectory);
-    QCOMPARE(list.count(), NUM_SUBDIRECTORIES + 3);
+    QCOMPARE(list.size(), NUM_SUBDIRECTORIES + 3);
     foreach(QString fileName, list) {
         QFileInfo info(fileName);
         if (info.isFile()) {
@@ -531,7 +531,7 @@ void tst_QNetworkDiskCache::expire()
         }
     }
     std::sort(cacheList.begin(), cacheList.end());
-    for (int i = 0; i < cacheList.count(); ++i) {
+    for (int i = 0; i < cacheList.size(); ++i) {
         QString fileName = cacheList[i];
         QCOMPARE(fileName, QLatin1String("http://localhost:4/") + QString::number(i + 6));
     }
@@ -570,7 +570,7 @@ void tst_QNetworkDiskCache::oldCacheVersionFile()
         QVERIFY(!QFile::exists(name));
     } else {
         QStringList files = countFiles(cache.cacheDirectory());
-        QCOMPARE(files.count(), NUM_SUBDIRECTORIES + 3);
+        QCOMPARE(files.size(), NUM_SUBDIRECTORIES + 3);
         // find the file
         QString cacheFile;
         foreach (QString file, files) {
diff --git a/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp b/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
index 78a3bb51aa..ea8e31c5e6 100644
--- a/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
+++ b/tests/auto/network/access/qnetworkreply/tst_qnetworkreply.cpp
@@ -1460,11 +1460,11 @@ QString tst_QNetworkReply::runSimpleRequest(QNetworkAccessManager::Operation op,
         while (!reply->isFinished()) {
             QTimer::singleShot(20000, loop, SLOT(quit()));
             code = loop->exec();
-            if (count == spy.count() && !reply->isFinished()) {
+            if (count == spy.size() && !reply->isFinished()) {
                 code = Timeout;
                 break;
             }
-            count = spy.count();
+            count = spy.size();
         }
         delete loop;
         loop = 0;
@@ -1530,11 +1530,11 @@ int tst_QNetworkReply::waitForFinish(QNetworkReplyPtr &reply)
     QSignalSpy spy(reply.data(), SIGNAL(downloadProgress(qint64,qint64)));
     while (!reply->isFinished()) {
         QTimer::singleShot(5000, loop, SLOT(quit()));
-        if (loop->exec() == Timeout && count == spy.count() && !reply->isFinished()) {
+        if (loop->exec() == Timeout && count == spy.size() && !reply->isFinished()) {
             returnCode = Timeout;
             break;
         }
-        count = spy.count();
+        count = spy.size();
     }
     delete loop;
     loop = 0;
@@ -2277,9 +2277,9 @@ void tst_QNetworkReply::putToFtp()
     QSignalSpy spy(r, SIGNAL(downloadProgress(qint64,qint64)));
     while (!r->isFinished()) {
         QTestEventLoop::instance().enterLoop(10);
-        if (count == spy.count() && !r->isFinished())
+        if (count == spy.size() && !r->isFinished())
             break;
-        count = spy.count();
+        count = spy.size();
     }
     QObject::disconnect(r, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
 
@@ -3589,7 +3589,7 @@ void tst_QNetworkReply::ioGetFromHttpWithAuth()
         QCOMPARE(reader1.data, expectedData);
         QCOMPARE(reader2.data, expectedData);
 
-        QCOMPARE(authspy.count(), (expectedAuth ? 1 : 0));
+        QCOMPARE(authspy.size(), (expectedAuth ? 1 : 0));
         expectedAuth = qMax(0, expectedAuth - 1);
     }
 
@@ -3610,7 +3610,7 @@ void tst_QNetworkReply::ioGetFromHttpWithAuth()
         QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
         QCOMPARE(reader.data, expectedData);
 
-        QCOMPARE(authspy.count(), (expectedAuth ? 1 : 0));
+        QCOMPARE(authspy.size(), (expectedAuth ? 1 : 0));
         expectedAuth = qMax(0, expectedAuth - 1);
     }
 
@@ -3627,7 +3627,7 @@ void tst_QNetworkReply::ioGetFromHttpWithAuth()
             // bad credentials in a synchronous request should just fail
             QCOMPARE(replySync->error(), QNetworkReply::AuthenticationRequiredError);
         } else {
-            QCOMPARE(authspy.count(), 0);
+            QCOMPARE(authspy.size(), 0);
 
             // we cannot use a data reader here, since that connects to the readyRead signal,
             // just use readAll()
@@ -3653,7 +3653,7 @@ void tst_QNetworkReply::ioGetFromHttpWithAuth()
             // bad credentials in a synchronous request should just fail
             QCOMPARE(replySync->error(), QNetworkReply::AuthenticationRequiredError);
         } else {
-            QCOMPARE(authspy.count(), 0);
+            QCOMPARE(authspy.size(), 0);
 
             // we cannot use a data reader here, since that connects to the readyRead signal,
             // just use readAll()
@@ -3679,7 +3679,7 @@ void tst_QNetworkReply::ioGetFromHttpWithAuthSynchronous()
     QNetworkReplyPtr replySync(manager.get(request));
     QVERIFY(replySync->isFinished()); // synchronous
     QCOMPARE(replySync->error(), QNetworkReply::AuthenticationRequiredError);
-    QCOMPARE(authspy.count(), 0);
+    QCOMPARE(authspy.size(), 0);
     QCOMPARE(replySync->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 401);
 }
 
@@ -3720,7 +3720,7 @@ void tst_QNetworkReply::ioGetFromHttpWithProxyAuth()
         QCOMPARE(reader1.data, referenceData);
         QCOMPARE(reader2.data, referenceData);
 
-        QCOMPARE(authspy.count(), 1);
+        QCOMPARE(authspy.size(), 1);
     }
 
     reference.seek(0);
@@ -3743,7 +3743,7 @@ void tst_QNetworkReply::ioGetFromHttpWithProxyAuth()
         QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
         QCOMPARE(reader.data, reference.readAll());
 
-        QCOMPARE(authspy.count(), 0);
+        QCOMPARE(authspy.size(), 0);
     }
 
     // now check with synchronous calls:
@@ -3756,7 +3756,7 @@ void tst_QNetworkReply::ioGetFromHttpWithProxyAuth()
         QSignalSpy authspy(&manager, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));
         QNetworkReplyPtr replySync(manager.get(request));
         QVERIFY(replySync->isFinished()); // synchronous
-        QCOMPARE(authspy.count(), 0);
+        QCOMPARE(authspy.size(), 0);
 
         // we cannot use a data reader here, since that connects to the readyRead signal,
         // just use readAll()
@@ -3784,7 +3784,7 @@ void tst_QNetworkReply::ioGetFromHttpWithProxyAuthSynchronous()
     manager.setProxy(QNetworkProxy()); // reset
     QVERIFY(replySync->isFinished()); // synchronous
     QCOMPARE(replySync->error(), QNetworkReply::ProxyAuthenticationRequiredError);
-    QCOMPARE(authspy.count(), 0);
+    QCOMPARE(authspy.size(), 0);
     QCOMPARE(replySync->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 407);
 }
 
@@ -3816,7 +3816,7 @@ void tst_QNetworkReply::ioGetFromHttpWithSocksProxy()
         QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
         QCOMPARE(reader.data, reference.readAll());
 
-        QCOMPARE(authspy.count(), 0);
+        QCOMPARE(authspy.size(), 0);
     }
 
     // set an invalid proxy just to make sure that we can't load
@@ -3843,7 +3843,7 @@ void tst_QNetworkReply::ioGetFromHttpWithSocksProxy()
         QEXPECT_FAIL("", "QTcpSocket doesn't return enough information yet", Continue);
         QCOMPARE(int(reply->error()), int(QNetworkReply::ProxyConnectionRefusedError));
 
-        QCOMPARE(authspy.count(), 0);
+        QCOMPARE(authspy.size(), 0);
     }
 }
 #endif // QT_CONFIG(networkproxy)
@@ -3871,7 +3871,7 @@ void tst_QNetworkReply::ioGetFromHttpsWithSslErrors()
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
     QCOMPARE(reader.data, reference.readAll());
 
-    QCOMPARE(sslspy.count(), 1);
+    QCOMPARE(sslspy.size(), 1);
 
     QVERIFY(!storedSslConfiguration.isNull());
     QVERIFY(!reply->sslConfiguration().isNull());
@@ -3899,7 +3899,7 @@ void tst_QNetworkReply::ioGetFromHttpsWithIgnoreSslErrors()
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), 200);
     QCOMPARE(reader.data, reference.readAll());
 
-    QCOMPARE(sslspy.count(), 1);
+    QCOMPARE(sslspy.size(), 1);
 
     QVERIFY(!storedSslConfiguration.isNull());
     QVERIFY(!reply->sslConfiguration().isNull());
@@ -3922,7 +3922,7 @@ void tst_QNetworkReply::ioGetFromHttpsWithSslHandshakeError()
     QCOMPARE(waitForFinish(reply), int(Failure));
 
     QCOMPARE(reply->error(), QNetworkReply::SslHandshakeFailedError);
-    QCOMPARE(sslspy.count(), 0);
+    QCOMPARE(sslspy.size(), 0);
 }
 #endif
 
@@ -3980,7 +3980,7 @@ void tst_QNetworkReply::ioGetFromHttpBrokenServer()
     QCOMPARE(waitForFinish(reply), int(Failure));
 
     QCOMPARE(reply->url(), request.url());
-    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.size(), 1);
     QVERIFY(reply->error() != QNetworkReply::NoError);
 }
 
@@ -4498,16 +4498,16 @@ void tst_QNetworkReply::ioGetWithManyProxies()
         // now verify that the proxies worked:
         QFETCH(QNetworkProxy, proxyUsed);
         if (proxyUsed.type() == QNetworkProxy::NoProxy) {
-            QCOMPARE(authspy.count(), 0);
+            QCOMPARE(authspy.size(), 0);
         } else {
             if (QByteArray(QTest::currentDataTag()).startsWith("ftp-"))
                 return;         // No authentication with current FTP or with FTP proxies
-            QCOMPARE(authspy.count(), 1);
+            QCOMPARE(authspy.size(), 1);
             QCOMPARE(qvariant_cast<QNetworkProxy>(authspy.at(0).at(0)), proxyUsed);
         }
     } else {
         // request failed
-        QCOMPARE(authspy.count(), 0);
+        QCOMPARE(authspy.size(), 0);
     }
 }
 #endif // QT_CONFIG(networkproxy)
@@ -4891,8 +4891,8 @@ void tst_QNetworkReply::ioPostToHttpFromSocket()
 
     QCOMPARE(reply->readAll().trimmed(), md5sum(data).toHex());
 
-    QTEST(int(authenticationRequiredSpy.count()), "authenticationRequiredCount");
-    QTEST(int(proxyAuthenticationRequiredSpy.count()), "proxyAuthenticationRequiredCount");
+    QTEST(int(authenticationRequiredSpy.size()), "authenticationRequiredCount");
+    QTEST(int(proxyAuthenticationRequiredSpy.size()), "proxyAuthenticationRequiredCount");
 }
 
 void tst_QNetworkReply::ioPostToHttpFromSocketSynchronous_data()
@@ -5391,7 +5391,7 @@ void tst_QNetworkReply::emitAllUploadProgressSignals()
         QVERIFY(!QTestEventLoop::instance().timeout());
 
         incomingSocket->close();
-        signalCount.append(spy.count());
+        signalCount.append(spy.size());
         reply->deleteLater();
     }
     server.close();
@@ -5437,7 +5437,7 @@ void tst_QNetworkReply::ioPostToHttpEmptyUploadProgress()
     QVERIFY(!QTestEventLoop::instance().timeout());
 
     // final check: only 1 uploadProgress has been emitted
-    QCOMPARE(spy.length(), 1);
+    QCOMPARE(spy.size(), 1);
     QList<QVariant> args = spy.last();
     QVERIFY(!args.isEmpty());
     QCOMPARE(args.at(0).toLongLong(), buffer.size());
@@ -5608,7 +5608,7 @@ void tst_QNetworkReply::downloadProgress()
     QVERIFY(!QTestEventLoop::instance().timeout());
     QVERIFY(reply->isFinished());
 
-    QVERIFY(spy.count() > 0);
+    QVERIFY(spy.size() > 0);
 
     //final progress should have equal current & total
     QList<QVariant> args = spy.takeLast();
@@ -5654,14 +5654,14 @@ void tst_QNetworkReply::uploadProgress()
     QVERIFY(server.hasPendingConnections());
 
     QTcpSocket *receiver = server.nextPendingConnection();
-    if (finished.count() == 0) {
+    if (finished.size() == 0) {
         // it's not finished yet, so wait for it to be
         QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
     }
     delete receiver;
 
-    QVERIFY(finished.count() > 0);
-    QVERIFY(spy.count() > 0);
+    QVERIFY(finished.size() > 0);
+    QVERIFY(spy.size() > 0);
 
     QList<QVariant> args = spy.last();
     QCOMPARE(args.at(0).toInt(), data.size());
@@ -5943,8 +5943,8 @@ void tst_QNetworkReply::nestedEventLoops()
     QTestEventLoop::instance().enterLoop(20);
     QVERIFY2(!QTestEventLoop::instance().timeout(), "Network timeout");
 
-    QCOMPARE(finishedspy.count(), 1);
-    QCOMPARE(errorspy.count(), 0);
+    QCOMPARE(finishedspy.size(), 1);
+    QCOMPARE(errorspy.size(), 0);
 }
 
 #if QT_CONFIG(networkproxy)
@@ -6171,9 +6171,9 @@ void tst_QNetworkReply::authorizationError()
     QCOMPARE(waitForFinish(reply), int(Failure));
 
     QFETCH(int, errorSignalCount);
-    QCOMPARE(errorSpy.count(), errorSignalCount);
+    QCOMPARE(errorSpy.size(), errorSignalCount);
     QFETCH(int, finishedSignalCount);
-    QCOMPARE(finishedSpy.count(), finishedSignalCount);
+    QCOMPARE(finishedSpy.size(), finishedSignalCount);
     QFETCH(int, error);
     QCOMPARE(reply->error(), QNetworkReply::NetworkError(error));
 
@@ -6532,7 +6532,7 @@ void tst_QNetworkReply::encrypted()
     QTestEventLoop::instance().enterLoop(20);
     QVERIFY(!QTestEventLoop::instance().timeout());
 
-    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.size(), 1);
 
     reply->deleteLater();
 }
@@ -6561,7 +6561,7 @@ void tst_QNetworkReply::abortOnEncrypted()
         });
 
     QSignalSpy spyEncrypted(reply, &QNetworkReply::encrypted);
-    QTRY_COMPARE(spyEncrypted.count(), 1);
+    QTRY_COMPARE(spyEncrypted.size(), 1);
 
     // Wait for the socket to be closed again in order to be sure QTcpSocket::readyRead would have been emitted.
     QTRY_VERIFY(server.socket != nullptr);
@@ -7144,9 +7144,9 @@ void tst_QNetworkReply::qtbug4121unknownAuthentication()
     QTestEventLoop::instance().enterLoop(10);
     QVERIFY(!QTestEventLoop::instance().timeout());
 
-    QCOMPARE(authSpy.count(), 0);
-    QCOMPARE(finishedSpy.count(), 1);
-    QCOMPARE(errorSpy.count(), 1);
+    QCOMPARE(authSpy.size(), 0);
+    QCOMPARE(finishedSpy.size(), 1);
+    QCOMPARE(errorSpy.size(), 1);
 
     QCOMPARE(reply->error(), QNetworkReply::AuthenticationRequiredError);
 }
@@ -7240,8 +7240,8 @@ void tst_QNetworkReply::authenticationCacheAfterCancel()
         QVERIFY(!QTestEventLoop::instance().timeout());
 
         QCOMPARE(reply->error(), QNetworkReply::ProxyAuthenticationRequiredError);
-        QCOMPARE(authSpy.count(), 0);
-        QCOMPARE(proxyAuthSpy.count(), 1);
+        QCOMPARE(authSpy.size(), 0);
+        QCOMPARE(proxyAuthSpy.size(), 1);
         proxyAuthSpy.clear();
 
         //should fail due to bad credentials
@@ -7255,8 +7255,8 @@ void tst_QNetworkReply::authenticationCacheAfterCancel()
         // Work round known quirk in the old test server (danted -v < v1.1.19):
         if (reply->error() != QNetworkReply::HostNotFoundError)
             QCOMPARE(reply->error(), QNetworkReply::ProxyAuthenticationRequiredError);
-        QCOMPARE(authSpy.count(), 0);
-        QVERIFY(proxyAuthSpy.count() > 0);
+        QCOMPARE(authSpy.size(), 0);
+        QVERIFY(proxyAuthSpy.size() > 0);
         proxyAuthSpy.clear();
 
         // QTBUG-23136 workaround (needed even with danted v1.1.19):
@@ -7281,10 +7281,10 @@ void tst_QNetworkReply::authenticationCacheAfterCancel()
     QVERIFY(!QTestEventLoop::instance().timeout());
 
     QCOMPARE(reply->error(), QNetworkReply::AuthenticationRequiredError);
-    QVERIFY(authSpy.count() > 0);
+    QVERIFY(authSpy.size() > 0);
     authSpy.clear();
     if (proxyAuth) {
-        QVERIFY(proxyAuthSpy.count() > 0);
+        QVERIFY(proxyAuthSpy.size() > 0);
         proxyAuthSpy.clear();
     }
 
@@ -7297,11 +7297,11 @@ void tst_QNetworkReply::authenticationCacheAfterCancel()
     QVERIFY(!QTestEventLoop::instance().timeout());
 
     QCOMPARE(reply->error(), QNetworkReply::AuthenticationRequiredError);
-    QVERIFY(authSpy.count() > 0);
+    QVERIFY(authSpy.size() > 0);
     authSpy.clear();
     if (proxyAuth) {
         //should be supplied from cache
-        QCOMPARE(proxyAuthSpy.count(), 0);
+        QCOMPARE(proxyAuthSpy.size(), 0);
         proxyAuthSpy.clear();
     }
 
@@ -7315,11 +7315,11 @@ void tst_QNetworkReply::authenticationCacheAfterCancel()
     QVERIFY(!QTestEventLoop::instance().timeout());
 
     QCOMPARE(reply->error(), QNetworkReply::NoError);
-    QVERIFY(authSpy.count() > 0);
+    QVERIFY(authSpy.size() > 0);
     authSpy.clear();
     if (proxyAuth) {
         //should be supplied from cache
-        QCOMPARE(proxyAuthSpy.count(), 0);
+        QCOMPARE(proxyAuthSpy.size(), 0);
         proxyAuthSpy.clear();
     }
 
@@ -7331,11 +7331,11 @@ void tst_QNetworkReply::authenticationCacheAfterCancel()
 
     QCOMPARE(reply->error(), QNetworkReply::NoError);
     //should be supplied from cache
-    QCOMPARE(authSpy.count(), 0);
+    QCOMPARE(authSpy.size(), 0);
     authSpy.clear();
     if (proxyAuth) {
         //should be supplied from cache
-        QCOMPARE(proxyAuthSpy.count(), 0);
+        QCOMPARE(proxyAuthSpy.size(), 0);
         proxyAuthSpy.clear();
     }
 
@@ -7437,8 +7437,8 @@ void tst_QNetworkReply::httpWithNoCredentialUsage()
         QNetworkReplyPtr reply(manager.get(request));
         QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
         // credentials in URL, so don't expect authentication signal
-        QCOMPARE(authSpy.count(), 0);
-        QCOMPARE(finishedSpy.count(), 1);
+        QCOMPARE(authSpy.size(), 0);
+        QCOMPARE(finishedSpy.size(), 1);
         finishedSpy.clear();
     }
 
@@ -7448,8 +7448,8 @@ void tst_QNetworkReply::httpWithNoCredentialUsage()
         QNetworkReplyPtr reply(manager.get(request));
         QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
         // credentials in cache, so don't expect authentication signal
-        QCOMPARE(authSpy.count(), 0);
-        QCOMPARE(finishedSpy.count(), 1);
+        QCOMPARE(authSpy.size(), 0);
+        QCOMPARE(finishedSpy.size(), 1);
         finishedSpy.clear();
     }
 
@@ -7466,9 +7466,9 @@ void tst_QNetworkReply::httpWithNoCredentialUsage()
         QVERIFY(!QTestEventLoop::instance().timeout());
 
         // We check if authenticationRequired was emitted, however we do not anything in it so it should be 401
-        QCOMPARE(authSpy.count(), 1);
-        QCOMPARE(finishedSpy.count(), 1);
-        QCOMPARE(errorSpy.count(), 1);
+        QCOMPARE(authSpy.size(), 1);
+        QCOMPARE(finishedSpy.size(), 1);
+        QCOMPARE(errorSpy.size(), 1);
 
         QCOMPARE(reply->error(), QNetworkReply::AuthenticationRequiredError);
     }
@@ -7753,8 +7753,8 @@ void tst_QNetworkReply::qtbug45581WrongReplyStatusCode()
 
     QCOMPARE(reply->readAll(), expectedContent);
 
-    QCOMPARE(finishedSpy.count(), 0);
-    QCOMPARE(sslErrorsSpy.count(), 0);
+    QCOMPARE(finishedSpy.size(), 0);
+    QCOMPARE(sslErrorsSpy.size(), 0);
 
     QCOMPARE(reply->header(QNetworkRequest::ContentLengthHeader).toLongLong(), expectedContent.size());
 
@@ -7843,8 +7843,8 @@ void tst_QNetworkReply::synchronousRequest()
     QSignalSpy sslErrorsSpy(&manager, SIGNAL(sslErrors(QNetworkReply*,QList<QSslError>)));
     RUN_REQUEST(runSimpleRequest(QNetworkAccessManager::GetOperation, request, reply, 0));
     QVERIFY(reply->isFinished());
-    QCOMPARE(finishedSpy.count(), 0);
-    QCOMPARE(sslErrorsSpy.count(), 0);
+    QCOMPARE(finishedSpy.size(), 0);
+    QCOMPARE(sslErrorsSpy.size(), 0);
 
     QCOMPARE(reply->header(QNetworkRequest::ContentTypeHeader).toString(), mimeType);
 
@@ -7883,7 +7883,7 @@ void tst_QNetworkReply::synchronousRequestSslFailure()
     runSimpleRequest(QNetworkAccessManager::GetOperation, request, reply, 0);
     QVERIFY(reply->isFinished());
     QCOMPARE(reply->error(), QNetworkReply::SslHandshakeFailedError);
-    QCOMPARE(sslErrorsSpy.count(), 0);
+    QCOMPARE(sslErrorsSpy.size(), 0);
 }
 #endif
 
@@ -8347,9 +8347,9 @@ void tst_QNetworkReply::emitErrorForAllReplies() // QTBUG-36890
     QVERIFY(!QTestEventLoop::instance().timeout());
     for (int a = 0; a < urls.size(); ++a) {
         QVERIFY(replies.at(a)->isFinished());
-        QCOMPARE(errorSpies.at(a)->count(), 1);
+        QCOMPARE(errorSpies.at(a)->size(), 1);
         errorSpies.at(a)->deleteLater();
-        QCOMPARE(finishedSpies.at(a)->count(), 1);
+        QCOMPARE(finishedSpies.at(a)->size(), 1);
         finishedSpies.at(a)->deleteLater();
         replies.at(a)->deleteLater();
     }
@@ -8469,8 +8469,8 @@ void tst_QNetworkReply::ioHttpSingleRedirect()
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
 
     // Redirected and finished should be emitted exactly once
-    QCOMPARE(redSpy.count(), 1);
-    QCOMPARE(finSpy.count(), 1);
+    QCOMPARE(redSpy.size(), 1);
+    QCOMPARE(finSpy.size(), 1);
 
     // Original URL should not be changed after redirect
     QCOMPARE(request.url(), localhost);
@@ -8516,8 +8516,8 @@ void tst_QNetworkReply::ioHttpChangeMaxRedirects()
 
     QCOMPARE(waitForFinish(reply), int(Failure));
 
-    QCOMPARE(redSpy.count(), request.maximumRedirectsAllowed());
-    QCOMPARE(spy.count(), 1);
+    QCOMPARE(redSpy.size(), request.maximumRedirectsAllowed());
+    QCOMPARE(spy.size(), 1);
     QCOMPARE(reply->error(), QNetworkReply::TooManyRedirectsError);
 
     // Increase max redirects to allow successful completion
@@ -8528,7 +8528,7 @@ void tst_QNetworkReply::ioHttpChangeMaxRedirects()
 
     QVERIFY2(waitForFinish(reply2) == Success, msgWaitForFinished(reply2));
 
-    QCOMPARE(redSpy2.count(), 2);
+    QCOMPARE(redSpy2.size(), 2);
     QCOMPARE(reply2->url(), server3Url);
     QCOMPARE(reply2->error(), QNetworkReply::NoError);
     QVERIFY(validateRedirectedResponseHeaders(reply2));
@@ -8661,8 +8661,8 @@ void tst_QNetworkReply::ioHttpRedirectPolicy()
     QSignalSpy redirectSpy(reply.data(), SIGNAL(redirected(QUrl)));
     QSignalSpy finishedSpy(reply.data(), SIGNAL(finished()));
     QVERIFY2(waitForFinish(reply) == Success, msgWaitForFinished(reply));
-    QCOMPARE(finishedSpy.count(), 1);
-    QCOMPARE(redirectSpy.count(), redirectCount);
+    QCOMPARE(finishedSpy.size(), 1);
+    QCOMPARE(redirectSpy.size(), redirectCount);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), statusCode);
     QVERIFY(validateRedirectedResponseHeaders(reply) || statusCode != 200);
 }
@@ -8745,7 +8745,7 @@ void tst_QNetworkReply::ioHttpRedirectPolicyErrors()
     QSignalSpy spy(reply.data(), SIGNAL(errorOccurred(QNetworkReply::NetworkError)));
 
     QCOMPARE(waitForFinish(reply), int(Failure));
-    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.size(), 1);
     QCOMPARE(reply->error(), expectedError);
 }
 
@@ -8795,7 +8795,7 @@ void tst_QNetworkReply::ioHttpUserVerifiedRedirect()
 
     QSignalSpy finishedSpy(reply.data(), SIGNAL(finished()));
     waitForFinish(reply);
-    QCOMPARE(finishedSpy.count(), 1);
+    QCOMPARE(finishedSpy.size(), 1);
     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), statusCode);
     QVERIFY(validateRedirectedResponseHeaders(reply) || statusCode != 200);
 }
@@ -9386,7 +9386,7 @@ void tst_QNetworkReply::autoDeleteRepliesAttribute()
         QSignalSpy finishedSpy(reply, &QNetworkReply::finished);
         QSignalSpy destroyedSpy(reply, &QObject::destroyed);
         QVERIFY(finishedSpy.wait());
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
         QVERIFY(destroyedSpy.wait());
     }
     {
@@ -9397,7 +9397,7 @@ void tst_QNetworkReply::autoDeleteRepliesAttribute()
         QSignalSpy finishedSpy(reply, &QNetworkReply::finished);
         QSignalSpy destroyedSpy(reply, &QObject::destroyed);
         QVERIFY(finishedSpy.wait());
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
         QVERIFY(destroyedSpy.wait());
     }
     // Now repeated, but without the attribute to make sure it does not get deleted automatically.
@@ -9411,10 +9411,10 @@ void tst_QNetworkReply::autoDeleteRepliesAttribute()
         QSignalSpy finishedSpy(reply.data(), &QNetworkReply::finished);
         QSignalSpy destroyedSpy(reply.data(), &QObject::destroyed);
         QVERIFY(finishedSpy.wait());
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
         QCoreApplication::processEvents();
         QCoreApplication::processEvents();
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
     }
     {
         // Post
@@ -9423,10 +9423,10 @@ void tst_QNetworkReply::autoDeleteRepliesAttribute()
         QSignalSpy finishedSpy(reply.data(), &QNetworkReply::finished);
         QSignalSpy destroyedSpy(reply.data(), &QObject::destroyed);
         QVERIFY(finishedSpy.wait());
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
         QCoreApplication::processEvents();
         QCoreApplication::processEvents();
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
     }
 }
 
@@ -9447,7 +9447,7 @@ void tst_QNetworkReply::autoDeleteReplies()
         QSignalSpy finishedSpy(reply, &QNetworkReply::finished);
         QSignalSpy destroyedSpy(reply, &QObject::destroyed);
         QVERIFY(finishedSpy.wait());
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
         QVERIFY(destroyedSpy.wait());
     }
     {
@@ -9457,7 +9457,7 @@ void tst_QNetworkReply::autoDeleteReplies()
         QSignalSpy finishedSpy(reply, &QNetworkReply::finished);
         QSignalSpy destroyedSpy(reply, &QObject::destroyed);
         QVERIFY(finishedSpy.wait());
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
         QVERIFY(destroyedSpy.wait());
     }
     // Here we repeat the test, but override the auto-deletion in the QNetworkRequest
@@ -9472,10 +9472,10 @@ void tst_QNetworkReply::autoDeleteReplies()
         QSignalSpy finishedSpy(reply.data(), &QNetworkReply::finished);
         QSignalSpy destroyedSpy(reply.data(), &QObject::destroyed);
         QVERIFY(finishedSpy.wait());
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
         QCoreApplication::processEvents();
         QCoreApplication::processEvents();
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
     }
     {
         // Post
@@ -9485,10 +9485,10 @@ void tst_QNetworkReply::autoDeleteReplies()
         QSignalSpy finishedSpy(reply.data(), &QNetworkReply::finished);
         QSignalSpy destroyedSpy(reply.data(), &QObject::destroyed);
         QVERIFY(finishedSpy.wait());
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
         QCoreApplication::processEvents();
         QCoreApplication::processEvents();
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
     }
     // Now we repeat the test with autoDeleteReplies set to false
     cleanup.dismiss();
@@ -9500,10 +9500,10 @@ void tst_QNetworkReply::autoDeleteReplies()
         QSignalSpy finishedSpy(reply.data(), &QNetworkReply::finished);
         QSignalSpy destroyedSpy(reply.data(), &QObject::destroyed);
         QVERIFY(finishedSpy.wait());
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
         QCoreApplication::processEvents();
         QCoreApplication::processEvents();
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
     }
     {
         // Post
@@ -9512,10 +9512,10 @@ void tst_QNetworkReply::autoDeleteReplies()
         QSignalSpy finishedSpy(reply.data(), &QNetworkReply::finished);
         QSignalSpy destroyedSpy(reply.data(), &QObject::destroyed);
         QVERIFY(finishedSpy.wait());
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
         QCoreApplication::processEvents();
         QCoreApplication::processEvents();
-        QCOMPARE(destroyedSpy.count(), 0);
+        QCOMPARE(destroyedSpy.size(), 0);
     }
 }
 
@@ -9529,7 +9529,7 @@ void tst_QNetworkReply::getWithTimeout()
 
     QCOMPARE(waitForFinish(reply), int(Success));
 
-    QCOMPARE(spy.count(), 0);
+    QCOMPARE(spy.size(), 0);
     QVERIFY(reply->error() == QNetworkReply::NoError);
 
     request.setTransferTimeout(1000);
@@ -9540,7 +9540,7 @@ void tst_QNetworkReply::getWithTimeout()
 
     QCOMPARE(waitForFinish(reply2), int(Failure));
 
-    QCOMPARE(spy2.count(), 1);
+    QCOMPARE(spy2.size(), 1);
     QVERIFY(reply2->error() == QNetworkReply::OperationCanceledError);
 
     request.setTransferTimeout(0);
@@ -9551,7 +9551,7 @@ void tst_QNetworkReply::getWithTimeout()
 
     QCOMPARE(waitForFinish(reply3), int(Failure));
 
-    QCOMPARE(spy3.count(), 1);
+    QCOMPARE(spy3.size(), 1);
     QVERIFY(reply3->error() == QNetworkReply::OperationCanceledError);
 
     manager.setTransferTimeout(0);
@@ -9569,7 +9569,7 @@ void tst_QNetworkReply::postWithTimeout()
 
     QCOMPARE(waitForFinish(reply), int(Success));
 
-    QCOMPARE(spy.count(), 0);
+    QCOMPARE(spy.size(), 0);
     QVERIFY(reply->error() == QNetworkReply::NoError);
 
     request.setTransferTimeout(1000);
@@ -9580,7 +9580,7 @@ void tst_QNetworkReply::postWithTimeout()
 
     QCOMPARE(waitForFinish(reply2), int(Failure));
 
-    QCOMPARE(spy2.count(), 1);
+    QCOMPARE(spy2.size(), 1);
     QVERIFY(reply2->error() == QNetworkReply::OperationCanceledError);
 
     request.setTransferTimeout(0);
@@ -9591,7 +9591,7 @@ void tst_QNetworkReply::postWithTimeout()
 
     QCOMPARE(waitForFinish(reply3), int(Failure));
 
-    QCOMPARE(spy3.count(), 1);
+    QCOMPARE(spy3.size(), 1);
     QVERIFY(reply3->error() == QNetworkReply::OperationCanceledError);
 
     manager.setTransferTimeout(0);
@@ -9636,13 +9636,13 @@ void tst_QNetworkReply::moreActivitySignals()
     QSignalSpy spy3(reply.data(), SIGNAL(metaDataChanged()));
     QSignalSpy spy4(reply.data(), SIGNAL(finished()));
     spy1.wait();
-    QCOMPARE(spy1.count(), 1);
+    QCOMPARE(spy1.size(), 1);
     spy2.wait();
-    QCOMPARE(spy2.count(), 1);
+    QCOMPARE(spy2.size(), 1);
     spy3.wait();
-    QCOMPARE(spy3.count(), 1);
+    QCOMPARE(spy3.size(), 1);
     spy4.wait();
-    QCOMPARE(spy4.count(), 1);
+    QCOMPARE(spy4.size(), 1);
     QVERIFY(reply->error() == QNetworkReply::NoError);
     // Second request will not send socketStartedConnecting because of keep-alive, so don't check it.
     QNetworkReplyPtr secondreply;
@@ -9656,11 +9656,11 @@ void tst_QNetworkReply::moreActivitySignals()
     QSignalSpy secondspy3(secondreply.data(), SIGNAL(metaDataChanged()));
     QSignalSpy secondspy4(secondreply.data(), SIGNAL(finished()));
     secondspy2.wait();
-    QCOMPARE(secondspy2.count(), 1);
+    QCOMPARE(secondspy2.size(), 1);
     secondspy3.wait();
-    QCOMPARE(secondspy3.count(), 1);
+    QCOMPARE(secondspy3.size(), 1);
     secondspy4.wait();
-    QCOMPARE(secondspy4.count(), 1);
+    QCOMPARE(secondspy4.size(), 1);
     QVERIFY(secondreply->error() == QNetworkReply::NoError);
 }
 
diff --git a/tests/auto/network/kernel/qdnslookup/tst_qdnslookup.cpp b/tests/auto/network/kernel/qdnslookup/tst_qdnslookup.cpp
index b1867d55fb..d22d858b26 100644
--- a/tests/auto/network/kernel/qdnslookup/tst_qdnslookup.cpp
+++ b/tests/auto/network/kernel/qdnslookup/tst_qdnslookup.cpp
@@ -66,7 +66,7 @@ QString tst_QDnsLookup::domainNameList(const QString &input)
 QStringList tst_QDnsLookup::domainNameListAlternatives(const QString &input)
 {
     QStringList alternatives = input.split('|');
-    for (int i = 0; i < alternatives.length(); ++i)
+    for (int i = 0; i < alternatives.size(); ++i)
         alternatives[i] = domainNameList(alternatives[i]);
     return alternatives;
 }
@@ -367,7 +367,7 @@ void tst_QDnsLookup::bindingsAndProperties()
     const QSignalSpy typeChangeSpy(&lookup, &QDnsLookup::typeChanged);
 
     dnsTypeProp = QDnsLookup::AAAA;
-    QCOMPARE(typeChangeSpy.count(), 1);
+    QCOMPARE(typeChangeSpy.size(), 1);
     QCOMPARE(lookup.type(), QDnsLookup::AAAA);
 
     dnsTypeProp.setBinding(lookup.bindableType().makeBinding());
@@ -379,7 +379,7 @@ void tst_QDnsLookup::bindingsAndProperties()
     const QSignalSpy nameChangeSpy(&lookup, &QDnsLookup::nameChanged);
 
     nameProp = QStringLiteral("a-plus-aaaa");
-    QCOMPARE(nameChangeSpy.count(), 1);
+    QCOMPARE(nameChangeSpy.size(), 1);
     QCOMPARE(lookup.name(), QStringLiteral("a-plus-aaaa"));
 
     nameProp.setBinding(lookup.bindableName().makeBinding());
@@ -391,7 +391,7 @@ void tst_QDnsLookup::bindingsAndProperties()
     const QSignalSpy nameserverChangeSpy(&lookup, &QDnsLookup::nameserverChanged);
 
     nameserverProp = QHostAddress::LocalHost;
-    QCOMPARE(nameserverChangeSpy.count(), 1);
+    QCOMPARE(nameserverChangeSpy.size(), 1);
     QCOMPARE(lookup.nameserver(), QHostAddress::LocalHost);
 
     nameserverProp.setBinding(lookup.bindableNameserver().makeBinding());
diff --git a/tests/auto/network/kernel/qnetworkinformation/tst_qnetworkinformation.cpp b/tests/auto/network/kernel/qnetworkinformation/tst_qnetworkinformation.cpp
index cde2399424..720388c53f 100644
--- a/tests/auto/network/kernel/qnetworkinformation/tst_qnetworkinformation.cpp
+++ b/tests/auto/network/kernel/qnetworkinformation/tst_qnetworkinformation.cpp
@@ -241,14 +241,14 @@ void tst_QNetworkInformation::isMetered()
     QSignalSpy spy(info, &QNetworkInformation::isMeteredChanged);
     QVERIFY(!info->isMetered());
     MockBackend::setNewMetered(true);
-    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.size(), 1);
     QVERIFY(info->isMetered());
     QVERIFY(spy[0][0].toBool());
     spy.clear();
 
     // Set the same value again, signal should not be emitted again
     MockBackend::setNewMetered(true);
-    QCOMPARE(spy.count(), 0);
+    QCOMPARE(spy.size(), 0);
 }
 
 QTEST_MAIN(tst_QNetworkInformation);
diff --git a/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp b/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp
index 0add6b2400..f240f3e832 100644
--- a/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp
+++ b/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp
@@ -246,7 +246,7 @@ void tst_QLocalSocket::server_basic()
     QCOMPARE(server.listen(QString()), false);
 
     QCOMPARE(server.hits.size(), 0);
-    QCOMPARE(spyNewConnection.count(), 0);
+    QCOMPARE(spyNewConnection.size(), 0);
 }
 
 void tst_QLocalSocket::server_connectionsCount()
@@ -287,11 +287,11 @@ void tst_QLocalSocket::socket_basic()
     QCOMPARE(socket.waitForDisconnected(0), false);
     QCOMPARE(socket.waitForReadyRead(0), false);
 
-    QCOMPARE(spyConnected.count(), 0);
-    QCOMPARE(spyDisconnected.count(), 0);
-    QCOMPARE(spyError.count(), 0);
-    QCOMPARE(spyStateChanged.count(), 0);
-    QCOMPARE(spyReadyRead.count(), 0);
+    QCOMPARE(spyConnected.size(), 0);
+    QCOMPARE(spyDisconnected.size(), 0);
+    QCOMPARE(spyError.size(), 0);
+    QCOMPARE(spyStateChanged.size(), 0);
+    QCOMPARE(spyReadyRead.size(), 0);
 }
 
 void tst_QLocalSocket::listen_data()
@@ -322,7 +322,7 @@ void tst_QLocalSocket::listen()
     QCOMPARE(server.hasPendingConnections(), false);
     QCOMPARE(server.nextPendingConnection(), (QLocalSocket*)0);
     QCOMPARE(server.hits.size(), 0);
-    QCOMPARE(spyNewConnection.count(), 0);
+    QCOMPARE(spyNewConnection.size(), 0);
     if (canListen) {
         QVERIFY(server.errorString().isEmpty());
         QCOMPARE(server.serverError(), QAbstractSocket::UnknownSocketError);
@@ -396,7 +396,7 @@ void tst_QLocalSocket::listenAndConnect()
             QCOMPARE(socket->error(), QLocalSocket::UnknownSocketError);
             QCOMPARE(socket->state(), QLocalSocket::ConnectedState);
             //QVERIFY(socket->socketDescriptor() != -1);
-            QCOMPARE(spyError.count(), 0);
+            QCOMPARE(spyError.size(), 0);
         } else {
             QVERIFY(!socket->errorString().isEmpty());
             QVERIFY(socket->error() != QLocalSocket::UnknownSocketError);
@@ -415,13 +415,13 @@ void tst_QLocalSocket::listenAndConnect()
         QCOMPARE(socket->waitForConnected(0), canListen);
         QCOMPARE(socket->waitForReadyRead(0), false);
 
-        QTRY_COMPARE(spyConnected.count(), canListen ? 1 : 0);
-        QCOMPARE(spyDisconnected.count(), 0);
+        QTRY_COMPARE(spyConnected.size(), canListen ? 1 : 0);
+        QCOMPARE(spyDisconnected.size(), 0);
 
         // error signals
-        QVERIFY(spyError.count() >= 0);
+        QVERIFY(spyError.size() >= 0);
         if (canListen) {
-            if (spyError.count() > 0)
+            if (spyError.size() > 0)
                 QCOMPARE(qvariant_cast<QLocalSocket::LocalSocketError>(spyError.first()[0]),
                          QLocalSocket::SocketTimeoutError);
         } else {
@@ -436,8 +436,8 @@ void tst_QLocalSocket::listenAndConnect()
         if (canListen)
             QCOMPARE(qvariant_cast<QLocalSocket::LocalSocketState>(spyStateChanged.last()[0]),
                      QLocalSocket::ConnectedState);
-        QCOMPARE(spyStateChanged.count(), 2);
-        QCOMPARE(spyReadyRead.count(), 0);
+        QCOMPARE(spyStateChanged.size(), 2);
+        QCOMPARE(spyReadyRead.size(), 0);
 
         bool timedOut = true;
         QCOMPARE(server.waitForNewConnection(3000, &timedOut), canListen);
@@ -452,14 +452,14 @@ void tst_QLocalSocket::listenAndConnect()
             QVERIFY(server.fullServerName().contains(name));
             QVERIFY(server.nextPendingConnection() != (QLocalSocket*)0);
             QTRY_COMPARE(server.hits.size(), i + 1);
-            QCOMPARE(spyNewConnection.count(), i + 1);
+            QCOMPARE(spyNewConnection.size(), i + 1);
             QVERIFY(server.errorString().isEmpty());
             QCOMPARE(server.serverError(), QAbstractSocket::UnknownSocketError);
         } else {
             QVERIFY(server.serverName().isEmpty());
             QVERIFY(server.fullServerName().isEmpty());
             QCOMPARE(server.nextPendingConnection(), (QLocalSocket*)0);
-            QCOMPARE(spyNewConnection.count(), 0);
+            QCOMPARE(spyNewConnection.size(), 0);
             QCOMPARE(server.hits.size(), 0);
             QVERIFY(!server.errorString().isEmpty());
             QCOMPARE(server.serverError(), QAbstractSocket::HostNotFoundError);
@@ -470,7 +470,7 @@ void tst_QLocalSocket::listenAndConnect()
     server.close();
 
     QCOMPARE(server.hits.size(), (canListen ? connections : 0));
-    QCOMPARE(spyNewConnection.count(), (canListen ? connections : 0));
+    QCOMPARE(spyNewConnection.size(), (canListen ? connections : 0));
 }
 
 void tst_QLocalSocket::connectWithOpen()
@@ -494,7 +494,7 @@ void tst_QLocalSocket::connectWithOpen()
     socket.close();
     server.close();
 
-    QCOMPARE(spyAboutToClose.count(), 1);
+    QCOMPARE(spyAboutToClose.size(), 1);
 }
 
 void tst_QLocalSocket::listenAndConnectAbstractNamespaceTrailingZeros_data()
@@ -660,7 +660,7 @@ void tst_QLocalSocket::sendData()
     QTest::qWait(250);
 #endif
     QVERIFY(!timedOut);
-    QCOMPARE(spyConnected.count(), canListen ? 1 : 0);
+    QCOMPARE(spyConnected.size(), canListen ? 1 : 0);
     QCOMPARE(socket.state(), canListen ? QLocalSocket::ConnectedState : QLocalSocket::UnconnectedState);
 
     // test sending/receiving data
@@ -686,7 +686,7 @@ void tst_QLocalSocket::sendData()
         QCOMPARE(socket.flush(), false);
         QCOMPARE(socket.isValid(), canListen);
         QCOMPARE(socket.readBufferSize(), (qint64)0);
-        QCOMPARE(spyReadyRead.count(), expectedReadyReadSignals);
+        QCOMPARE(spyReadyRead.size(), expectedReadyReadSignals);
 
         QVERIFY(testLine.startsWith(in.readLine()));
 
@@ -697,16 +697,16 @@ void tst_QLocalSocket::sendData()
     }
 
     socket.disconnectFromServer();
-    QCOMPARE(spyConnected.count(), canListen ? 1 : 0);
-    QCOMPARE(spyDisconnected.count(), canListen ? 1 : 0);
-    QCOMPARE(spyError.count(), canListen ? 0 : 1);
-    QCOMPARE(spyStateChanged.count(), canListen ? 4 : 2);
-    QCOMPARE(spyReadyRead.count(), canListen ? expectedReadyReadSignals : 0);
+    QCOMPARE(spyConnected.size(), canListen ? 1 : 0);
+    QCOMPARE(spyDisconnected.size(), canListen ? 1 : 0);
+    QCOMPARE(spyError.size(), canListen ? 0 : 1);
+    QCOMPARE(spyStateChanged.size(), canListen ? 4 : 2);
+    QCOMPARE(spyReadyRead.size(), canListen ? expectedReadyReadSignals : 0);
 
     server.close();
 
     QCOMPARE(server.hits.size(), (canListen ? 1 : 0));
-    QCOMPARE(spy.count(), (canListen ? 1 : 0));
+    QCOMPARE(spy.size(), (canListen ? 1 : 0));
 }
 
 void tst_QLocalSocket::readLine_data()
@@ -1006,7 +1006,7 @@ void tst_QLocalSocket::simpleCommandProtocol2()
 
     localSocketWrite.abort();
     QCOMPARE(localSocketWrite.state(), QLocalSocket::UnconnectedState);
-    QCOMPARE(spyDisconnected.count(), 1);
+    QCOMPARE(spyDisconnected.size(), 1);
     QCOMPARE(localSocketWrite.bytesToWrite(), 0);
     QVERIFY(!localSocketWrite.isOpen());
 
@@ -1096,9 +1096,9 @@ public:
         QVERIFY(socket.waitForConnected(1000));
 
         // We should *not* have this signal yet!
-        QCOMPARE(spyReadyRead.count(), 0);
+        QCOMPARE(spyReadyRead.size(), 0);
         socket.waitForReadyRead();
-        QCOMPARE(spyReadyRead.count(), 1);
+        QCOMPARE(spyReadyRead.size(), 1);
         QTextStream in(&socket);
         QCOMPARE(in.readLine(), testLine);
         socket.close();
@@ -1309,7 +1309,7 @@ void tst_QLocalSocket::waitForDisconnectByServer()
     serverSocket->close();
     QCOMPARE(serverSocket->state(), QLocalSocket::UnconnectedState);
     QVERIFY(socket.waitForDisconnected(3000));
-    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.size(), 1);
 }
 
 void tst_QLocalSocket::waitForReadyReadOnDisconnected()
@@ -1426,7 +1426,7 @@ void tst_QLocalSocket::recycleClientSocket()
     QLocalSocket client;
     QSignalSpy clientReadyReadSpy(&client, SIGNAL(readyRead()));
     QSignalSpy clientErrorSpy(&client, SIGNAL(errorOccurred(QLocalSocket::LocalSocketError)));
-    for (int i = 0; i < lines.count(); ++i) {
+    for (int i = 0; i < lines.size(); ++i) {
         client.abort();
         clientReadyReadSpy.clear();
         client.connectToServer(serverName);
@@ -1521,7 +1521,7 @@ void tst_QLocalSocket::writeToClientAndDisconnect()
     QVERIFY(clientSocket->waitForDisconnected());
 
     QVERIFY(client.waitForDisconnected());
-    QCOMPARE(readChannelFinishedSpy.count(), 1);
+    QCOMPARE(readChannelFinishedSpy.size(), 1);
     const QByteArray received = client.readAll();
     QCOMPARE(received.size(), qint64(sizeof(buffer) * chunks));
     QCOMPARE(client.state(), QLocalSocket::UnconnectedState);
@@ -1551,7 +1551,7 @@ void tst_QLocalSocket::writeToDisconnected()
 
     QCOMPARE(client.bytesToWrite(), qint64(1));
     QVERIFY(!client.waitForBytesWritten());
-    QCOMPARE(spyError.count(), 1);
+    QCOMPARE(spyError.size(), 1);
     QCOMPARE(client.state(), QLocalSocket::UnconnectedState);
 }
 
@@ -1656,7 +1656,7 @@ void tst_QLocalSocket::asyncDisconnectNotify()
     QVERIFY(serverSocket);
     delete serverSocket;
     QTRY_VERIFY(!disconnectedSpy.isEmpty());
-    QCOMPARE(readChannelFinishedSpy.count(), 1);
+    QCOMPARE(readChannelFinishedSpy.size(), 1);
 }
 
 void tst_QLocalSocket::verifySocketOptions_data()
diff --git a/tests/auto/network/socket/qtcpserver/tst_qtcpserver.cpp b/tests/auto/network/socket/qtcpserver/tst_qtcpserver.cpp
index 5c87a3f04b..b10bce335b 100644
--- a/tests/auto/network/socket/qtcpserver/tst_qtcpserver.cpp
+++ b/tests/auto/network/socket/qtcpserver/tst_qtcpserver.cpp
@@ -248,7 +248,7 @@ void tst_QTcpServer::clientServerLoop()
     QVERIFY(server.waitForNewConnection(5000));
     QVERIFY(server.hasPendingConnections());
 
-    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.size(), 1);
 
     QTcpSocket *serverSocket = server.nextPendingConnection();
     QVERIFY(serverSocket != 0);
@@ -409,9 +409,9 @@ void tst_QTcpServer::maxPendingConnections()
     // two connections have been made. The second compare makes sure no
     // more are accepted. Creating connections happens multithreaded so
     // qWait must be used for that.
-    QTRY_COMPARE(spy.count(), 2);
+    QTRY_COMPARE(spy.size(), 2);
     QTest::qWait(100);
-    QCOMPARE(spy.count(), 2);
+    QCOMPARE(spy.size(), 2);
 
     QVERIFY(server.hasPendingConnections());
     QVERIFY(server.nextPendingConnection());
@@ -1016,12 +1016,12 @@ void tst_QTcpServer::eagainBlockingAccept()
     QTcpSocket s;
     s.connectToHost(QHostAddress::LocalHost, 7896);
     QSignalSpy spy(&server, SIGNAL(newConnection()));
-    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, 500);
+    QTRY_COMPARE_WITH_TIMEOUT(spy.size(), 1, 500);
     s.close();
 
     // To test try again, should connect just fine.
     s.connectToHost(QHostAddress::LocalHost, 7896);
-    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 2, 500);
+    QTRY_COMPARE_WITH_TIMEOUT(spy.size(), 2, 500);
     s.close();
     server.close();
 }
@@ -1057,13 +1057,13 @@ void tst_QTcpServer::pauseAccepting()
     QTcpSocket sockets[NumSockets];
     sockets[0].connectToHost(address, server.serverPort());
     QVERIFY(spy.wait());
-    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.size(), 1);
 
     server.pauseAccepting();
     for (int i = 1; i < NumSockets; ++i)
         sockets[i].connectToHost(address, server.serverPort());
     QVERIFY(!spy.wait(400));
-    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.size(), 1);
 
     server.resumeAccepting();
     if (setProxy) {
@@ -1071,7 +1071,7 @@ void tst_QTcpServer::pauseAccepting()
                      Abort);
     }
     QVERIFY(spy.wait());
-    QCOMPARE(spy.count(), 6);
+    QCOMPARE(spy.size(), 6);
 }
 
 
@@ -1135,11 +1135,11 @@ void tst_QTcpServer::pendingConnectionAvailable()
     QCOMPARE(socket.state(), QTcpSocket::ConnectedState);
 
     int expectedPendingConnections = useDerivedServer ? 0 : 1;
-    QCOMPARE(pendingConnectionSpy.count(), expectedPendingConnections);
+    QCOMPARE(pendingConnectionSpy.size(), expectedPendingConnections);
 
     if (useDerivedServer)
         static_cast<DerivedServer *>(server)->emitNextSocket();
-    QCOMPARE(pendingConnectionSpy.count(), 1);
+    QCOMPARE(pendingConnectionSpy.size(), 1);
 }
 
 QTEST_MAIN(tst_QTcpServer)
diff --git a/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp b/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp
index bf933406a6..e35c771b0b 100644
--- a/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp
+++ b/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp
@@ -1781,7 +1781,7 @@ void tst_QTcpSocket::recursiveReadyRead()
     QVERIFY2(!timeout(),
             "Timed out when waiting for the readyRead() signal.");
 
-    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.size(), 1);
 
     delete testSocket;
 }
@@ -2006,8 +2006,8 @@ void tst_QTcpSocket::remoteCloseError()
     enterLoop(30);
     QVERIFY(!timeout());
 
-    QCOMPARE(disconnectedSpy.count(), 1);
-    QCOMPARE(errorSpy.count(), 1);
+    QCOMPARE(disconnectedSpy.size(), 1);
+    QCOMPARE(errorSpy.size(), 1);
     QCOMPARE(clientSocket->error(), QAbstractSocket::RemoteHostClosedError);
 
     delete serverSocket;
@@ -2138,7 +2138,7 @@ void tst_QTcpSocket::waitForConnectedInHostLookupSlot()
     if (tmpSocket->state() != QAbstractSocket::ConnectedState)
         loop.exec();
 
-    QCOMPARE(timerSpy.count(), 0);
+    QCOMPARE(timerSpy.size(), 0);
 
     delete tmpSocket;
 }
@@ -2243,7 +2243,7 @@ void tst_QTcpSocket::readyReadSignalsAfterWaitForReadyRead()
     // Wait for the read
     QVERIFY(socket->waitForReadyRead(10000));
 
-    QCOMPARE(readyReadSpy.count(), 1);
+    QCOMPARE(readyReadSpy.size(), 1);
 
     QString s = socket->readLine();
     QVERIFY2(QtNetworkSettings::compareReplyIMAP(s.toLatin1()), s.toLatin1().constData());
@@ -2251,7 +2251,7 @@ void tst_QTcpSocket::readyReadSignalsAfterWaitForReadyRead()
 
     QCoreApplication::instance()->processEvents();
     QCOMPARE(socket->bytesAvailable(), qint64(0));
-    QCOMPARE(readyReadSpy.count(), 1);
+    QCOMPARE(readyReadSpy.size(), 1);
 
     delete socket;
 }
@@ -2325,8 +2325,8 @@ void tst_QTcpSocket::abortiveClose()
 
     enterLoop(5);
 
-    QCOMPARE(readyReadSpy.count(), 0);
-    QCOMPARE(errorSpy.count(), 1);
+    QCOMPARE(readyReadSpy.size(), 0);
+    QCOMPARE(errorSpy.size(), 1);
 
     QCOMPARE(*static_cast<const int *>(errorSpy.at(0).at(0).constData()),
              int(QAbstractSocket::RemoteHostClosedError));
@@ -2445,11 +2445,11 @@ void tst_QTcpSocket::connectionRefused()
     QCOMPARE(socket->state(), QAbstractSocket::UnconnectedState);
     QCOMPARE(socket->error(), QAbstractSocket::ConnectionRefusedError);
 
-    QCOMPARE(stateSpy.count(), 3);
+    QCOMPARE(stateSpy.size(), 3);
     QCOMPARE(qvariant_cast<QAbstractSocket::SocketState>(stateSpy.at(0).at(0)), QAbstractSocket::HostLookupState);
     QCOMPARE(qvariant_cast<QAbstractSocket::SocketState>(stateSpy.at(1).at(0)), QAbstractSocket::ConnectingState);
     QCOMPARE(qvariant_cast<QAbstractSocket::SocketState>(stateSpy.at(2).at(0)), QAbstractSocket::UnconnectedState);
-    QCOMPARE(errorSpy.count(), 1);
+    QCOMPARE(errorSpy.size(), 1);
 
     delete socket;
 }
@@ -3118,8 +3118,8 @@ void tst_QTcpSocket::serverDisconnectWithBuffered()
         QCOMPARE(socket->state(), QAbstractSocket::UnconnectedState);
     }
     // Test signal emitting
-    QCOMPARE(spyDisconnected.count(), 1);
-    QVERIFY(spyStateChanged.count() > 0);
+    QCOMPARE(spyDisconnected.size(), 1);
+    QVERIFY(spyStateChanged.size() > 0);
     QVERIFY(qvariant_cast<QAbstractSocket::SocketState>(spyStateChanged.last().first())
             == QAbstractSocket::UnconnectedState);
 
@@ -3208,7 +3208,7 @@ void tst_QTcpSocket::readNotificationsAfterBind()
     QTestEventLoop::instance().enterLoop(10);
     QVERIFY2(!QTestEventLoop::instance().timeout(), "Connection to closed port timed out instead of refusing, something is wrong");
     QVERIFY2(socket.state() == QAbstractSocket::UnconnectedState, "Socket connected unexpectedly!");
-    QCOMPARE(spyReadyRead.count(), 0);
+    QCOMPARE(spyReadyRead.size(), 0);
 }
 
 QTEST_MAIN(tst_QTcpSocket)
diff --git a/tests/auto/network/socket/qudpsocket/tst_qudpsocket.cpp b/tests/auto/network/socket/qudpsocket/tst_qudpsocket.cpp
index 22d24ed448..4380433899 100644
--- a/tests/auto/network/socket/qudpsocket/tst_qudpsocket.cpp
+++ b/tests/auto/network/socket/qudpsocket/tst_qudpsocket.cpp
@@ -334,7 +334,7 @@ void tst_QUdpSocket::unconnectedServerAndClientTest()
 
     QSignalSpy stateChangedSpy(&serverSocket, SIGNAL(stateChanged(QAbstractSocket::SocketState)));
     QVERIFY2(serverSocket.bind(), serverSocket.errorString().toLatin1().constData());
-    QCOMPARE(stateChangedSpy.count(), 1);
+    QCOMPARE(stateChangedSpy.size(), 1);
 
     const char *message[] = {"Yo mista", "Yo", "Wassap"};
 
@@ -875,17 +875,17 @@ void tst_QUdpSocket::writeDatagram()
 #if defined (Q_OS_HPUX)
             QSKIP("HP-UX 11.11 on hai (PA-RISC 64) truncates too long datagrams.");
 #endif
-            QCOMPARE(bytesspy.count(), 0);
-            QCOMPARE(errorspy.count(), 1);
+            QCOMPARE(bytesspy.size(), 0);
+            QCOMPARE(errorspy.size(), 1);
             QCOMPARE(*static_cast<const int *>(errorspy.at(0).at(0).constData()),
                     int(QUdpSocket::DatagramTooLargeError));
             QCOMPARE(client.error(), QUdpSocket::DatagramTooLargeError);
             break;
         }
-        QCOMPARE(bytesspy.count(), 1);
+        QCOMPARE(bytesspy.size(), 1);
         QCOMPARE(*static_cast<const qint64 *>(bytesspy.at(0).at(0).constData()),
                 qint64(i * 1024));
-        QCOMPARE(errorspy.count(), 0);
+        QCOMPARE(errorspy.size(), 0);
         if (!server.waitForReadyRead(5000))
             QSKIP(QString("UDP packet lost at size %1, unable to complete the test.").arg(i * 1024).toLatin1().data());
         QCOMPARE(server.pendingDatagramSize(), qint64(i * 1024));
@@ -998,7 +998,7 @@ void tst_QUdpSocket::writeDatagramToNonExistingPeer()
         QVERIFY(sUdp.bind());
     QCOMPARE(sUdp.writeDatagram("", 1, peerAddress, peerPort), qint64(1));
     QTestEventLoop::instance().enterLoop(1);
-    QCOMPARE(sReadyReadSpy.count(), 0);
+    QCOMPARE(sReadyReadSpy.size(), 0);
 }
 
 void tst_QUdpSocket::writeToNonExistingPeer_data()
@@ -1041,8 +1041,8 @@ void tst_QUdpSocket::writeToNonExistingPeer()
     // the third one will succeed...
     QCOMPARE(sConnected.write("", 1), qint64(1));
     QTestEventLoop::instance().enterLoop(1);
-    QCOMPARE(sConnectedReadyReadSpy.count(), 0);
-    QCOMPARE(sConnectedErrorSpy.count(), 1);
+    QCOMPARE(sConnectedReadyReadSpy.size(), 0);
+    QCOMPARE(sConnectedErrorSpy.size(), 1);
     QCOMPARE(int(sConnected.error()), int(QUdpSocket::ConnectionRefusedError));
 
     // we should now get a read error
@@ -1647,7 +1647,7 @@ void tst_QUdpSocket::linkLocalIPv6()
         QSignalSpy spy(s, SIGNAL(readyRead()));
 
         QVERIFY(s->writeDatagram(testData, s->localAddress(), neutral.localPort()));
-        QTRY_VERIFY(neutralReadSpy.count() > 0); //note may need to accept a firewall prompt
+        QTRY_VERIFY(neutralReadSpy.size() > 0); //note may need to accept a firewall prompt
 
         QNetworkDatagram dgram = neutral.receiveDatagram(testData.size() * 2);
         QVERIFY(dgram.isValid());
@@ -1659,7 +1659,7 @@ void tst_QUdpSocket::linkLocalIPv6()
         QCOMPARE(dgram.data(), testData);
 
         QVERIFY(neutral.writeDatagram(dgram.makeReply(testData)));
-        QTRY_VERIFY(spy.count() > 0); //note may need to accept a firewall prompt
+        QTRY_VERIFY(spy.size() > 0); //note may need to accept a firewall prompt
 
         dgram = s->receiveDatagram(testData.size() * 2);
         QCOMPARE(dgram.data(), testData);
@@ -1786,7 +1786,7 @@ void tst_QUdpSocket::readyRead()
     QTest::qWait(100);
 
     // make sure only one signal was emitted
-    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.size(), 1);
     QVERIFY(receiver.hasPendingDatagrams());
 #ifdef RELIABLE_BYTES_AVAILABLE
     QCOMPARE(receiver.bytesAvailable(), qint64(2));
@@ -1798,7 +1798,7 @@ void tst_QUdpSocket::readyRead()
 
     // no new signal should be emitted because we haven't read the first datagram yet
     QTest::qWait(100);
-    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.size(), 1);
     QVERIFY(receiver.hasPendingDatagrams());
     QVERIFY(receiver.bytesAvailable() >= 1);    // most likely is 1, but it could be 1 + 2 in the future
     QCOMPARE(receiver.pendingDatagramSize(), qint64(2));
@@ -1810,7 +1810,7 @@ void tst_QUdpSocket::readyRead()
     // write a new datagram and ensure the signal is emitted now
     sender.writeDatagram("abc", makeNonAny(receiver.localAddress()), port);
     QTest::qWait(100);
-    QCOMPARE(spy.count(), 2);
+    QCOMPARE(spy.size(), 2);
     QVERIFY(receiver.hasPendingDatagrams());
 #ifdef RELIABLE_BYTES_AVAILABLE
     QCOMPARE(receiver.bytesAvailable(), qint64(3));
@@ -1890,7 +1890,7 @@ void tst_QUdpSocket::asyncReadDatagram()
     QTestEventLoop::instance().enterLoop(1);
 
     QVERIFY(!QTestEventLoop::instance().timeout());
-    QCOMPARE(spy.count(), 2);
+    QCOMPARE(spy.size(), 2);
 
     delete m_asyncSender;
     delete m_asyncReceiver;
diff --git a/tests/auto/network/ssl/qsslserver/tst_qsslserver.cpp b/tests/auto/network/ssl/qsslserver/tst_qsslserver.cpp
index f5356e58f7..13a3201345 100644
--- a/tests/auto/network/ssl/qsslserver/tst_qsslserver.cpp
+++ b/tests/auto/network/ssl/qsslserver/tst_qsslserver.cpp
@@ -142,15 +142,15 @@ void tst_QSslServer::testOneSuccessfulConnection()
     QVERIFY(server.startedEncryptionHandshakeSpy.isValid());
 
     // Check that no connections has occurred
-    QCOMPARE(server.sslErrorsSpy.count(), 0);
-    QCOMPARE(server.peerVerifyErrorSpy.count(), 0);
-    QCOMPARE(server.errorOccurredSpy.count(), 0);
-    QCOMPARE(server.pendingConnectionAvailableSpy.count(), 0);
-    QCOMPARE(server.preSharedKeyAuthenticationRequiredSpy.count(), 0);
-    QCOMPARE(server.alertSentSpy.count(), 0);
-    QCOMPARE(server.alertReceivedSpy.count(), 0);
-    QCOMPARE(server.handshakeInterruptedOnErrorSpy.count(), 0);
-    QCOMPARE(server.startedEncryptionHandshakeSpy.count(), 0);
+    QCOMPARE(server.sslErrorsSpy.size(), 0);
+    QCOMPARE(server.peerVerifyErrorSpy.size(), 0);
+    QCOMPARE(server.errorOccurredSpy.size(), 0);
+    QCOMPARE(server.pendingConnectionAvailableSpy.size(), 0);
+    QCOMPARE(server.preSharedKeyAuthenticationRequiredSpy.size(), 0);
+    QCOMPARE(server.alertSentSpy.size(), 0);
+    QCOMPARE(server.alertReceivedSpy.size(), 0);
+    QCOMPARE(server.handshakeInterruptedOnErrorSpy.size(), 0);
+    QCOMPARE(server.startedEncryptionHandshakeSpy.size(), 0);
 
     // Connect client
     QSslSocket client;
@@ -187,15 +187,15 @@ void tst_QSslServer::testOneSuccessfulConnection()
     loop.exec();
 
     // Check that one encrypted connection has occurred without error
-    QCOMPARE(server.sslErrorsSpy.count(), 0);
-    QCOMPARE(server.peerVerifyErrorSpy.count(), 0);
-    QCOMPARE(server.errorOccurredSpy.count(), 0);
-    QCOMPARE(server.pendingConnectionAvailableSpy.count(), 1);
-    QCOMPARE(server.preSharedKeyAuthenticationRequiredSpy.count(), 0);
-    QCOMPARE(server.alertSentSpy.count(), 0);
-    QCOMPARE(server.alertReceivedSpy.count(), 0);
-    QCOMPARE(server.handshakeInterruptedOnErrorSpy.count(), 0);
-    QCOMPARE(server.startedEncryptionHandshakeSpy.count(), 1);
+    QCOMPARE(server.sslErrorsSpy.size(), 0);
+    QCOMPARE(server.peerVerifyErrorSpy.size(), 0);
+    QCOMPARE(server.errorOccurredSpy.size(), 0);
+    QCOMPARE(server.pendingConnectionAvailableSpy.size(), 1);
+    QCOMPARE(server.preSharedKeyAuthenticationRequiredSpy.size(), 0);
+    QCOMPARE(server.alertSentSpy.size(), 0);
+    QCOMPARE(server.alertReceivedSpy.size(), 0);
+    QCOMPARE(server.handshakeInterruptedOnErrorSpy.size(), 0);
+    QCOMPARE(server.startedEncryptionHandshakeSpy.size(), 1);
 
     // Check client socket
     QVERIFY(client.isEncrypted());
@@ -224,16 +224,16 @@ void tst_QSslServer::testSelfSignedCertificateRejectedByServer()
     loop.exec();
 
     // Check that one encrypted connection has failed
-    QCOMPARE(server.sslErrorsSpy.count(), 1);
-    QCOMPARE(server.peerVerifyErrorSpy.count(), 1);
-    QCOMPARE(server.errorOccurredSpy.count(), 1);
-    QCOMPARE(server.pendingConnectionAvailableSpy.count(), 0);
-    QCOMPARE(server.preSharedKeyAuthenticationRequiredSpy.count(), 0);
-    QCOMPARE(server.alertSentSpy.count(),
+    QCOMPARE(server.sslErrorsSpy.size(), 1);
+    QCOMPARE(server.peerVerifyErrorSpy.size(), 1);
+    QCOMPARE(server.errorOccurredSpy.size(), 1);
+    QCOMPARE(server.pendingConnectionAvailableSpy.size(), 0);
+    QCOMPARE(server.preSharedKeyAuthenticationRequiredSpy.size(), 0);
+    QCOMPARE(server.alertSentSpy.size(),
              isTestingOpenSsl ? 1 : 0); // OpenSSL only signal
-    QCOMPARE(server.alertReceivedSpy.count(), 0);
-    QCOMPARE(server.handshakeInterruptedOnErrorSpy.count(), 0);
-    QCOMPARE(server.startedEncryptionHandshakeSpy.count(), 1);
+    QCOMPARE(server.alertReceivedSpy.size(), 0);
+    QCOMPARE(server.handshakeInterruptedOnErrorSpy.size(), 0);
+    QCOMPARE(server.startedEncryptionHandshakeSpy.size(), 1);
 
     // Type of certificate error to expect
     const auto certificateError =
@@ -290,32 +290,32 @@ void tst_QSslServer::testSelfSignedCertificateRejectedByClient()
     QTcpSocket *connection = server.server.nextPendingConnection();
     if (connection == nullptr) {
         // Client disconnected before connection accepted by server
-        QCOMPARE(server.sslErrorsSpy.count(), 0);
-        QCOMPARE(server.peerVerifyErrorSpy.count(), 0);
-        QCOMPARE(server.errorOccurredSpy.count(), 1); // Client rejected first
-        QCOMPARE(server.pendingConnectionAvailableSpy.count(), 0);
-        QCOMPARE(server.preSharedKeyAuthenticationRequiredSpy.count(), 0);
-        QCOMPARE(server.alertSentSpy.count(), 0);
-        QCOMPARE(server.alertReceivedSpy.count(),
+        QCOMPARE(server.sslErrorsSpy.size(), 0);
+        QCOMPARE(server.peerVerifyErrorSpy.size(), 0);
+        QCOMPARE(server.errorOccurredSpy.size(), 1); // Client rejected first
+        QCOMPARE(server.pendingConnectionAvailableSpy.size(), 0);
+        QCOMPARE(server.preSharedKeyAuthenticationRequiredSpy.size(), 0);
+        QCOMPARE(server.alertSentSpy.size(), 0);
+        QCOMPARE(server.alertReceivedSpy.size(),
                  isTestingOpenSsl ? 1 : 0); // OpenSSL only signal
-        QCOMPARE(server.handshakeInterruptedOnErrorSpy.count(), 0);
-        QCOMPARE(server.startedEncryptionHandshakeSpy.count(), 1);
+        QCOMPARE(server.handshakeInterruptedOnErrorSpy.size(), 0);
+        QCOMPARE(server.startedEncryptionHandshakeSpy.size(), 1);
 
         const auto errrOccuredSpyError = qvariant_cast<QAbstractSocket::SocketError>(
                 std::as_const(server.errorOccurredSpy).first()[1]);
         QCOMPARE(errrOccuredSpyError, socketError);
     } else {
         // Client disconnected after connection accepted by server
-        QCOMPARE(server.sslErrorsSpy.count(), 0);
-        QCOMPARE(server.peerVerifyErrorSpy.count(), 0);
-        QCOMPARE(server.errorOccurredSpy.count(), 0); // Server accepted first
-        QCOMPARE(server.pendingConnectionAvailableSpy.count(), 1);
-        QCOMPARE(server.preSharedKeyAuthenticationRequiredSpy.count(), 0);
-        QCOMPARE(server.alertSentSpy.count(), 0);
-        QCOMPARE(server.alertReceivedSpy.count(),
+        QCOMPARE(server.sslErrorsSpy.size(), 0);
+        QCOMPARE(server.peerVerifyErrorSpy.size(), 0);
+        QCOMPARE(server.errorOccurredSpy.size(), 0); // Server accepted first
+        QCOMPARE(server.pendingConnectionAvailableSpy.size(), 1);
+        QCOMPARE(server.preSharedKeyAuthenticationRequiredSpy.size(), 0);
+        QCOMPARE(server.alertSentSpy.size(), 0);
+        QCOMPARE(server.alertReceivedSpy.size(),
                  isTestingOpenSsl ? 1 : 0); // OpenSSL only signal
-        QCOMPARE(server.handshakeInterruptedOnErrorSpy.count(), 0);
-        QCOMPARE(server.startedEncryptionHandshakeSpy.count(), 1);
+        QCOMPARE(server.handshakeInterruptedOnErrorSpy.size(), 0);
+        QCOMPARE(server.startedEncryptionHandshakeSpy.size(), 1);
 
         QCOMPARE(connection->state(), QAbstractSocket::UnconnectedState);
         QCOMPARE(connection->error(), socketError);
@@ -325,12 +325,12 @@ void tst_QSslServer::testSelfSignedCertificateRejectedByClient()
     }
 
     // Check that client has rejected server
-    QCOMPARE(clientConnectedSpy.count(), 1);
-    QCOMPARE(clientHostFoundSpy.count(), 1);
-    QCOMPARE(clientDisconnectedSpy.count(), 1);
-    QCOMPARE(clientConnectionEncryptedSpy.count(), 0);
-    QCOMPARE(clientSslErrorsSpy.count(), isTestingOpenSsl ? 0 : 1);
-    QCOMPARE(clientErrorOccurredSpy.count(), 1);
+    QCOMPARE(clientConnectedSpy.size(), 1);
+    QCOMPARE(clientHostFoundSpy.size(), 1);
+    QCOMPARE(clientDisconnectedSpy.size(), 1);
+    QCOMPARE(clientConnectionEncryptedSpy.size(), 0);
+    QCOMPARE(clientSslErrorsSpy.size(), isTestingOpenSsl ? 0 : 1);
+    QCOMPARE(clientErrorOccurredSpy.size(), 1);
 
     // Check client socket
     QVERIFY(!client.isEncrypted());
@@ -364,15 +364,15 @@ void tst_QSslServer::testHandshakeInterruptedOnError()
     loop.exec();
 
     // Check that client certificate causes handshake interrupted signal to be emitted
-    QCOMPARE(server.sslErrorsSpy.count(), 0);
-    QCOMPARE(server.peerVerifyErrorSpy.count(), 0);
-    QCOMPARE(server.errorOccurredSpy.count(), 1);
-    QCOMPARE(server.pendingConnectionAvailableSpy.count(), 0);
-    QCOMPARE(server.preSharedKeyAuthenticationRequiredSpy.count(), 0);
-    QCOMPARE(server.alertSentSpy.count(), 1);
-    QCOMPARE(server.alertReceivedSpy.count(), 0);
-    QCOMPARE(server.handshakeInterruptedOnErrorSpy.count(), 1);
-    QCOMPARE(server.startedEncryptionHandshakeSpy.count(), 1);
+    QCOMPARE(server.sslErrorsSpy.size(), 0);
+    QCOMPARE(server.peerVerifyErrorSpy.size(), 0);
+    QCOMPARE(server.errorOccurredSpy.size(), 1);
+    QCOMPARE(server.pendingConnectionAvailableSpy.size(), 0);
+    QCOMPARE(server.preSharedKeyAuthenticationRequiredSpy.size(), 0);
+    QCOMPARE(server.alertSentSpy.size(), 1);
+    QCOMPARE(server.alertReceivedSpy.size(), 0);
+    QCOMPARE(server.handshakeInterruptedOnErrorSpy.size(), 1);
+    QCOMPARE(server.startedEncryptionHandshakeSpy.size(), 1);
 }
 
 void tst_QSslServer::testPreSharedKeyAuthenticationRequired()
@@ -422,15 +422,15 @@ void tst_QSslServer::testPreSharedKeyAuthenticationRequired()
     loop.exec();
 
     // Check that server is connected
-    QCOMPARE(server.sslErrorsSpy.count(), 1);
-    QCOMPARE(server.peerVerifyErrorSpy.count(), 1);
-    QCOMPARE(server.errorOccurredSpy.count(), 0);
-    QCOMPARE(server.pendingConnectionAvailableSpy.count(), 1);
-    QCOMPARE(server.preSharedKeyAuthenticationRequiredSpy.count(), 1);
-    QCOMPARE(server.alertSentSpy.count(), 0);
-    QCOMPARE(server.alertReceivedSpy.count(), 0);
-    QCOMPARE(server.handshakeInterruptedOnErrorSpy.count(), 0);
-    QCOMPARE(server.startedEncryptionHandshakeSpy.count(), 1);
+    QCOMPARE(server.sslErrorsSpy.size(), 1);
+    QCOMPARE(server.peerVerifyErrorSpy.size(), 1);
+    QCOMPARE(server.errorOccurredSpy.size(), 0);
+    QCOMPARE(server.pendingConnectionAvailableSpy.size(), 1);
+    QCOMPARE(server.preSharedKeyAuthenticationRequiredSpy.size(), 1);
+    QCOMPARE(server.alertSentSpy.size(), 0);
+    QCOMPARE(server.alertReceivedSpy.size(), 0);
+    QCOMPARE(server.handshakeInterruptedOnErrorSpy.size(), 0);
+    QCOMPARE(server.startedEncryptionHandshakeSpy.size(), 1);
 
     // Check client socket
     QVERIFY(client.isEncrypted());
@@ -457,7 +457,7 @@ void tst_QSslServer::plaintextClient()
     socket.write("Hello World!");
     socket.waitForBytesWritten();
     // ... and quickly get disconnected:
-    QTRY_COMPARE_GT(socketDisconnectedSpy.count(), 0);
+    QTRY_COMPARE_GT(socketDisconnectedSpy.size(), 0);
     QCOMPARE(socket.state(), QAbstractSocket::SocketState::UnconnectedState);
 }
 
diff --git a/tests/auto/network/ssl/qsslsocket/tst_qsslsocket.cpp b/tests/auto/network/ssl/qsslsocket/tst_qsslsocket.cpp
index 5d8de03d7f..4e380bcde1 100644
--- a/tests/auto/network/ssl/qsslsocket/tst_qsslsocket.cpp
+++ b/tests/auto/network/ssl/qsslsocket/tst_qsslsocket.cpp
@@ -836,30 +836,30 @@ void tst_QSslSocket::simpleConnect()
 
     // Entered connecting state
     QCOMPARE(socket.state(), QAbstractSocket::ConnectingState);
-    QCOMPARE(connectedSpy.count(), 0);
-    QCOMPARE(hostFoundSpy.count(), 1);
-    QCOMPARE(disconnectedSpy.count(), 0);
+    QCOMPARE(connectedSpy.size(), 0);
+    QCOMPARE(hostFoundSpy.size(), 1);
+    QCOMPARE(disconnectedSpy.size(), 0);
     enterLoop(10);
 
     // Entered connected state
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
     QCOMPARE(socket.mode(), QSslSocket::UnencryptedMode);
     QVERIFY(!socket.isEncrypted());
-    QCOMPARE(connectedSpy.count(), 1);
-    QCOMPARE(hostFoundSpy.count(), 1);
-    QCOMPARE(disconnectedSpy.count(), 0);
+    QCOMPARE(connectedSpy.size(), 1);
+    QCOMPARE(hostFoundSpy.size(), 1);
+    QCOMPARE(disconnectedSpy.size(), 0);
 
     // Enter encrypted mode
     socket.startClientEncryption();
     QCOMPARE(socket.mode(), QSslSocket::SslClientMode);
     QVERIFY(!socket.isEncrypted());
-    QCOMPARE(connectionEncryptedSpy.count(), 0);
-    QCOMPARE(sslErrorsSpy.count(), 0);
+    QCOMPARE(connectionEncryptedSpy.size(), 0);
+    QCOMPARE(sslErrorsSpy.size(), 0);
 
     // Starting handshake
     enterLoop(10);
-    QCOMPARE(sslErrorsSpy.count(), 1);
-    QCOMPARE(connectionEncryptedSpy.count(), 0);
+    QCOMPARE(sslErrorsSpy.size(), 1);
+    QCOMPARE(connectionEncryptedSpy.size(), 0);
     QVERIFY(!socket.isEncrypted());
     QCOMPARE(socket.state(), QAbstractSocket::UnconnectedState);
 }
@@ -897,10 +897,10 @@ void tst_QSslSocket::simpleConnectWithIgnore()
     enterLoop(10);
 
     // Done; encryption should be enabled.
-    QCOMPARE(sslErrorsSpy.count(), 1);
+    QCOMPARE(sslErrorsSpy.size(), 1);
     QVERIFY(socket.isEncrypted());
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
-    QCOMPARE(encryptedSpy.count(), 1);
+    QCOMPARE(encryptedSpy.size(), 1);
 
     // Wait for incoming data
     if (!socket.canReadLine())
@@ -2821,7 +2821,7 @@ void tst_QSslSocket::closeWhileEmittingSocketError()
     QTestEventLoop::instance().enterLoopMSecs(1000);
     QVERIFY(!QTestEventLoop::instance().timeout());
 
-    QCOMPARE(socketErrorSpy.count(), 1);
+    QCOMPARE(socketErrorSpy.size(), 1);
 }
 
 #endif // Feature 'openssl'.
@@ -2918,7 +2918,7 @@ void tst_QSslSocket::ignoreSslErrorsList()
     bool expectEncryptionSuccess = (expectedSslErrorSignalCount == 0);
     if (socket.waitForEncrypted(10000) != expectEncryptionSuccess)
         QSKIP("Skipping flaky test - See QTBUG-29941");
-    QCOMPARE(sslErrorsSpy.count(), expectedSslErrorSignalCount);
+    QCOMPARE(sslErrorsSpy.size(), expectedSslErrorSignalCount);
 }
 
 void tst_QSslSocket::ignoreSslErrorsListWithSlot_data()
@@ -3160,9 +3160,9 @@ void tst_QSslSocket::resume()
     QFETCH_GLOBAL(bool, setProxy);
     if (setProxy && QTestEventLoop::instance().timeout())
         QSKIP("Skipping flaky test - See QTBUG-29941");
-    QCOMPARE(sslErrorSpy.count(), 1);
-    QCOMPARE(errorSpy.count(), 0);
-    QCOMPARE(encryptedSpy.count(), 0);
+    QCOMPARE(sslErrorSpy.size(), 1);
+    QCOMPARE(errorSpy.size(), 0);
+    QCOMPARE(encryptedSpy.size(), 0);
     QVERIFY(!socket.isEncrypted());
     if (ignoreErrorsAfterPause) {
         if (errorsToIgnore.empty())
@@ -3174,15 +3174,15 @@ void tst_QSslSocket::resume()
     QTestEventLoop::instance().enterLoop(10);
     QVERIFY(!QTestEventLoop::instance().timeout()); // quit by encrypted() or error() signal
     if (expectSuccess) {
-        QCOMPARE(encryptedSpy.count(), 1);
+        QCOMPARE(encryptedSpy.size(), 1);
         QVERIFY(socket.isEncrypted());
-        QCOMPARE(errorSpy.count(), 0);
+        QCOMPARE(errorSpy.size(), 0);
         socket.disconnectFromHost();
         QVERIFY(socket.waitForDisconnected(10000));
     } else {
-        QCOMPARE(encryptedSpy.count(), 0);
+        QCOMPARE(encryptedSpy.size(), 0);
         QVERIFY(!socket.isEncrypted());
-        QCOMPARE(errorSpy.count(), 1);
+        QCOMPARE(errorSpy.size(), 1);
         QCOMPARE(socket.error(), QAbstractSocket::SslHandshakeFailedError);
     }
 }
@@ -4142,32 +4142,32 @@ void tst_QSslSocket::simplePskConnect()
 
     // Entered connecting state
     QCOMPARE(socket.state(), QAbstractSocket::ConnectingState);
-    QCOMPARE(connectedSpy.count(), 0);
-    QCOMPARE(hostFoundSpy.count(), 1);
-    QCOMPARE(disconnectedSpy.count(), 0);
+    QCOMPARE(connectedSpy.size(), 0);
+    QCOMPARE(hostFoundSpy.size(), 1);
+    QCOMPARE(disconnectedSpy.size(), 0);
     enterLoop(10);
 
     // Entered connected state
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
     QCOMPARE(socket.mode(), QSslSocket::UnencryptedMode);
     QVERIFY(!socket.isEncrypted());
-    QCOMPARE(connectedSpy.count(), 1);
-    QCOMPARE(hostFoundSpy.count(), 1);
-    QCOMPARE(disconnectedSpy.count(), 0);
+    QCOMPARE(connectedSpy.size(), 1);
+    QCOMPARE(hostFoundSpy.size(), 1);
+    QCOMPARE(disconnectedSpy.size(), 0);
 
     // Enter encrypted mode
     socket.startClientEncryption();
     QCOMPARE(socket.mode(), QSslSocket::SslClientMode);
     QVERIFY(!socket.isEncrypted());
-    QCOMPARE(connectionEncryptedSpy.count(), 0);
-    QCOMPARE(sslErrorsSpy.count(), 0);
-    QCOMPARE(peerVerifyErrorSpy.count(), 0);
+    QCOMPARE(connectionEncryptedSpy.size(), 0);
+    QCOMPARE(sslErrorsSpy.size(), 0);
+    QCOMPARE(peerVerifyErrorSpy.size(), 0);
 
     // Start handshake.
     enterLoop(10);
 
     // We must get the PSK signal in all cases
-    QCOMPARE(pskAuthenticationRequiredSpy.count(), 1);
+    QCOMPARE(pskAuthenticationRequiredSpy.size(), 1);
 
     switch (pskTestType) {
     case PskConnectDoNotHandlePsk:
@@ -4176,40 +4176,40 @@ void tst_QSslSocket::simplePskConnect()
     case PskConnectWrongIdentity:
     case PskConnectWrongPreSharedKey:
         // Handshake failure
-        QCOMPARE(socketErrorsSpy.count(), 1);
+        QCOMPARE(socketErrorsSpy.size(), 1);
         QCOMPARE(qvariant_cast<QAbstractSocket::SocketError>(socketErrorsSpy.at(0).at(0)), QAbstractSocket::SslHandshakeFailedError);
-        QCOMPARE(sslErrorsSpy.count(), 0);
-        QCOMPARE(peerVerifyErrorSpy.count(), 0);
-        QCOMPARE(connectionEncryptedSpy.count(), 0);
+        QCOMPARE(sslErrorsSpy.size(), 0);
+        QCOMPARE(peerVerifyErrorSpy.size(), 0);
+        QCOMPARE(connectionEncryptedSpy.size(), 0);
         QVERIFY(!socket.isEncrypted());
         break;
 
     case PskConnectRightCredentialsPeerVerifyFailure:
         // Peer verification failure
-        QCOMPARE(socketErrorsSpy.count(), 1);
+        QCOMPARE(socketErrorsSpy.size(), 1);
         QCOMPARE(qvariant_cast<QAbstractSocket::SocketError>(socketErrorsSpy.at(0).at(0)), QAbstractSocket::SslHandshakeFailedError);
-        QCOMPARE(sslErrorsSpy.count(), 1);
-        QCOMPARE(peerVerifyErrorSpy.count(), 1);
-        QCOMPARE(connectionEncryptedSpy.count(), 0);
+        QCOMPARE(sslErrorsSpy.size(), 1);
+        QCOMPARE(peerVerifyErrorSpy.size(), 1);
+        QCOMPARE(connectionEncryptedSpy.size(), 0);
         QVERIFY(!socket.isEncrypted());
         break;
 
     case PskConnectRightCredentialsVerifyPeer:
         // Peer verification failure, but ignore it and keep connecting
-        QCOMPARE(socketErrorsSpy.count(), 0);
-        QCOMPARE(sslErrorsSpy.count(), 1);
-        QCOMPARE(peerVerifyErrorSpy.count(), 1);
-        QCOMPARE(connectionEncryptedSpy.count(), 1);
+        QCOMPARE(socketErrorsSpy.size(), 0);
+        QCOMPARE(sslErrorsSpy.size(), 1);
+        QCOMPARE(peerVerifyErrorSpy.size(), 1);
+        QCOMPARE(connectionEncryptedSpy.size(), 1);
         QVERIFY(socket.isEncrypted());
         QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
         break;
 
     case PskConnectRightCredentialsDoNotVerifyPeer:
         // No peer verification => no failure
-        QCOMPARE(socketErrorsSpy.count(), 0);
-        QCOMPARE(sslErrorsSpy.count(), 0);
-        QCOMPARE(peerVerifyErrorSpy.count(), 0);
-        QCOMPARE(connectionEncryptedSpy.count(), 1);
+        QCOMPARE(socketErrorsSpy.size(), 0);
+        QCOMPARE(sslErrorsSpy.size(), 0);
+        QCOMPARE(peerVerifyErrorSpy.size(), 0);
+        QCOMPARE(connectionEncryptedSpy.size(), 1);
         QVERIFY(socket.isEncrypted());
         QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
         break;
@@ -4250,7 +4250,7 @@ void tst_QSslSocket::simplePskConnect()
     }
 
     QCOMPARE(socket.state(), QAbstractSocket::UnconnectedState);
-    QCOMPARE(disconnectedSpy.count(), 1);
+    QCOMPARE(disconnectedSpy.size(), 1);
 }
 
 void tst_QSslSocket::ephemeralServerKey_data()
@@ -4283,7 +4283,7 @@ void tst_QSslSocket::ephemeralServerKey()
     client->connectToHostEncrypted(QHostAddress(QHostAddress::LocalHost).toString(), server.serverPort());
     spy.wait();
 
-    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.size(), 1);
     QVERIFY(server.config.ephemeralServerKey().isNull());
     QCOMPARE(client->sslConfiguration().ephemeralServerKey().isNull(), emptyKey);
 }
@@ -4346,22 +4346,22 @@ void tst_QSslSocket::pskServer()
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
     QCOMPARE(socket.mode(), QSslSocket::UnencryptedMode);
     QVERIFY(!socket.isEncrypted());
-    QCOMPARE(connectedSpy.count(), 1);
-    QCOMPARE(disconnectedSpy.count(), 0);
+    QCOMPARE(connectedSpy.size(), 1);
+    QCOMPARE(disconnectedSpy.size(), 0);
 
     // Enter encrypted mode
     socket.startClientEncryption();
     QCOMPARE(socket.mode(), QSslSocket::SslClientMode);
     QVERIFY(!socket.isEncrypted());
-    QCOMPARE(connectionEncryptedSpy.count(), 0);
+    QCOMPARE(connectionEncryptedSpy.size(), 0);
 
     // Start handshake.
     enterLoop(10);
 
     // We must get the PSK signal in all cases
-    QCOMPARE(pskAuthenticationRequiredSpy.count(), 1);
+    QCOMPARE(pskAuthenticationRequiredSpy.size(), 1);
 
-    QCOMPARE(connectionEncryptedSpy.count(), 1);
+    QCOMPARE(connectionEncryptedSpy.size(), 1);
     QVERIFY(socket.isEncrypted());
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
 
@@ -4374,7 +4374,7 @@ void tst_QSslSocket::pskServer()
     enterLoop(10);
 
     QCOMPARE(socket.state(), QAbstractSocket::UnconnectedState);
-    QCOMPARE(disconnectedSpy.count(), 1);
+    QCOMPARE(disconnectedSpy.size(), 1);
 }
 
 void tst_QSslSocket::signatureAlgorithm_data()
@@ -4527,7 +4527,7 @@ void tst_QSslSocket::forwardReadChannelFinished()
             &QTestEventLoop::instance(), &QTestEventLoop::exitLoop);
     socket.connectToHostEncrypted(QtNetworkSettings::httpServerName(), 443);
     enterLoop(10);
-    QVERIFY(readChannelFinishedSpy.count());
+    QVERIFY(readChannelFinishedSpy.size());
 }
 
 #endif // QT_CONFIG(openssl)
@@ -4714,8 +4714,8 @@ void tst_QSslSocket::alertMissingCertificate()
         runner.enterLoopMSecs(10000);
     }
 
-    QVERIFY(serverSpy.count() > 0);
-    QVERIFY(clientSpy.count() > 0);
+    QVERIFY(serverSpy.size() > 0);
+    QVERIFY(clientSpy.size() > 0);
     QVERIFY(server.socket && !server.socket->isEncrypted());
     QVERIFY(!clientSocket.isEncrypted());
 }
@@ -4768,9 +4768,9 @@ void tst_QSslSocket::alertInvalidCertificate()
 
     runner.enterLoopMSecs(1000);
 
-    QVERIFY(serverSpy.count() > 0);
-    QVERIFY(clientSpy.count() > 0);
-    QVERIFY(interruptedSpy.count() > 0);
+    QVERIFY(serverSpy.size() > 0);
+    QVERIFY(clientSpy.size() > 0);
+    QVERIFY(interruptedSpy.size() > 0);
     QVERIFY(server.socket && !server.socket->isEncrypted());
     QVERIFY(!clientSocket.isEncrypted());
 }
@@ -4897,14 +4897,14 @@ void tst_QSslSocket::selfSignedCertificates()
     runner.enterLoopMSecs(1000);
 
     if (clientKnown) {
-        QCOMPARE(serverSpy.count(), 0);
-        QCOMPARE(clientSpy.count(), 0);
+        QCOMPARE(serverSpy.size(), 0);
+        QCOMPARE(clientSpy.size(), 0);
         QVERIFY(server.socket && server.socket->isEncrypted());
         QVERIFY(clientSocket.isEncrypted());
     } else {
-        QVERIFY(serverSpy.count() > 0);
+        QVERIFY(serverSpy.size() > 0);
         QEXPECT_FAIL("", "Failing to trigger signal, QTBUG-81661", Continue);
-        QVERIFY(clientSpy.count() > 0);
+        QVERIFY(clientSpy.size() > 0);
         QVERIFY(server.socket && !server.socket->isEncrypted());
         QVERIFY(!clientSocket.isEncrypted());
     }
@@ -5035,15 +5035,15 @@ void tst_QSslSocket::pskHandshake()
     runner.enterLoopMSecs(1000);
 
     if (pskRight) {
-        QCOMPARE(serverSpy.count(), 0);
-        QCOMPARE(clientSpy.count(), 0);
+        QCOMPARE(serverSpy.size(), 0);
+        QCOMPARE(clientSpy.size(), 0);
         QVERIFY(server.socket && server.socket->isEncrypted());
         QVERIFY(clientSocket.isEncrypted());
     } else {
-        QVERIFY(serverSpy.count() > 0);
+        QVERIFY(serverSpy.size() > 0);
         QCOMPARE(serverSpy.first().at(0).toInt(), static_cast<int>(QSsl::AlertLevel::Fatal));
         QCOMPARE(serverSpy.first().at(1).toInt(), static_cast<int>(QSsl::AlertType::BadRecordMac));
-        QVERIFY(clientSpy.count() > 0);
+        QVERIFY(clientSpy.size() > 0);
         QCOMPARE(clientSpy.first().at(0).toInt(), static_cast<int>(QSsl::AlertLevel::Fatal));
         QCOMPARE(clientSpy.first().at(1).toInt(), static_cast<int>(QSsl::AlertType::BadRecordMac));
         QVERIFY(server.socket && !server.socket->isEncrypted());