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

This is a semantic patch using ClangTidyTransformator as in
qtbase/df9d882d41b741fef7c5beeddb0abe9d904443d8:

  auto QtContainerClass = anyOf(
      expr(hasType(cxxRecordDecl(isSameOrDerivedFrom(hasAnyName(classes))))).bind(o),
      expr(hasType(namedDecl(hasAnyName(<classes>)))).bind(o));
  makeRule(cxxMemberCallExpr(on(QtContainerClass),
                             callee(cxxMethodDecl(hasAnyName({"count", "length"),
                                                  parameterCountIs(0))))),
           changeTo(cat(access(o, cat("size"), "()"))),
           cat("use 'size()' instead of 'count()/length()'"))

a.k.a qt-port-to-std-compatible-api with config Scope: 'Container',
with the extended set of container classes recognized.

Change-Id: Ic219197507870fd2b739f2e04ff138021e58d550
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>

5 files changed, 326 insertions, 326 deletions

diff --git a/tests/auto/websockets/dataprocessor/tst_dataprocessor.cpp b/tests/auto/websockets/dataprocessor/tst_dataprocessor.cpp
index 189c34a..d814cce 100644
--- a/tests/auto/websockets/dataprocessor/tst_dataprocessor.cpp
+++ b/tests/auto/websockets/dataprocessor/tst_dataprocessor.cpp
@@ -222,20 +222,20 @@ void tst_DataProcessor::goodBinaryFrame()
 
     data.append(char(FIN | QWebSocketProtocol::OpCodeBinary));
 
-    if (payload.length() < 126)
+    if (payload.size() < 126)
     {
-        data.append(char(payload.length()));
+        data.append(char(payload.size()));
     }
-    else if (payload.length() < 65536)
+    else if (payload.size() < 65536)
     {
-        quint16 swapped = qToBigEndian<quint16>(payload.length());
+        quint16 swapped = qToBigEndian<quint16>(payload.size());
         const char *wireRepresentation
                 = static_cast<const char *>(static_cast<const void *>(&swapped));
         data.append(char(126)).append(wireRepresentation, 2);
     }
     else
     {
-        quint64 swapped = qToBigEndian<quint64>(payload.length());
+        quint64 swapped = qToBigEndian<quint64>(payload.size());
         const char *wireRepresentation
                 = static_cast<const char *>(static_cast<const void *>(&swapped));
         data.append(char(127)).append(wireRepresentation, 8);
@@ -256,18 +256,18 @@ void tst_DataProcessor::goodBinaryFrame()
     QSignalSpy textFrameReceivedSpy(&dataProcessor, SIGNAL(textFrameReceived(QString,bool)));
     QSignalSpy textMessageReceivedSpy(&dataProcessor, SIGNAL(textMessageReceived(QString)));
     dataProcessor.process(&buffer);
-    QCOMPARE(errorReceivedSpy.count(), 0);
-    QCOMPARE(pingReceivedSpy.count(), 0);
-    QCOMPARE(pongReceivedSpy.count(), 0);
-    QCOMPARE(closeReceivedSpy.count(), 0);
-    QCOMPARE(binaryFrameReceivedSpy.count(), 1);
-    QCOMPARE(binaryMessageReceivedSpy.count(), 1);
-    QCOMPARE(textFrameReceivedSpy.count(), 0);
-    QCOMPARE(textMessageReceivedSpy.count(), 0);
+    QCOMPARE(errorReceivedSpy.size(), 0);
+    QCOMPARE(pingReceivedSpy.size(), 0);
+    QCOMPARE(pongReceivedSpy.size(), 0);
+    QCOMPARE(closeReceivedSpy.size(), 0);
+    QCOMPARE(binaryFrameReceivedSpy.size(), 1);
+    QCOMPARE(binaryMessageReceivedSpy.size(), 1);
+    QCOMPARE(textFrameReceivedSpy.size(), 0);
+    QCOMPARE(textMessageReceivedSpy.size(), 0);
     QList<QVariant> arguments = binaryFrameReceivedSpy.takeFirst();
-    QCOMPARE(arguments.at(0).toByteArray().length(), payload.length());
+    QCOMPARE(arguments.at(0).toByteArray().size(), payload.size());
     arguments = binaryMessageReceivedSpy.takeFirst();
-    QCOMPARE(arguments.at(0).toByteArray().length(), payload.length());
+    QCOMPARE(arguments.at(0).toByteArray().size(), payload.size());
     buffer.close();
 }
 
@@ -316,20 +316,20 @@ void tst_DataProcessor::goodTextFrame()
 
     data.append(char(FIN | QWebSocketProtocol::OpCodeText));
 
-    if (payload.length() < 126)
+    if (payload.size() < 126)
     {
-        data.append(char(payload.length()));
+        data.append(char(payload.size()));
     }
-    else if (payload.length() < 65536)
+    else if (payload.size() < 65536)
     {
-        quint16 swapped = qToBigEndian<quint16>(payload.length());
+        quint16 swapped = qToBigEndian<quint16>(payload.size());
         const char *wireRepresentation
                 = static_cast<const char *>(static_cast<const void *>(&swapped));
         data.append(char(126)).append(wireRepresentation, 2);
     }
     else
     {
-        quint64 swapped = qToBigEndian<quint64>(payload.length());
+        quint64 swapped = qToBigEndian<quint64>(payload.size());
         const char *wireRepresentation
                 = static_cast<const char *>(static_cast<const void *>(&swapped));
         data.append(char(127)).append(wireRepresentation, 8);
@@ -352,18 +352,18 @@ void tst_DataProcessor::goodTextFrame()
 
     dataProcessor.process(&buffer);
 
-    QCOMPARE(errorReceivedSpy.count(), 0);
-    QCOMPARE(pingReceivedSpy.count(), 0);
-    QCOMPARE(pongReceivedSpy.count(), 0);
-    QCOMPARE(closeReceivedSpy.count(), 0);
-    QCOMPARE(textFrameReceivedSpy.count(), 1);
-    QCOMPARE(textMessageReceivedSpy.count(), 1);
-    QCOMPARE(binaryFrameReceivedSpy.count(), 0);
-    QCOMPARE(binaryMessageReceivedSpy.count(), 0);
+    QCOMPARE(errorReceivedSpy.size(), 0);
+    QCOMPARE(pingReceivedSpy.size(), 0);
+    QCOMPARE(pongReceivedSpy.size(), 0);
+    QCOMPARE(closeReceivedSpy.size(), 0);
+    QCOMPARE(textFrameReceivedSpy.size(), 1);
+    QCOMPARE(textMessageReceivedSpy.size(), 1);
+    QCOMPARE(binaryFrameReceivedSpy.size(), 0);
+    QCOMPARE(binaryMessageReceivedSpy.size(), 0);
     QList<QVariant> arguments = textFrameReceivedSpy.takeFirst();
-    QCOMPARE(arguments.at(0).toString().length(), size);
+    QCOMPARE(arguments.at(0).toString().size(), size);
     arguments = textMessageReceivedSpy.takeFirst();
-    QCOMPARE(arguments.at(0).toString().length(), size);
+    QCOMPARE(arguments.at(0).toString().size(), size);
     buffer.close();
 }
 
@@ -389,14 +389,14 @@ void tst_DataProcessor::goodControlFrame()
     buffer.setData(data);
     buffer.open(QIODevice::ReadOnly);
     dataProcessor.process(&buffer);
-    QCOMPARE(errorReceivedSpy.count(), 0);
-    QCOMPARE(textFrameReceivedSpy.count(), 0);
-    QCOMPARE(textMessageReceivedSpy.count(), 0);
-    QCOMPARE(binaryFrameReceivedSpy.count(), 0);
-    QCOMPARE(binaryMessageReceivedSpy.count(), 0);
-    QCOMPARE(closeFrameReceivedSpy.count(), 0);
-    QCOMPARE(pongReceivedSpy.count(), 0);
-    QCOMPARE(pingReceivedSpy.count(), 1);
+    QCOMPARE(errorReceivedSpy.size(), 0);
+    QCOMPARE(textFrameReceivedSpy.size(), 0);
+    QCOMPARE(textMessageReceivedSpy.size(), 0);
+    QCOMPARE(binaryFrameReceivedSpy.size(), 0);
+    QCOMPARE(binaryMessageReceivedSpy.size(), 0);
+    QCOMPARE(closeFrameReceivedSpy.size(), 0);
+    QCOMPARE(pongReceivedSpy.size(), 0);
+    QCOMPARE(pingReceivedSpy.size(), 1);
     buffer.close();
 
     data.clear();
@@ -407,14 +407,14 @@ void tst_DataProcessor::goodControlFrame()
     buffer.setData(data);
     buffer.open(QIODevice::ReadOnly);
     dataProcessor.process(&buffer);
-    QCOMPARE(errorReceivedSpy.count(), 0);
-    QCOMPARE(textFrameReceivedSpy.count(), 0);
-    QCOMPARE(textMessageReceivedSpy.count(), 0);
-    QCOMPARE(binaryFrameReceivedSpy.count(), 0);
-    QCOMPARE(binaryMessageReceivedSpy.count(), 0);
-    QCOMPARE(closeFrameReceivedSpy.count(), 0);
-    QCOMPARE(pingReceivedSpy.count(), 0);
-    QCOMPARE(pongReceivedSpy.count(), 1);
+    QCOMPARE(errorReceivedSpy.size(), 0);
+    QCOMPARE(textFrameReceivedSpy.size(), 0);
+    QCOMPARE(textMessageReceivedSpy.size(), 0);
+    QCOMPARE(binaryFrameReceivedSpy.size(), 0);
+    QCOMPARE(binaryMessageReceivedSpy.size(), 0);
+    QCOMPARE(closeFrameReceivedSpy.size(), 0);
+    QCOMPARE(pingReceivedSpy.size(), 0);
+    QCOMPARE(pongReceivedSpy.size(), 1);
     buffer.close();
 }
 
@@ -539,14 +539,14 @@ void tst_DataProcessor::goodOpcodes()
 
     dataProcessor.process(&buffer);
 
-    QCOMPARE(errorReceivedSpy.count(), 0);
-    QCOMPARE(pingReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodePing ? 1 : 0);
-    QCOMPARE(pongReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodePong ? 1 : 0);
-    QCOMPARE(closeReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeClose ? 1 : 0);
-    QCOMPARE(textFrameReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeText ? 1 : 0);
-    QCOMPARE(textMessageReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeText ? 1 : 0);
-    QCOMPARE(binaryFrameReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeBinary ? 1 : 0);
-    QCOMPARE(binaryMessageReceivedSpy.count(), opCode == QWebSocketProtocol::OpCodeBinary ? 1 : 0);
+    QCOMPARE(errorReceivedSpy.size(), 0);
+    QCOMPARE(pingReceivedSpy.size(), opCode == QWebSocketProtocol::OpCodePing ? 1 : 0);
+    QCOMPARE(pongReceivedSpy.size(), opCode == QWebSocketProtocol::OpCodePong ? 1 : 0);
+    QCOMPARE(closeReceivedSpy.size(), opCode == QWebSocketProtocol::OpCodeClose ? 1 : 0);
+    QCOMPARE(textFrameReceivedSpy.size(), opCode == QWebSocketProtocol::OpCodeText ? 1 : 0);
+    QCOMPARE(textMessageReceivedSpy.size(), opCode == QWebSocketProtocol::OpCodeText ? 1 : 0);
+    QCOMPARE(binaryFrameReceivedSpy.size(), opCode == QWebSocketProtocol::OpCodeBinary ? 1 : 0);
+    QCOMPARE(binaryMessageReceivedSpy.size(), opCode == QWebSocketProtocol::OpCodeBinary ? 1 : 0);
 
     buffer.close();
 }
@@ -564,7 +564,7 @@ void tst_DataProcessor::goodCloseFrame()
     data.append(char(FIN | QWebSocketProtocol::OpCodeClose));
     if (swapped != 0)
     {
-        data.append(char(payload.length() + 2)).append(wireRepresentation, 2).append(payload.toUtf8());
+        data.append(char(payload.size() + 2)).append(wireRepresentation, 2).append(payload.toUtf8());
     }
     else
     {
@@ -588,17 +588,17 @@ void tst_DataProcessor::goodCloseFrame()
 
     dataProcessor.process(&buffer);
 
-    QCOMPARE(errorReceivedSpy.count(), 0);
-    QCOMPARE(pingReceivedSpy.count(), 0);
-    QCOMPARE(pongReceivedSpy.count(), 0);
-    QCOMPARE(closeFrameReceivedSpy.count(), 1);
-    QCOMPARE(textFrameReceivedSpy.count(), 0);
-    QCOMPARE(textMessageReceivedSpy.count(), 0);
-    QCOMPARE(binaryFrameReceivedSpy.count(), 0);
-    QCOMPARE(binaryMessageReceivedSpy.count(), 0);
+    QCOMPARE(errorReceivedSpy.size(), 0);
+    QCOMPARE(pingReceivedSpy.size(), 0);
+    QCOMPARE(pongReceivedSpy.size(), 0);
+    QCOMPARE(closeFrameReceivedSpy.size(), 1);
+    QCOMPARE(textFrameReceivedSpy.size(), 0);
+    QCOMPARE(textMessageReceivedSpy.size(), 0);
+    QCOMPARE(binaryFrameReceivedSpy.size(), 0);
+    QCOMPARE(binaryMessageReceivedSpy.size(), 0);
     QList<QVariant> arguments = closeFrameReceivedSpy.takeFirst();
     QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), closeCode);
-    QCOMPARE(arguments.at(1).toString().length(), payload.length());
+    QCOMPARE(arguments.at(1).toString().size(), payload.size());
     buffer.close();
 }
 
@@ -674,14 +674,14 @@ void tst_DataProcessor::nonCharacterCodes()
         buffer.open(QIODevice::ReadOnly);
         dataProcessor.process(&buffer);
 
-        QCOMPARE(errorSpy.count(), 0);
-        QCOMPARE(closeSpy.count(), 0);
-        QCOMPARE(pingFrameSpy.count(), 0);
-        QCOMPARE(pongFrameSpy.count(), 0);
-        QCOMPARE(textFrameSpy.count(), 1);
-        QCOMPARE(textMessageSpy.count(), 1);
-        QCOMPARE(binaryFrameSpy.count(), 0);
-        QCOMPARE(binaryMessageSpy.count(), 0);
+        QCOMPARE(errorSpy.size(), 0);
+        QCOMPARE(closeSpy.size(), 0);
+        QCOMPARE(pingFrameSpy.size(), 0);
+        QCOMPARE(pongFrameSpy.size(), 0);
+        QCOMPARE(textFrameSpy.size(), 1);
+        QCOMPARE(textMessageSpy.size(), 1);
+        QCOMPARE(binaryFrameSpy.size(), 0);
+        QCOMPARE(binaryMessageSpy.size(), 0);
 
         QVariantList arguments = textFrameSpy.takeFirst();
         QCOMPARE(arguments.at(0).value<QString>().toUtf8(), payload);
@@ -719,15 +719,15 @@ void tst_DataProcessor::frameTooSmall()
 
     dataProcessor.process(&buffer);
 
-    QTRY_VERIFY_WITH_TIMEOUT(errorSpy.count(), 7000);
-    QCOMPARE(errorSpy.count(), 1);
-    QCOMPARE(closeSpy.count(), 0);
-    QCOMPARE(pingMessageSpy.count(), 0);
-    QCOMPARE(pongMessageSpy.count(), 0);
-    QCOMPARE(textMessageSpy.count(), 0);
-    QCOMPARE(binaryMessageSpy.count(), 0);
-    QCOMPARE(textFrameSpy.count(), 0);
-    QCOMPARE(binaryFrameSpy.count(), 0);
+    QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), 7000);
+    QCOMPARE(errorSpy.size(), 1);
+    QCOMPARE(closeSpy.size(), 0);
+    QCOMPARE(pingMessageSpy.size(), 0);
+    QCOMPARE(pongMessageSpy.size(), 0);
+    QCOMPARE(textMessageSpy.size(), 0);
+    QCOMPARE(binaryMessageSpy.size(), 0);
+    QCOMPARE(textFrameSpy.size(), 0);
+    QCOMPARE(binaryFrameSpy.size(), 0);
 
     QList<QVariant> arguments = errorSpy.takeFirst();
     QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
@@ -752,15 +752,15 @@ void tst_DataProcessor::frameTooSmall()
 
     dataProcessor.process(&buffer);
 
-    QTRY_VERIFY_WITH_TIMEOUT(errorSpy.count(), 7000);
-    QCOMPARE(errorSpy.count(), 1);
-    QCOMPARE(closeSpy.count(), 0);
-    QCOMPARE(pingMessageSpy.count(), 0);
-    QCOMPARE(pongMessageSpy.count(), 0);
-    QCOMPARE(textMessageSpy.count(), 0);
-    QCOMPARE(binaryMessageSpy.count(), 0);
-    QCOMPARE(textFrameSpy.count(), 0);
-    QCOMPARE(binaryFrameSpy.count(), 0);
+    QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), 7000);
+    QCOMPARE(errorSpy.size(), 1);
+    QCOMPARE(closeSpy.size(), 0);
+    QCOMPARE(pingMessageSpy.size(), 0);
+    QCOMPARE(pongMessageSpy.size(), 0);
+    QCOMPARE(textMessageSpy.size(), 0);
+    QCOMPARE(binaryMessageSpy.size(), 0);
+    QCOMPARE(textFrameSpy.size(), 0);
+    QCOMPARE(binaryFrameSpy.size(), 0);
 
     arguments = errorSpy.takeFirst();
     QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
@@ -785,15 +785,15 @@ void tst_DataProcessor::frameTooSmall()
 
         dataProcessor.process(&buffer);
 
-        QTRY_VERIFY_WITH_TIMEOUT(errorSpy.count(), 7000);
-        QCOMPARE(errorSpy.count(), 1);
-        QCOMPARE(closeSpy.count(), 0);
-        QCOMPARE(pingMessageSpy.count(), 0);
-        QCOMPARE(pongMessageSpy.count(), 0);
-        QCOMPARE(textMessageSpy.count(), 0);
-        QCOMPARE(binaryMessageSpy.count(), 0);
-        QCOMPARE(textFrameSpy.count(), 1);
-        QCOMPARE(binaryFrameSpy.count(), 0);
+        QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), 7000);
+        QCOMPARE(errorSpy.size(), 1);
+        QCOMPARE(closeSpy.size(), 0);
+        QCOMPARE(pingMessageSpy.size(), 0);
+        QCOMPARE(pongMessageSpy.size(), 0);
+        QCOMPARE(textMessageSpy.size(), 0);
+        QCOMPARE(binaryMessageSpy.size(), 0);
+        QCOMPARE(textFrameSpy.size(), 1);
+        QCOMPARE(binaryFrameSpy.size(), 0);
 
         errorSpy.clear();
         closeSpy.clear();
@@ -813,15 +813,15 @@ void tst_DataProcessor::frameTooSmall()
         buffer.open(QIODevice::ReadOnly);
         dataProcessor.process(&buffer);
 
-        QTRY_VERIFY_WITH_TIMEOUT(errorSpy.count(), 7000);
-        QCOMPARE(errorSpy.count(), 1);
-        QCOMPARE(closeSpy.count(), 0);
-        QCOMPARE(pingMessageSpy.count(), 0);
-        QCOMPARE(pongMessageSpy.count(), 0);
-        QCOMPARE(textMessageSpy.count(), 0);
-        QCOMPARE(binaryMessageSpy.count(), 0);
-        QCOMPARE(textFrameSpy.count(), 0);
-        QCOMPARE(binaryFrameSpy.count(), 0);
+        QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), 7000);
+        QCOMPARE(errorSpy.size(), 1);
+        QCOMPARE(closeSpy.size(), 0);
+        QCOMPARE(pingMessageSpy.size(), 0);
+        QCOMPARE(pongMessageSpy.size(), 0);
+        QCOMPARE(textMessageSpy.size(), 0);
+        QCOMPARE(binaryMessageSpy.size(), 0);
+        QCOMPARE(textFrameSpy.size(), 0);
+        QCOMPARE(binaryFrameSpy.size(), 0);
 
         QList<QVariant> arguments = errorSpy.takeFirst();
         QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
@@ -843,15 +843,15 @@ void tst_DataProcessor::frameTooSmall()
         buffer.open(QIODevice::ReadOnly);
         dataProcessor.process(&buffer);
 
-        QTRY_VERIFY_WITH_TIMEOUT(errorSpy.count(), 7000);
-        QCOMPARE(errorSpy.count(), 1);
-        QCOMPARE(closeSpy.count(), 0);
-        QCOMPARE(pingMessageSpy.count(), 0);
-        QCOMPARE(pongMessageSpy.count(), 0);
-        QCOMPARE(textMessageSpy.count(), 0);
-        QCOMPARE(binaryMessageSpy.count(), 0);
-        QCOMPARE(textFrameSpy.count(), 1);
-        QCOMPARE(binaryFrameSpy.count(), 0);
+        QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), 7000);
+        QCOMPARE(errorSpy.size(), 1);
+        QCOMPARE(closeSpy.size(), 0);
+        QCOMPARE(pingMessageSpy.size(), 0);
+        QCOMPARE(pongMessageSpy.size(), 0);
+        QCOMPARE(textMessageSpy.size(), 0);
+        QCOMPARE(binaryMessageSpy.size(), 0);
+        QCOMPARE(textFrameSpy.size(), 1);
+        QCOMPARE(binaryFrameSpy.size(), 0);
 
         buffer.close();
         data.clear();
@@ -872,15 +872,15 @@ void tst_DataProcessor::frameTooSmall()
         buffer.open(QIODevice::ReadOnly);
 
         dataProcessor.process(&buffer);
-        QTRY_VERIFY_WITH_TIMEOUT(errorSpy.count(), 7000);
-        QCOMPARE(errorSpy.count(), 1);
-        QCOMPARE(closeSpy.count(), 0);
-        QCOMPARE(pingMessageSpy.count(), 0);
-        QCOMPARE(pongMessageSpy.count(), 0);
-        QCOMPARE(textMessageSpy.count(), 0);
-        QCOMPARE(binaryMessageSpy.count(), 0);
-        QCOMPARE(textFrameSpy.count(), 0);
-        QCOMPARE(binaryFrameSpy.count(), 0);
+        QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), 7000);
+        QCOMPARE(errorSpy.size(), 1);
+        QCOMPARE(closeSpy.size(), 0);
+        QCOMPARE(pingMessageSpy.size(), 0);
+        QCOMPARE(pongMessageSpy.size(), 0);
+        QCOMPARE(textMessageSpy.size(), 0);
+        QCOMPARE(binaryMessageSpy.size(), 0);
+        QCOMPARE(textFrameSpy.size(), 0);
+        QCOMPARE(binaryFrameSpy.size(), 0);
         arguments = errorSpy.takeFirst();
         QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
                  QWebSocketProtocol::CloseCodeGoingAway);
@@ -1355,14 +1355,14 @@ void tst_DataProcessor::invalidPayloadInCloseFrame()
     buffer.setData(data);
     buffer.open(QIODevice::ReadOnly);
     dataProcessor.process(&buffer);
-    QCOMPARE(closeSpy.count(), 1);
-    QCOMPARE(errorSpy.count(), 0);
-    QCOMPARE(pingMessageSpy.count(), 0);
-    QCOMPARE(pongMessageSpy.count(), 0);
-    QCOMPARE(textMessageSpy.count(), 0);
-    QCOMPARE(binaryMessageSpy.count(), 0);
-    QCOMPARE(textFrameSpy.count(), 0);
-    QCOMPARE(binaryFrameSpy.count(), 0);
+    QCOMPARE(closeSpy.size(), 1);
+    QCOMPARE(errorSpy.size(), 0);
+    QCOMPARE(pingMessageSpy.size(), 0);
+    QCOMPARE(pongMessageSpy.size(), 0);
+    QCOMPARE(textMessageSpy.size(), 0);
+    QCOMPARE(binaryMessageSpy.size(), 0);
+    QCOMPARE(textFrameSpy.size(), 0);
+    QCOMPARE(binaryFrameSpy.size(), 0);
     QVariantList arguments = closeSpy.takeFirst();
     QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), expectedCloseCode);
     buffer.close();
@@ -1461,12 +1461,12 @@ void tst_DataProcessor::doTest(int timeout)
     buffer.setData(data);
     buffer.open(QIODevice::ReadOnly);
     dataProcessor.process(&buffer);
-    QTRY_VERIFY_WITH_TIMEOUT(errorSpy.count(), timeout);
-    QCOMPARE(errorSpy.count(), 1);
-    QCOMPARE(textMessageSpy.count(), 0);
-    QCOMPARE(binaryMessageSpy.count(), 0);
-    QCOMPARE(textFrameSpy.count(), isContinuationFrame ? 1 : 0);
-    QCOMPARE(binaryFrameSpy.count(), 0);
+    QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), timeout);
+    QCOMPARE(errorSpy.size(), 1);
+    QCOMPARE(textMessageSpy.size(), 0);
+    QCOMPARE(binaryMessageSpy.size(), 0);
+    QCOMPARE(textFrameSpy.size(), isContinuationFrame ? 1 : 0);
+    QCOMPARE(binaryFrameSpy.size(), 0);
     QVariantList arguments = errorSpy.takeFirst();
     QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), expectedCloseCode);
     buffer.close();
@@ -1501,12 +1501,12 @@ void tst_DataProcessor::doCloseFrameTest()
     buffer.setData(data);
     buffer.open(QIODevice::ReadOnly);
     dataProcessor.process(&buffer);
-    QCOMPARE(closeSpy.count(), 1);
-    QCOMPARE(errorSpy.count(), 0);
-    QCOMPARE(textMessageSpy.count(), 0);
-    QCOMPARE(binaryMessageSpy.count(), 0);
-    QCOMPARE(textFrameSpy.count(), 0);
-    QCOMPARE(binaryFrameSpy.count(), 0);
+    QCOMPARE(closeSpy.size(), 1);
+    QCOMPARE(errorSpy.size(), 0);
+    QCOMPARE(textMessageSpy.size(), 0);
+    QCOMPARE(binaryMessageSpy.size(), 0);
+    QCOMPARE(textFrameSpy.size(), 0);
+    QCOMPARE(binaryFrameSpy.size(), 0);
     QVariantList arguments = closeSpy.takeFirst();
     QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), expectedCloseCode);
     buffer.close();
@@ -1678,7 +1678,7 @@ void tst_DataProcessor::invalidUTF8(const char *dataTag, const char *utf8Sequenc
         QTest::newRow(QStringLiteral("Close frame with invalid UTF8-sequence: %1")
                       .arg(dataTag).toLatin1().constData())
                 << quint8(FIN | QWebSocketProtocol::OpCodeClose)
-                << quint8(payload.length() + 2)
+                << quint8(payload.size() + 2)
                 << QByteArray(wireRepresentation, 2).append(payload)
                 << false
                 << QWebSocketProtocol::CloseCodeWrongDatatype;
@@ -1688,7 +1688,7 @@ void tst_DataProcessor::invalidUTF8(const char *dataTag, const char *utf8Sequenc
         QTest::newRow(QStringLiteral("Text frame with invalid UTF8-sequence: %1")
                       .arg(dataTag).toLatin1().constData())
                 << quint8(FIN | QWebSocketProtocol::OpCodeText)
-                << quint8(payload.length())
+                << quint8(payload.size())
                 << payload
                 << false
                 << QWebSocketProtocol::CloseCodeWrongDatatype;
@@ -1696,7 +1696,7 @@ void tst_DataProcessor::invalidUTF8(const char *dataTag, const char *utf8Sequenc
         QTest::newRow(QStringLiteral("Continuation text frame with invalid UTF8-sequence: %1")
                       .arg(dataTag).toLatin1().constData())
                 << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
-                << quint8(payload.length())
+                << quint8(payload.size())
                 << payload
                 << true
                 << QWebSocketProtocol::CloseCodeWrongDatatype;
@@ -1836,7 +1836,7 @@ void tst_DataProcessor::clearDataBuffers()
     const QByteArray binaryData("Hello!");
     QByteArray data;
     data.append(char(FIN | QWebSocketProtocol::OpCodeBinary));
-    data.append(char(binaryData.length()));
+    data.append(char(binaryData.size()));
     data.append(binaryData);
 
     QWebSocketDataProcessor dataProcessor;
diff --git a/tests/auto/websockets/handshakerequest/tst_handshakerequest.cpp b/tests/auto/websockets/handshakerequest/tst_handshakerequest.cpp
index 8f92346..1c0da5c 100644
--- a/tests/auto/websockets/handshakerequest/tst_handshakerequest.cpp
+++ b/tests/auto/websockets/handshakerequest/tst_handshakerequest.cpp
@@ -75,30 +75,30 @@ void tst_HandshakeRequest::tst_initialization()
         QCOMPARE(request.port(), 0);
         QVERIFY(!request.isSecure());
         QVERIFY(!request.isValid());
-        QCOMPARE(request.extensions().length(), 0);
-        QCOMPARE(request.protocols().length(), 0);
+        QCOMPARE(request.extensions().size(), 0);
+        QCOMPARE(request.protocols().size(), 0);
         QCOMPARE(request.headers().size(), 0);
-        QCOMPARE(request.key().length(), 0);
-        QCOMPARE(request.origin().length(), 0);
-        QCOMPARE(request.host().length(), 0);
+        QCOMPARE(request.key().size(), 0);
+        QCOMPARE(request.origin().size(), 0);
+        QCOMPARE(request.host().size(), 0);
         QVERIFY(request.requestUrl().isEmpty());
-        QCOMPARE(request.resourceName().length(), 0);
-        QCOMPARE(request.versions().length(), 0);
+        QCOMPARE(request.resourceName().size(), 0);
+        QCOMPARE(request.versions().size(), 0);
     }
     {
         QWebSocketHandshakeRequest request(80, true);
         QCOMPARE(request.port(), 80);
         QVERIFY(request.isSecure());
         QVERIFY(!request.isValid());
-        QCOMPARE(request.extensions().length(), 0);
-        QCOMPARE(request.protocols().length(), 0);
+        QCOMPARE(request.extensions().size(), 0);
+        QCOMPARE(request.protocols().size(), 0);
         QCOMPARE(request.headers().size(), 0);
-        QCOMPARE(request.key().length(), 0);
-        QCOMPARE(request.origin().length(), 0);
-        QCOMPARE(request.host().length(), 0);
+        QCOMPARE(request.key().size(), 0);
+        QCOMPARE(request.origin().size(), 0);
+        QCOMPARE(request.host().size(), 0);
         QVERIFY(request.requestUrl().isEmpty());
-        QCOMPARE(request.resourceName().length(), 0);
-        QCOMPARE(request.versions().length(), 0);
+        QCOMPARE(request.resourceName().size(), 0);
+        QCOMPARE(request.versions().size(), 0);
     }
     {
         QWebSocketHandshakeRequest request(80, true);
@@ -106,15 +106,15 @@ void tst_HandshakeRequest::tst_initialization()
         QCOMPARE(request.port(), 80);
         QVERIFY(request.isSecure());
         QVERIFY(!request.isValid());
-        QCOMPARE(request.extensions().length(), 0);
-        QCOMPARE(request.protocols().length(), 0);
+        QCOMPARE(request.extensions().size(), 0);
+        QCOMPARE(request.protocols().size(), 0);
         QCOMPARE(request.headers().size(), 0);
-        QCOMPARE(request.key().length(), 0);
-        QCOMPARE(request.origin().length(), 0);
-        QCOMPARE(request.host().length(), 0);
+        QCOMPARE(request.key().size(), 0);
+        QCOMPARE(request.origin().size(), 0);
+        QCOMPARE(request.host().size(), 0);
         QVERIFY(request.requestUrl().isEmpty());
-        QCOMPARE(request.resourceName().length(), 0);
-        QCOMPARE(request.versions().length(), 0);
+        QCOMPARE(request.resourceName().size(), 0);
+        QCOMPARE(request.versions().size(), 0);
     }
 }
 
@@ -195,15 +195,15 @@ void tst_HandshakeRequest::tst_invalidStream()
     QVERIFY(!request.isValid());
     QCOMPARE(request.port(), 80);
     QVERIFY(request.isSecure());
-    QCOMPARE(request.extensions().length(), 0);
-    QCOMPARE(request.protocols().length(), 0);
+    QCOMPARE(request.extensions().size(), 0);
+    QCOMPARE(request.protocols().size(), 0);
     QCOMPARE(request.headers().size(), 0);
-    QCOMPARE(request.key().length(), 0);
-    QCOMPARE(request.origin().length(), 0);
-    QCOMPARE(request.host().length(), 0);
+    QCOMPARE(request.key().size(), 0);
+    QCOMPARE(request.origin().size(), 0);
+    QCOMPARE(request.host().size(), 0);
     QVERIFY(request.requestUrl().isEmpty());
-    QCOMPARE(request.resourceName().length(), 0);
-    QCOMPARE(request.versions().length(), 0);
+    QCOMPARE(request.resourceName().size(), 0);
+    QCOMPARE(request.versions().size(), 0);
 }
 
 /*
@@ -228,15 +228,15 @@ void tst_HandshakeRequest::tst_multipleValuesInConnectionHeader()
     QVERIFY(request.isValid());
     QCOMPARE(request.port(), 80);
     QVERIFY(!request.isSecure());
-    QCOMPARE(request.extensions().length(), 0);
-    QCOMPARE(request.protocols().length(), 0);
+    QCOMPARE(request.extensions().size(), 0);
+    QCOMPARE(request.protocols().size(), 0);
     QCOMPARE(request.headers().size(), 5);
-    QCOMPARE(request.key().length(), 9);
-    QCOMPARE(request.origin().length(), 0);
+    QCOMPARE(request.key().size(), 9);
+    QCOMPARE(request.origin().size(), 0);
     QCOMPARE(request.requestUrl(), QUrl("ws://foo.com/test"));
     QCOMPARE(request.host(), QStringLiteral("foo.com"));
-    QCOMPARE(request.resourceName().length(), 5);
-    QCOMPARE(request.versions().length(), 1);
+    QCOMPARE(request.resourceName().size(), 5);
+    QCOMPARE(request.versions().size(), 1);
     QCOMPARE(request.versions().at(0), QWebSocketProtocol::Version13);
 }
 
@@ -261,7 +261,7 @@ void tst_HandshakeRequest::tst_parsingWhitespaceInHeaders()
 
     QVERIFY(request.isValid());
     QCOMPARE(request.key(), QStringLiteral("AVD FBDDFF"));
-    QCOMPARE(request.versions().length(), 1);
+    QCOMPARE(request.versions().size(), 1);
     QCOMPARE(request.versions().at(0), QWebSocketProtocol::Version13);
 }
 
@@ -280,8 +280,8 @@ void tst_HandshakeRequest::tst_multipleVersions()
     QVERIFY(request.isValid());
     QCOMPARE(request.port(), 80);
     QVERIFY(!request.isSecure());
-    QCOMPARE(request.extensions().length(), 0);
-    QCOMPARE(request.protocols().length(), 0);
+    QCOMPARE(request.extensions().size(), 0);
+    QCOMPARE(request.protocols().size(), 0);
     QCOMPARE(request.headers().size(), 5);
     QVERIFY(request.hasHeader("host"));
     QVERIFY(request.hasHeader("sec-websocket-version"));
@@ -289,11 +289,11 @@ void tst_HandshakeRequest::tst_multipleVersions()
     QVERIFY(request.hasHeader("upgrade"));
     QVERIFY(request.hasHeader("connection"));
     QCOMPARE(request.key(), QStringLiteral("AVDFBDDFF"));
-    QCOMPARE(request.origin().length(), 0);
+    QCOMPARE(request.origin().size(), 0);
     QCOMPARE(request.requestUrl(), QUrl("ws://foo.com/test"));
     QCOMPARE(request.host(), QStringLiteral("foo.com"));
-    QCOMPARE(request.resourceName().length(), 5);
-    QCOMPARE(request.versions().length(), 6);
+    QCOMPARE(request.resourceName().size(), 5);
+    QCOMPARE(request.versions().size(), 6);
     //should be 13 since the list is ordered in decreasing order
     QCOMPARE(request.versions().at(0), QWebSocketProtocol::Version13);
 }
@@ -345,7 +345,7 @@ void tst_HandshakeRequest::tst_qtbug_48123_data()
     QString legalHeader = header;
     const QString headerKey = QStringLiteral("X-CUSTOM-KEY: ");
     legalHeader.append(headerKey);
-    legalHeader.append(QString(MAX_HEADERLINE_LENGTH - headerKey.length(), QLatin1Char('c')));
+    legalHeader.append(QString(MAX_HEADERLINE_LENGTH - headerKey.size(), QLatin1Char('c')));
     legalHeader.append(QStringLiteral("\r\n\r\n"));
 
     QTest::newRow("headerline with maximum length") << legalHeader << true;
diff --git a/tests/auto/websockets/qwebsocket/tst_qwebsocket.cpp b/tests/auto/websockets/qwebsocket/tst_qwebsocket.cpp
index 09310a3..bfc1ea2 100644
--- a/tests/auto/websockets/qwebsocket/tst_qwebsocket.cpp
+++ b/tests/auto/websockets/qwebsocket/tst_qwebsocket.cpp
@@ -312,17 +312,17 @@ void tst_QWebSocket::tst_invalidOpen()
     QCOMPARE(socket.sendTextMessage(QStringLiteral("A text message")), 0);
     QCOMPARE(socket.sendBinaryMessage(QByteArrayLiteral("A text message")), 0);
 
-    if (errorSpy.count() == 0)
+    if (errorSpy.size() == 0)
         QVERIFY(errorSpy.wait());
-    QCOMPARE(errorSpy.count(), 1);
+    QCOMPARE(errorSpy.size(), 1);
     QList<QVariant> arguments = errorSpy.takeFirst();
     QAbstractSocket::SocketError socketError =
             qvariant_cast<QAbstractSocket::SocketError>(arguments.at(0));
     QCOMPARE(socketError, QAbstractSocket::ConnectionRefusedError);
-    QCOMPARE(aboutToCloseSpy.count(), 0);
-    QCOMPARE(connectedSpy.count(), 0);
-    QCOMPARE(disconnectedSpy.count(), disconnectedCount);
-    QCOMPARE(stateChangedSpy.count(), stateChangedCount);
+    QCOMPARE(aboutToCloseSpy.size(), 0);
+    QCOMPARE(connectedSpy.size(), 0);
+    QCOMPARE(disconnectedSpy.size(), disconnectedCount);
+    QCOMPARE(stateChangedSpy.size(), stateChangedCount);
     if (stateChangedCount == 2) {
         arguments = stateChangedSpy.takeFirst();
         QAbstractSocket::SocketState socketState =
@@ -331,13 +331,13 @@ void tst_QWebSocket::tst_invalidOpen()
         socketState = qvariant_cast<QAbstractSocket::SocketState>(arguments.at(0));
         QCOMPARE(socketState, QAbstractSocket::UnconnectedState);
     }
-    QCOMPARE(readChannelFinishedSpy.count(), 0);
-    QCOMPARE(textFrameReceivedSpy.count(), 0);
-    QCOMPARE(binaryFrameReceivedSpy.count(), 0);
-    QCOMPARE(textMessageReceivedSpy.count(), 0);
-    QCOMPARE(binaryMessageReceivedSpy.count(), 0);
-    QCOMPARE(pongSpy.count(), 0);
-    QCOMPARE(bytesWrittenSpy.count(), 0);
+    QCOMPARE(readChannelFinishedSpy.size(), 0);
+    QCOMPARE(textFrameReceivedSpy.size(), 0);
+    QCOMPARE(binaryFrameReceivedSpy.size(), 0);
+    QCOMPARE(textMessageReceivedSpy.size(), 0);
+    QCOMPARE(binaryMessageReceivedSpy.size(), 0);
+    QCOMPARE(pongSpy.size(), 0);
+    QCOMPARE(bytesWrittenSpy.size(), 0);
 }
 
 void tst_QWebSocket::tst_invalidOrigin()
@@ -378,28 +378,28 @@ void tst_QWebSocket::tst_invalidOrigin()
 
     QVERIFY(errorSpy.wait());
 
-    QCOMPARE(errorSpy.count(), 1);
+    QCOMPARE(errorSpy.size(), 1);
     QList<QVariant> arguments = errorSpy.takeFirst();
     QAbstractSocket::SocketError socketError =
             qvariant_cast<QAbstractSocket::SocketError>(arguments.at(0));
     QCOMPARE(socketError, QAbstractSocket::ConnectionRefusedError);
-    QCOMPARE(aboutToCloseSpy.count(), 0);
-    QCOMPARE(connectedSpy.count(), 0);
-    QCOMPARE(disconnectedSpy.count(), 1);
-    QCOMPARE(stateChangedSpy.count(), 2);   //connectingstate, unconnectedstate
+    QCOMPARE(aboutToCloseSpy.size(), 0);
+    QCOMPARE(connectedSpy.size(), 0);
+    QCOMPARE(disconnectedSpy.size(), 1);
+    QCOMPARE(stateChangedSpy.size(), 2);   //connectingstate, unconnectedstate
     arguments = stateChangedSpy.takeFirst();
     QAbstractSocket::SocketState socketState =
             qvariant_cast<QAbstractSocket::SocketState>(arguments.at(0));
     arguments = stateChangedSpy.takeFirst();
     socketState = qvariant_cast<QAbstractSocket::SocketState>(arguments.at(0));
     QCOMPARE(socketState, QAbstractSocket::UnconnectedState);
-    QCOMPARE(readChannelFinishedSpy.count(), 0);
-    QCOMPARE(textFrameReceivedSpy.count(), 0);
-    QCOMPARE(binaryFrameReceivedSpy.count(), 0);
-    QCOMPARE(textMessageReceivedSpy.count(), 0);
-    QCOMPARE(binaryMessageReceivedSpy.count(), 0);
-    QCOMPARE(pongSpy.count(), 0);
-    QCOMPARE(bytesWrittenSpy.count(), 0);
+    QCOMPARE(readChannelFinishedSpy.size(), 0);
+    QCOMPARE(textFrameReceivedSpy.size(), 0);
+    QCOMPARE(binaryFrameReceivedSpy.size(), 0);
+    QCOMPARE(textMessageReceivedSpy.size(), 0);
+    QCOMPARE(binaryMessageReceivedSpy.size(), 0);
+    QCOMPARE(pongSpy.size(), 0);
+    QCOMPARE(bytesWrittenSpy.size(), 0);
 }
 
 void tst_QWebSocket::tst_sendTextMessage()
@@ -428,8 +428,8 @@ void tst_QWebSocket::tst_sendTextMessage()
 
     socket.open(url);
 
-    QTRY_COMPARE(socketConnectedSpy.count(), 1);
-    QCOMPARE(socketError.count(), 0);
+    QTRY_COMPARE(socketConnectedSpy.size(), 1);
+    QCOMPARE(socketError.size(), 0);
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
     QList<QVariant> arguments = serverConnectedSpy.takeFirst();
     QUrl urlConnected = arguments.at(0).toUrl();
@@ -442,14 +442,14 @@ void tst_QWebSocket::tst_sendTextMessage()
     QVERIFY(textMessageReceived.wait(500));
     QCOMPARE(socket.bytesToWrite(), 0);
 
-    QCOMPARE(textMessageReceived.count(), 1);
-    QCOMPARE(binaryMessageReceived.count(), 0);
-    QCOMPARE(binaryFrameReceived.count(), 0);
+    QCOMPARE(textMessageReceived.size(), 1);
+    QCOMPARE(binaryMessageReceived.size(), 0);
+    QCOMPARE(binaryFrameReceived.size(), 0);
     arguments = textMessageReceived.takeFirst();
     QString messageReceived = arguments.at(0).toString();
     QCOMPARE(messageReceived, QStringLiteral("Hello world!"));
 
-    QCOMPARE(textFrameReceived.count(), 1);
+    QCOMPARE(textFrameReceived.size(), 1);
     arguments = textFrameReceived.takeFirst();
     QString frameReceived = arguments.at(0).toString();
     bool isLastFrame = arguments.at(1).toBool();
@@ -464,8 +464,8 @@ void tst_QWebSocket::tst_sendTextMessage()
     // QTBUG-74464 QWebsocket doesn't receive text (binary) message with size > 32 kb
     socket.open(url);
 
-    QTRY_COMPARE(socketConnectedSpy.count(), 1);
-    QCOMPARE(socketError.count(), 0);
+    QTRY_COMPARE(socketConnectedSpy.size(), 1);
+    QCOMPARE(socketError.size(), 0);
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
     arguments = serverConnectedSpy.takeFirst();
     urlConnected = arguments.at(0).toUrl();
@@ -475,16 +475,16 @@ void tst_QWebSocket::tst_sendTextMessage()
     // transmit a long text message with 1 MB
     QString longString(0x100000, 'a');
     socket.sendTextMessage(longString);
-    QVERIFY(socket.bytesToWrite() > longString.length());
+    QVERIFY(socket.bytesToWrite() > longString.size());
     QVERIFY(textMessageReceived.wait());
     QCOMPARE(socket.bytesToWrite(), 0);
 
-    QCOMPARE(textMessageReceived.count(), 1);
-    QCOMPARE(binaryMessageReceived.count(), 0);
-    QCOMPARE(binaryFrameReceived.count(), 0);
+    QCOMPARE(textMessageReceived.size(), 1);
+    QCOMPARE(binaryMessageReceived.size(), 0);
+    QCOMPARE(binaryFrameReceived.size(), 0);
     arguments = textMessageReceived.takeFirst();
     messageReceived = arguments.at(0).toString();
-    QCOMPARE(messageReceived.length(), longString.length());
+    QCOMPARE(messageReceived.size(), longString.size());
     QCOMPARE(messageReceived, longString);
 
     arguments = textFrameReceived.takeLast();
@@ -500,20 +500,20 @@ void tst_QWebSocket::tst_sendTextMessage()
     socket.open(QUrl(QStringLiteral("ws://") + echoServer.hostAddress().toString() +
                      QStringLiteral(":") + QString::number(echoServer.port())));
 
-    QTRY_COMPARE(socketConnectedSpy.count(), 1);
+    QTRY_COMPARE(socketConnectedSpy.size(), 1);
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
 
     socket.sendTextMessage(QStringLiteral("Hello world!"));
 
     QVERIFY(textMessageReceived.wait(500));
-    QCOMPARE(textMessageReceived.count(), 1);
-    QCOMPARE(binaryMessageReceived.count(), 0);
-    QCOMPARE(binaryFrameReceived.count(), 0);
+    QCOMPARE(textMessageReceived.size(), 1);
+    QCOMPARE(binaryMessageReceived.size(), 0);
+    QCOMPARE(binaryFrameReceived.size(), 0);
     arguments = textMessageReceived.takeFirst();
     messageReceived = arguments.at(0).toString();
     QCOMPARE(messageReceived, QStringLiteral("Hello world!"));
 
-    QCOMPARE(textFrameReceived.count(), 1);
+    QCOMPARE(textFrameReceived.size(), 1);
     arguments = textFrameReceived.takeFirst();
     frameReceived = arguments.at(0).toString();
     isLastFrame = arguments.at(1).toBool();
@@ -544,7 +544,7 @@ void tst_QWebSocket::tst_sendBinaryMessage()
     socket.open(QUrl(QStringLiteral("ws://") + echoServer.hostAddress().toString() +
                      QStringLiteral(":") + QString::number(echoServer.port())));
 
-    QTRY_COMPARE(socketConnectedSpy.count(), 1);
+    QTRY_COMPARE(socketConnectedSpy.size(), 1);
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
 
     QCOMPARE(socket.bytesToWrite(), 0);
@@ -554,14 +554,14 @@ void tst_QWebSocket::tst_sendBinaryMessage()
     QVERIFY(binaryMessageReceived.wait(500));
     QCOMPARE(socket.bytesToWrite(), 0);
 
-    QCOMPARE(textMessageReceived.count(), 0);
-    QCOMPARE(textFrameReceived.count(), 0);
-    QCOMPARE(binaryMessageReceived.count(), 1);
+    QCOMPARE(textMessageReceived.size(), 0);
+    QCOMPARE(textFrameReceived.size(), 0);
+    QCOMPARE(binaryMessageReceived.size(), 1);
     QList<QVariant> arguments = binaryMessageReceived.takeFirst();
     QByteArray messageReceived = arguments.at(0).toByteArray();
     QCOMPARE(messageReceived, QByteArrayLiteral("Hello world!"));
 
-    QCOMPARE(binaryFrameReceived.count(), 1);
+    QCOMPARE(binaryFrameReceived.size(), 1);
     arguments = binaryFrameReceived.takeFirst();
     QByteArray frameReceived = arguments.at(0).toByteArray();
     bool isLastFrame = arguments.at(1).toBool();
@@ -578,20 +578,20 @@ void tst_QWebSocket::tst_sendBinaryMessage()
     socket.open(QUrl(QStringLiteral("ws://") + echoServer.hostAddress().toString() +
                      QStringLiteral(":") + QString::number(echoServer.port())));
 
-    QTRY_COMPARE(socketConnectedSpy.count(), 1);
+    QTRY_COMPARE(socketConnectedSpy.size(), 1);
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
 
     socket.sendBinaryMessage(QByteArrayLiteral("Hello world!"));
 
     QVERIFY(binaryMessageReceived.wait(500));
-    QCOMPARE(textMessageReceived.count(), 0);
-    QCOMPARE(textFrameReceived.count(), 0);
-    QCOMPARE(binaryMessageReceived.count(), 1);
+    QCOMPARE(textMessageReceived.size(), 0);
+    QCOMPARE(textFrameReceived.size(), 0);
+    QCOMPARE(binaryMessageReceived.size(), 1);
     arguments = binaryMessageReceived.takeFirst();
     messageReceived = arguments.at(0).toByteArray();
     QCOMPARE(messageReceived, QByteArrayLiteral("Hello world!"));
 
-    QCOMPARE(binaryFrameReceived.count(), 1);
+    QCOMPARE(binaryFrameReceived.size(), 1);
     arguments = binaryFrameReceived.takeFirst();
     frameReceived = arguments.at(0).toByteArray();
     isLastFrame = arguments.at(1).toBool();
@@ -611,7 +611,7 @@ void tst_QWebSocket::tst_errorString()
 
     socket.open(QUrl(QStringLiteral("ws://someserver.on.mars:9999")));
 
-    QTRY_COMPARE_WITH_TIMEOUT(errorSpy.count(), 1, 10000);
+    QTRY_COMPARE_WITH_TIMEOUT(errorSpy.size(), 1, 10000);
     QList<QVariant> arguments = errorSpy.takeFirst();
     QAbstractSocket::SocketError socketError =
             qvariant_cast<QAbstractSocket::SocketError>(arguments.at(0));
@@ -690,8 +690,8 @@ void tst_QWebSocket::tst_openRequest()
 
     socket.open(req, options);
 
-    QTRY_COMPARE(socketConnectedSpy.count(), 1);
-    QTRY_COMPARE(serverRequestSpy.count(), 1);
+    QTRY_COMPARE(socketConnectedSpy.size(), 1);
+    QTRY_COMPARE(serverRequestSpy.size(), 1);
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
     QList<QVariant> arguments = serverRequestSpy.takeFirst();
     QNetworkRequest requestConnected = arguments.at(0).value<QNetworkRequest>();
@@ -799,7 +799,7 @@ void tst_QWebSocket::tst_moveToThread()
     url.setQuery(query);
 
     socket->asyncOpen(url);
-    if (socketConnectedSpy.count() == 0)
+    if (socketConnectedSpy.size() == 0)
         QVERIFY(socketConnectedSpy.wait(500));
 
     socket->asyncSendTextMessage(textMessage);
@@ -866,16 +866,16 @@ void tst_QWebSocket::overlongCloseReason()
     QUrl url = QUrl(QStringLiteral("ws://") + echoServer.hostAddress().toString() +
                     QStringLiteral(":") + QString::number(echoServer.port()));
     socket.open(url);
-    QTRY_COMPARE(socketConnectedSpy.count(), 1);
-    QTRY_COMPARE(serverConnectedSpy.count(), 1);
+    QTRY_COMPARE(socketConnectedSpy.size(), 1);
+    QTRY_COMPARE(serverConnectedSpy.size(), 1);
 
     const QString reason(200, QChar::fromLatin1('a'));
     socket.close(QWebSocketProtocol::CloseCodeGoingAway, reason);
     QCOMPARE(socket.closeCode(), QWebSocketProtocol::CloseCodeGoingAway);
     // Max length of a control frame is 125, but 2 bytes are used for the close code:
-    QCOMPARE(socket.closeReason().length(), 123);
+    QCOMPARE(socket.closeReason().size(), 123);
     QCOMPARE(socket.closeReason(), reason.left(123));
-    QTRY_COMPARE(socketDisconnectedSpy.count(), 1);
+    QTRY_COMPARE(socketDisconnectedSpy.size(), 1);
 }
 
 void tst_QWebSocket::incomingMessageTooLong()
@@ -895,13 +895,13 @@ void tst_QWebSocket::incomingMessageTooLong()
     QUrl url = QUrl(QStringLiteral("ws://") + echoServer.hostAddress().toString() +
                     QStringLiteral(":") + QString::number(echoServer.port()));
     socket.open(url);
-    QTRY_COMPARE(socketConnectedSpy.count(), 1);
-    QTRY_COMPARE(serverConnectedSpy.count(), 1);
+    QTRY_COMPARE(socketConnectedSpy.size(), 1);
+    QTRY_COMPARE(serverConnectedSpy.size(), 1);
 
     QString payload(maxAllowedIncomingMessageSize+1, 'a');
     QCOMPARE(socket.sendTextMessage(payload), payload.size());
 
-    QTRY_COMPARE(socketDisconnectedSpy.count(), 1);
+    QTRY_COMPARE(socketDisconnectedSpy.size(), 1);
     QCOMPARE(socket.closeCode(), QWebSocketProtocol::CloseCodeTooMuchData);
 }
 
@@ -923,13 +923,13 @@ void tst_QWebSocket::incomingFrameTooLong()
     QUrl url = QUrl(QStringLiteral("ws://") + echoServer.hostAddress().toString() +
                     QStringLiteral(":") + QString::number(echoServer.port()));
     socket.open(url);
-    QTRY_COMPARE(socketConnectedSpy.count(), 1);
-    QTRY_COMPARE(serverConnectedSpy.count(), 1);
+    QTRY_COMPARE(socketConnectedSpy.size(), 1);
+    QTRY_COMPARE(serverConnectedSpy.size(), 1);
 
     QString payload(maxAllowedIncomingFrameSize+1, 'a');
     QCOMPARE(socket.sendTextMessage(payload), payload.size());
 
-    QTRY_COMPARE(socketDisconnectedSpy.count(), 1);
+    QTRY_COMPARE(socketDisconnectedSpy.size(), 1);
     QCOMPARE(socket.closeCode(), QWebSocketProtocol::CloseCodeTooMuchData);
 }
 
@@ -978,7 +978,7 @@ void tst_QWebSocket::customHeader()
     QVERIFY(data.contains("CustomHeader: Example"));
     const auto view = QLatin1String(data);
     const auto keyHeader = QLatin1String("Sec-WebSocket-Key:");
-    const qsizetype keyStart = view.indexOf(keyHeader, 0, Qt::CaseInsensitive) + keyHeader.length();
+    const qsizetype keyStart = view.indexOf(keyHeader, 0, Qt::CaseInsensitive) + keyHeader.size();
     QVERIFY(keyStart != -1);
     const qsizetype keyEnd = view.indexOf(QLatin1String("\r\n"), keyStart);
     QVERIFY(keyEnd != -1);
diff --git a/tests/auto/websockets/qwebsocketserver/tst_qwebsocketserver.cpp b/tests/auto/websockets/qwebsocketserver/tst_qwebsocketserver.cpp
index 7decdb5..f8d4dba 100644
--- a/tests/auto/websockets/qwebsocketserver/tst_qwebsocketserver.cpp
+++ b/tests/auto/websockets/qwebsocketserver/tst_qwebsocketserver.cpp
@@ -179,7 +179,7 @@ void tst_QWebSocketServer::tst_initialisation()
     #ifndef QT_NO_SSL
         QCOMPARE(server.sslConfiguration(), QSslConfiguration::defaultConfiguration());
     #endif
-        QCOMPARE(server.supportedVersions().count(), 1);
+        QCOMPARE(server.supportedVersions().size(), 1);
         QCOMPARE(server.supportedVersions().at(0), QWebSocketProtocol::VersionLatest);
         QCOMPARE(server.supportedVersions().at(0), QWebSocketProtocol::Version13);
 
@@ -204,7 +204,7 @@ void tst_QWebSocketServer::tst_initialisation()
     #ifndef QT_NO_SSL
         QCOMPARE(server.sslConfiguration(), QSslConfiguration::defaultConfiguration());
     #endif
-        QCOMPARE(server.supportedVersions().count(), 1);
+        QCOMPARE(server.supportedVersions().size(), 1);
         QCOMPARE(server.supportedVersions().at(0), QWebSocketProtocol::VersionLatest);
         QCOMPARE(server.supportedVersions().at(0), QWebSocketProtocol::Version13);
         QCOMPARE(server.serverUrl(), QUrl());
@@ -288,26 +288,26 @@ void tst_QWebSocketServer::tst_listening()
 
     QVERIFY(server.listen());   //listen on all network interface, choose an appropriate port
     QVERIFY(server.isListening());
-    QCOMPARE(serverClosedSpy.count(), 0);
+    QCOMPARE(serverClosedSpy.size(), 0);
     server.close();
-    QTRY_COMPARE(serverClosedSpy.count(), 1);
+    QTRY_COMPARE(serverClosedSpy.size(), 1);
     QVERIFY(!server.isListening());
-    QCOMPARE(serverErrorSpy.count(), 0);
+    QCOMPARE(serverErrorSpy.size(), 0);
 
     QVERIFY(!server.listen(QHostAddress(QStringLiteral("1.2.3.4")), 0));
     QCOMPARE(server.error(), QWebSocketProtocol::CloseCodeAbnormalDisconnection);
     QCOMPARE(server.errorString().toLatin1().constData(), "The address is not available");
     QVERIFY(!server.isListening());
 
-    QCOMPARE(serverAcceptErrorSpy.count(), 0);
-    QCOMPARE(serverConnectionSpy.count(), 0);
-    QCOMPARE(corsAuthenticationSpy.count(), 0);
+    QCOMPARE(serverAcceptErrorSpy.size(), 0);
+    QCOMPARE(serverConnectionSpy.size(), 0);
+    QCOMPARE(corsAuthenticationSpy.size(), 0);
 #ifndef QT_NO_SSL
-    QCOMPARE(peerVerifyErrorSpy.count(), 0);
-    QCOMPARE(sslErrorsSpy.count(), 0);
+    QCOMPARE(peerVerifyErrorSpy.size(), 0);
+    QCOMPARE(sslErrorsSpy.size(), 0);
 #endif
-    QCOMPARE(serverErrorSpy.count(), 1);
-    QCOMPARE(serverClosedSpy.count(), 1);
+    QCOMPARE(serverErrorSpy.size(), 1);
+    QCOMPARE(serverClosedSpy.size(), 1);
 }
 
 void tst_QWebSocketServer::tst_connectivity()
@@ -336,21 +336,21 @@ void tst_QWebSocketServer::tst_connectivity()
 
     socket.open(server.serverUrl().toString());
 
-    QTRY_COMPARE(socketConnectedSpy.count(), 1);
+    QTRY_COMPARE(socketConnectedSpy.size(), 1);
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
-    QCOMPARE(serverConnectionSpy.count(), 1);
-    QCOMPARE(corsAuthenticationSpy.count(), 1);
+    QCOMPARE(serverConnectionSpy.size(), 1);
+    QCOMPARE(corsAuthenticationSpy.size(), 1);
 
-    QCOMPARE(serverClosedSpy.count(), 0);
+    QCOMPARE(serverClosedSpy.size(), 0);
 
     server.close();
 
-    QTRY_COMPARE(serverClosedSpy.count(), 1);
+    QTRY_COMPARE(serverClosedSpy.size(), 1);
 #ifndef QT_NO_SSL
-    QCOMPARE(peerVerifyErrorSpy.count(), 0);
-    QCOMPARE(sslErrorsSpy.count(), 0);
+    QCOMPARE(peerVerifyErrorSpy.size(), 0);
+    QCOMPARE(sslErrorsSpy.size(), 0);
 #endif
-    QCOMPARE(serverErrorSpy.count(), 0);
+    QCOMPARE(serverErrorSpy.size(), 0);
 }
 
 void tst_QWebSocketServer::tst_protocols_data()
@@ -385,7 +385,7 @@ void tst_QWebSocketServer::tst_protocols()
     client.open(server.serverUrl(), opt);
 
     QTRY_COMPARE(client.state(), QAbstractSocket::ConnectedState);
-    QTRY_COMPARE(newConnectionSpy.count(), 1);
+    QTRY_COMPARE(newConnectionSpy.size(), 1);
 
     auto *serverSocket = server.nextPendingConnection();
     QVERIFY(serverSocket);
@@ -463,19 +463,19 @@ void tst_QWebSocketServer::tst_preSharedKey()
 
     socket.open(server.serverUrl().toString());
 
-    QTRY_COMPARE(socketConnectedSpy.count(), 1);
+    QTRY_COMPARE(socketConnectedSpy.size(), 1);
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
-    QCOMPARE(serverConnectionSpy.count(), 1);
-    QCOMPARE(serverPskRequiredSpy.count(), 1);
-    QCOMPARE(socketPskRequiredSpy.count(), 1);
+    QCOMPARE(serverConnectionSpy.size(), 1);
+    QCOMPARE(serverPskRequiredSpy.size(), 1);
+    QCOMPARE(socketPskRequiredSpy.size(), 1);
 
-    QCOMPARE(serverClosedSpy.count(), 0);
+    QCOMPARE(serverClosedSpy.size(), 0);
 
     server.close();
 
-    QTRY_COMPARE(serverClosedSpy.count(), 1);
-    QCOMPARE(sslErrorsSpy.count(), 0);
-    QCOMPARE(serverErrorSpy.count(), 0);
+    QTRY_COMPARE(serverClosedSpy.size(), 1);
+    QCOMPARE(sslErrorsSpy.size(), 0);
+    QCOMPARE(serverErrorSpy.size(), 0);
 }
 
 void tst_QWebSocketServer::tst_maxPendingConnections()
@@ -511,21 +511,21 @@ void tst_QWebSocketServer::tst_maxPendingConnections()
 
     socket1.open(server.serverUrl().toString());
 
-    QTRY_COMPARE(socket1ConnectedSpy.count(), 1);
+    QTRY_COMPARE(socket1ConnectedSpy.size(), 1);
     QCOMPARE(socket1.state(), QAbstractSocket::ConnectedState);
-    QCOMPARE(serverConnectionSpy.count(), 1);
-    QCOMPARE(corsAuthenticationSpy.count(), 1);
+    QCOMPARE(serverConnectionSpy.size(), 1);
+    QCOMPARE(corsAuthenticationSpy.size(), 1);
     socket2.open(server.serverUrl().toString());
-    QTRY_COMPARE(socket2ConnectedSpy.count(), 1);
+    QTRY_COMPARE(socket2ConnectedSpy.size(), 1);
     QCOMPARE(socket2.state(), QAbstractSocket::ConnectedState);
-    QCOMPARE(serverConnectionSpy.count(), 2);
-    QCOMPARE(corsAuthenticationSpy.count(), 2);
+    QCOMPARE(serverConnectionSpy.size(), 2);
+    QCOMPARE(corsAuthenticationSpy.size(), 2);
     socket3.open(server.serverUrl().toString());
     QVERIFY(!socket3ConnectedSpy.wait(250));
-    QCOMPARE(socket3ConnectedSpy.count(), 0);
+    QCOMPARE(socket3ConnectedSpy.size(), 0);
     QCOMPARE(socket3.state(), QAbstractSocket::UnconnectedState);
-    QCOMPARE(serverConnectionSpy.count(), 2);
-    QCOMPARE(corsAuthenticationSpy.count(), 2);
+    QCOMPARE(serverConnectionSpy.size(), 2);
+    QCOMPARE(corsAuthenticationSpy.size(), 2);
 
     QVERIFY(server.hasPendingConnections());
     QWebSocket *pSocket = server.nextPendingConnection();
@@ -540,20 +540,20 @@ void tst_QWebSocketServer::tst_maxPendingConnections()
 
 //will resolve in another commit
 #ifndef Q_OS_WIN
-    QCOMPARE(serverErrorSpy.count(), 1);
+    QCOMPARE(serverErrorSpy.size(), 1);
     QCOMPARE(serverErrorSpy.at(0).at(0).value<QWebSocketProtocol::CloseCode>(),
              QWebSocketProtocol::CloseCodeAbnormalDisconnection);
 #endif
-    QCOMPARE(serverClosedSpy.count(), 0);
+    QCOMPARE(serverClosedSpy.size(), 0);
 
     server.close();
 
-    QTRY_COMPARE(serverClosedSpy.count(), 1);
+    QTRY_COMPARE(serverClosedSpy.size(), 1);
 #ifndef QT_NO_SSL
-    QCOMPARE(peerVerifyErrorSpy.count(), 0);
-    QCOMPARE(sslErrorsSpy.count(), 0);
+    QCOMPARE(peerVerifyErrorSpy.size(), 0);
+    QCOMPARE(sslErrorsSpy.size(), 0);
 #endif
-    QCOMPARE(serverAcceptErrorSpy.count(), 0);
+    QCOMPARE(serverAcceptErrorSpy.size(), 0);
 }
 
 void tst_QWebSocketServer::tst_serverDestroyedWhileSocketConnected()
@@ -578,16 +578,16 @@ void tst_QWebSocketServer::tst_serverDestroyedWhileSocketConnected()
 
     socket.open(server->serverUrl().toString());
 
-    QTRY_COMPARE(socketConnectedSpy.count(), 1);
+    QTRY_COMPARE(socketConnectedSpy.size(), 1);
     QCOMPARE(socket.state(), QAbstractSocket::ConnectedState);
-    QCOMPARE(serverConnectionSpy.count(), 1);
-    QCOMPARE(corsAuthenticationSpy.count(), 1);
+    QCOMPARE(serverConnectionSpy.size(), 1);
+    QCOMPARE(corsAuthenticationSpy.size(), 1);
 
-    QCOMPARE(serverClosedSpy.count(), 0);
+    QCOMPARE(serverClosedSpy.size(), 0);
 
     delete server;
 
-    QTRY_COMPARE(socketDisconnectedSpy.count(), 1);
+    QTRY_COMPARE(socketDisconnectedSpy.size(), 1);
 }
 
 #ifndef QT_NO_SSL
@@ -622,7 +622,7 @@ void tst_QWebSocketServer::tst_scheme()
     QWebSocket plainSocket;
     plainSocket.open(plainServer.serverUrl().toString());
 
-    QTRY_COMPARE(plainServerConnectionSpy.count(), 1);
+    QTRY_COMPARE(plainServerConnectionSpy.size(), 1);
     QScopedPointer<QWebSocket> plainServerSocket(plainServer.nextPendingConnection());
     QVERIFY(!plainServerSocket.isNull());
     QCOMPARE(plainServerSocket->requestUrl().scheme(), QStringLiteral("ws"));
@@ -646,7 +646,7 @@ void tst_QWebSocketServer::tst_scheme()
             });
     secureSocket.open(secureServer.serverUrl().toString());
 
-    QTRY_COMPARE(secureServerConnectionSpy.count(), 1);
+    QTRY_COMPARE(secureServerConnectionSpy.size(), 1);
     QScopedPointer<QWebSocket> secureServerSocket(secureServer.nextPendingConnection());
     QVERIFY(!secureServerSocket.isNull());
     QCOMPARE(secureServerSocket->requestUrl().scheme(), QStringLiteral("wss"));
@@ -670,9 +670,9 @@ void tst_QWebSocketServer::tst_handleConnection()
     QWebSocket webSocket;
     QSignalSpy wsConnectedSpy(&webSocket, &QWebSocket::connected);
     webSocket.open(QStringLiteral("ws://localhost:%1").arg(tcpServer.serverPort()));
-    QTRY_COMPARE(wsConnectedSpy.count(), 1);
+    QTRY_COMPARE(wsConnectedSpy.size(), 1);
 
-    QTRY_COMPARE(wsServerConnectionSpy.count(), 1);
+    QTRY_COMPARE(wsServerConnectionSpy.size(), 1);
 
     QScopedPointer<QWebSocket> webServerSocket(wsServer.nextPendingConnection());
     QVERIFY(!webServerSocket.isNull());
@@ -680,7 +680,7 @@ void tst_QWebSocketServer::tst_handleConnection()
     QSignalSpy wsMessageReceivedSpy(webServerSocket.data(), &QWebSocket::textMessageReceived);
     webSocket.sendTextMessage("dummy");
 
-    QTRY_COMPARE(wsMessageReceivedSpy.count(), 1);
+    QTRY_COMPARE(wsMessageReceivedSpy.size(), 1);
     QList<QVariant> arguments = wsMessageReceivedSpy.takeFirst();
     QCOMPARE(arguments.first().toString(), QString("dummy"));
 
@@ -688,7 +688,7 @@ void tst_QWebSocketServer::tst_handleConnection()
     webServerSocket->sendTextMessage("hello");
     QVERIFY(webServerSocket->bytesToWrite() > 5); // 5 + a few extra bytes for header
     QTRY_COMPARE(webServerSocket->bytesToWrite(), 0);
-    QTRY_COMPARE(clientMessageReceivedSpy.count(), 1);
+    QTRY_COMPARE(clientMessageReceivedSpy.size(), 1);
     arguments = clientMessageReceivedSpy.takeFirst();
     QCOMPARE(arguments.first().toString(), QString("hello"));
 }
@@ -734,7 +734,7 @@ void tst_QWebSocketServer::tst_handshakeTimeout()
         QWebSocket socket;
         socket.open(plainServer.serverUrl().toString());
 
-        QTRY_COMPARE(plainServerConnectionSpy.count(), 1);
+        QTRY_COMPARE(plainServerConnectionSpy.size(), 1);
         QScopedPointer<QWebSocket> plainServerSocket(plainServer.nextPendingConnection());
         QVERIFY(!plainServerSocket.isNull());
 
@@ -759,14 +759,14 @@ void tst_QWebSocketServer::tst_handshakeTimeout()
         QCoreApplication::processEvents();
 
         /* We have 50 plain TCP connections open, that are not proper websockets. */
-        QCOMPARE(plainServerConnectionSpy.count(), 0);
+        QCOMPARE(plainServerConnectionSpy.size(), 0);
 
         QWebSocket socket;
         socket.open(plainServer.serverUrl().toString());
 
         /* Check that a real websocket will be processed after some non-websocket
          * TCP connections timeout. */
-        QTRY_COMPARE(plainServerConnectionSpy.count(), 1);
+        QTRY_COMPARE(plainServerConnectionSpy.size(), 1);
         QScopedPointer<QWebSocket> plainServerSocket(plainServer.nextPendingConnection());
         QVERIFY(!plainServerSocket.isNull());
 
@@ -794,7 +794,7 @@ void tst_QWebSocketServer::tst_handshakeTimeout()
         openManyConnections(&sockets, secureServer.serverPort(), numConnections);
 
         QCoreApplication::processEvents();
-        QCOMPARE(secureServerConnectionSpy.count(), 0);
+        QCOMPARE(secureServerConnectionSpy.size(), 0);
 
         QWebSocket secureSocket;
         connect(&secureSocket, &QWebSocket::errorOccurred,
@@ -808,7 +808,7 @@ void tst_QWebSocketServer::tst_handshakeTimeout()
 
         secureSocket.open(secureServer.serverUrl().toString());
 
-        QTRY_COMPARE(secureServerConnectionSpy.count(), 1);
+        QTRY_COMPARE(secureServerConnectionSpy.size(), 1);
         QScopedPointer<QWebSocket> serverSocket(secureServer.nextPendingConnection());
         QVERIFY(!serverSocket.isNull());
 
@@ -830,14 +830,14 @@ void tst_QWebSocketServer::tst_handshakeTimeout()
         QSignalSpy socketDisconnectedSpy(&socket, &QWebSocket::disconnected);
         socket.open(plainServer.serverUrl().toString());
 
-        QTRY_COMPARE(plainServerConnectionSpy.count(), 1);
-        QTRY_COMPARE(socketConnectedSpy.count(), 1);
+        QTRY_COMPARE(plainServerConnectionSpy.size(), 1);
+        QTRY_COMPARE(socketConnectedSpy.size(), 1);
 
         QEventLoop loop;
         QTimer::singleShot(500, &loop, &QEventLoop::quit);
         loop.exec();
 
-        QCOMPARE(socketDisconnectedSpy.count(), 0);
+        QCOMPARE(socketDisconnectedSpy.size(), 0);
     }
 }
 
@@ -865,7 +865,7 @@ void tst_QWebSocketServer::multipleFrames()
     QVERIFY(messageReceivedSpy.wait());
     // Since there's no guarantee the operating system will fit all 10 websocket frames into 1 tcp
     // frame, let's just assume it will do at least 2. EXCEPT_FAIL any which doesn't merge any.
-    QVERIFY2(messageReceivedSpy.count() > 1, "Received only 1 message in the TCP frame!");
+    QVERIFY2(messageReceivedSpy.size() > 1, "Received only 1 message in the TCP frame!");
 }
 
 QTEST_MAIN(tst_QWebSocketServer)
diff --git a/tests/auto/websockets/websocketframe/tst_websocketframe.cpp b/tests/auto/websockets/websocketframe/tst_websocketframe.cpp
index 7f2c4bb..6f42911 100644
--- a/tests/auto/websockets/websocketframe/tst_websocketframe.cpp
+++ b/tests/auto/websockets/websocketframe/tst_websocketframe.cpp
@@ -55,7 +55,7 @@ QByteArray FrameHelper::wireRepresentation()
 {
     quint8 byte = 0x00;
     QByteArray wireRep;
-    quint64 payloadLength = m_payload.length();
+    quint64 payloadLength = m_payload.size();
 
     //FIN, opcode
     byte = static_cast<quint8>((m_opCode & 0x0F) | (m_isFinalFrame ? 0x80 : 0x00)); //FIN, opcode
@@ -154,7 +154,7 @@ void tst_WebSocketFrame::tst_initialization()
 {
     QWebSocketFrame frame;
     QVERIFY(!frame.isValid());
-    QCOMPARE(frame.payload().length(), 0);
+    QCOMPARE(frame.payload().size(), 0);
 }
 
 void tst_WebSocketFrame::tst_copyConstructorAndAssignment()
@@ -315,7 +315,7 @@ void tst_WebSocketFrame::tst_goodFrames()
     QCOMPARE(frame.isControlFrame(), isControlFrame);
     QCOMPARE(frame.isDataFrame(), isDataFrame);
     QCOMPARE(frame.isContinuationFrame(), isContinuationFrame);
-    QCOMPARE(frame.payload().length(), payload.length());
+    QCOMPARE(frame.payload().size(), payload.size());
     QCOMPARE(frame.payload(), payload);
 }