Port from container.count()/length() to size()

This is semantic patch using ClangTidyTransformator:

  auto QtContainerClass = 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'.

<classes> are:

    // sequential:
    "QByteArray",
    "QList",
    "QQueue",
    "QStack",
    "QString",
    "QVarLengthArray",
    "QVector",
    // associative:
    "QHash",
    "QMultiHash",
    "QMap",
    "QMultiMap",
    "QSet",
    // Qt has no QMultiSet

Change-Id: Ibe8837be96e8d30d1846881ecd65180c1bc459af
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>

11 files changed, 128 insertions, 128 deletions

diff --git a/tests/auto/corelib/tools/collections/tst_collections.cpp b/tests/auto/corelib/tools/collections/tst_collections.cpp
index 23ebf5046a..3ec49a7444 100644
--- a/tests/auto/corelib/tools/collections/tst_collections.cpp
+++ b/tests/auto/corelib/tools/collections/tst_collections.cpp
@@ -684,7 +684,7 @@ QT_WARNING_POP
         list.insert(0, "atzero");
         QCOMPARE(list.at(0), QString("atzero"));
 
-        int listCount = list.count();
+        int listCount = list.size();
         list.insert(listCount, "atcount");
         QCOMPARE(list.at(listCount), QString("atcount"));
     }
@@ -2018,8 +2018,8 @@ void tst_Collections::qstring()
     s = "ascii";
     s += QChar((uchar) 0xb0);
     QVERIFY(s.toUtf8() != s.toLatin1());
-    QCOMPARE(s[s.length()-1].unicode(), (ushort)0xb0);
-    QCOMPARE(s.left(s.length()-1), QLatin1String("ascii"));
+    QCOMPARE(s[s.size()-1].unicode(), (ushort)0xb0);
+    QCOMPARE(s.left(s.size()-1), QLatin1String("ascii"));
 
     QVERIFY(s == QString::fromUtf8(s.toUtf8().constData()));
 
@@ -2071,7 +2071,7 @@ void tst_Collections::qstring()
 
 
     QString str = "Hello";
-    QString cstr = QString::fromRawData(str.unicode(), str.length());
+    QString cstr = QString::fromRawData(str.unicode(), str.size());
     QCOMPARE(str, QLatin1String("Hello"));
     QCOMPARE(cstr, QLatin1String("Hello"));
     cstr.clear();
@@ -2821,7 +2821,7 @@ void instantiateContainer()
 
     container.clear();
     container.contains(value);
-    container.count();
+    container.size();
     container.empty();
     container.isEmpty();
     container.size();
@@ -3244,7 +3244,7 @@ template<template<class> class C> void QTBUG13079_collectionInsideCollectionImpl
     QCOMPARE(nodeList.first().s, QString::fromLatin1("child"));
 
     nodeList = nodeList.first().children;
-    QCOMPARE(nodeList.count(), 0);
+    QCOMPARE(nodeList.size(), 0);
     nodeList << QTBUG13079_Node<C>();
 }
 
@@ -3269,7 +3269,7 @@ template<template<class, class> class C> void QTBUG13079_collectionInsideCollect
     QCOMPARE(nodeMap[12].s, QString::fromLatin1("child"));
 
     nodeMap = nodeMap[12].children;
-    QCOMPARE(nodeMap.count(), 0);
+    QCOMPARE(nodeMap.size(), 0);
     nodeMap[42] = QTBUG13079_NodeAssoc<C>();
 }
 
@@ -3336,7 +3336,7 @@ void tst_Collections::QTBUG13079_collectionInsideCollection()
         QSet<QTBUG13079_Node<QSet> > nodeSet;
         nodeSet << QTBUG13079_Node<QSet>();
         nodeSet = nodeSet.begin()->children;
-        QCOMPARE(nodeSet.count(), 0);
+        QCOMPARE(nodeSet.size(), 0);
     }
 
     QTBUG13079_collectionInsideCollectionAssocImpl<QMap>();
@@ -3358,7 +3358,7 @@ template<class Container> void foreach_test_arrays(const Container &container)
         set << val;
         i++;
     }
-    QCOMPARE(set.count(), container.count());
+    QCOMPARE(set.size(), container.size());
 
     //modify the container while iterating.
     Container c2 = container;
@@ -3395,9 +3395,9 @@ void tst_Collections::foreach_2()
         varl2 << i;
         varl3 << i;
     }
-    QCOMPARE(varl1.count(), intlist.count());
-    QCOMPARE(varl2.count(), intlist.count());
-    QCOMPARE(varl3.count(), intlist.count());
+    QCOMPARE(varl1.size(), intlist.size());
+    QCOMPARE(varl2.size(), intlist.size());
+    QCOMPARE(varl3.size(), intlist.size());
 
     QVarLengthArray<QString> varl4;
     QVarLengthArray<QString, 3> varl5;
@@ -3407,9 +3407,9 @@ void tst_Collections::foreach_2()
         varl5 << str;
         varl6 << str;
     }
-    QCOMPARE(varl4.count(), strlist.count());
-    QCOMPARE(varl5.count(), strlist.count());
-    QCOMPARE(varl6.count(), strlist.count());
+    QCOMPARE(varl4.size(), strlist.count());
+    QCOMPARE(varl5.size(), strlist.count());
+    QCOMPARE(varl6.size(), strlist.count());
 }
 
 struct IntOrString
@@ -3439,8 +3439,8 @@ template<class Container> void insert_remove_loop_impl()
     t.insert(t.begin() + 2, T(IntOrString(7)));
     t.insert(t.begin() + 5, 3,  T(IntOrString(8)));
     int expect1[] = { 4 , 1 , 7, 5 , 5 , 8, 8, 8, 6, 5, 2 , 3 };
-    QCOMPARE(size_t(t.count()), sizeof(expect1)/sizeof(int));
-    for (int i = 0; i < t.count(); i++) {
+    QCOMPARE(size_t(t.size()), sizeof(expect1)/sizeof(int));
+    for (int i = 0; i < t.size(); i++) {
         QCOMPARE(t[i], T(IntOrString(expect1[i])));
     }
 
@@ -3454,8 +3454,8 @@ template<class Container> void insert_remove_loop_impl()
     t.remove(7);
     t.remove(2, 3);
     int expect2[] = { 4 , 1 , 9, 8, 6, 5, 2 , 3 };
-    QCOMPARE(size_t(t.count()), sizeof(expect2)/sizeof(int));
-    for (int i = 0; i < t.count(); i++) {
+    QCOMPARE(size_t(t.size()), sizeof(expect2)/sizeof(int));
+    for (int i = 0; i < t.size(); i++) {
         QCOMPARE(t[i], T(IntOrString(expect2[i])));
     }
 
@@ -3467,16 +3467,16 @@ template<class Container> void insert_remove_loop_impl()
     }
 
     int expect3[] = { 1 , 9, 5, 3 };
-    QCOMPARE(size_t(t.count()), sizeof(expect3)/sizeof(int));
-    for (int i = 0; i < t.count(); i++) {
+    QCOMPARE(size_t(t.size()), sizeof(expect3)/sizeof(int));
+    for (int i = 0; i < t.size(); i++) {
         QCOMPARE(t[i], T(IntOrString(expect3[i])));
     }
 
     t.erase(t.begin() + 1, t.end() - 1);
 
     int expect4[] = { 1 , 3 };
-    QCOMPARE(size_t(t.count()), sizeof(expect4)/sizeof(int));
-    for (int i = 0; i < t.count(); i++) {
+    QCOMPARE(size_t(t.size()), sizeof(expect4)/sizeof(int));
+    for (int i = 0; i < t.size(); i++) {
         QCOMPARE(t[i], T(IntOrString(expect4[i])));
     }
 
@@ -3493,8 +3493,8 @@ template<class Container> void insert_remove_loop_impl()
 
     int expect5[] = { 1, 1, 2, 3*3, 3, 3*3+1, 10, 11*11, 11, 11*11+1, 12 , 13*13, 13, 13*13+1, 14,
                       15*15, 15, 15*15+1, 16 , 17*17, 17, 17*17+1 ,18 , 19*19, 19, 19*19+1, 20, 21*21, 21, 21*21+1 };
-    QCOMPARE(size_t(t.count()), sizeof(expect5)/sizeof(int));
-    for (int i = 0; i < t.count(); i++) {
+    QCOMPARE(size_t(t.size()), sizeof(expect5)/sizeof(int));
+    for (int i = 0; i < t.size(); i++) {
         QCOMPARE(t[i], T(IntOrString(expect5[i])));
     }
 
@@ -3504,8 +3504,8 @@ template<class Container> void insert_remove_loop_impl()
     t.insert(2, 4, T(IntOrString(7)));
 
     int expect6[] = { 1, 2, 7, 7, 7, 7, 9, 9, 9, 9, 3, 4 };
-    QCOMPARE(size_t(t.count()), sizeof(expect6)/sizeof(int));
-    for (int i = 0; i < t.count(); i++) {
+    QCOMPARE(size_t(t.size()), sizeof(expect6)/sizeof(int));
+    for (int i = 0; i < t.size(); i++) {
         QCOMPARE(t[i], T(IntOrString(expect6[i])));
     }
 
diff --git a/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp b/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp
index 3e755e67da..97c682c688 100644
--- a/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp
+++ b/tests/auto/corelib/tools/qbitarray/tst_qbitarray.cpp
@@ -13,10 +13,10 @@
 static QBitArray QStringToQBitArray(const QString &str)
 {
     QBitArray ba;
-    ba.resize(str.length());
+    ba.resize(str.size());
     int i;
     QChar tru('1');
-    for (i = 0; i < str.length(); i++)
+    for (i = 0; i < str.size(); i++)
     {
         if (str.at(i) == tru)
         {
diff --git a/tests/auto/corelib/tools/qcryptographichash/tst_qcryptographichash.cpp b/tests/auto/corelib/tools/qcryptographichash/tst_qcryptographichash.cpp
index 2151c69323..c2e8b0194f 100644
--- a/tests/auto/corelib/tools/qcryptographichash/tst_qcryptographichash.cpp
+++ b/tests/auto/corelib/tools/qcryptographichash/tst_qcryptographichash.cpp
@@ -402,7 +402,7 @@ void tst_QCryptographicHash::hashLength()
     QFETCH(const QCryptographicHash::Algorithm, algorithm);
 
     QByteArray output = QCryptographicHash::hash("test", algorithm);
-    QCOMPARE(QCryptographicHash::hashLength(algorithm), output.length());
+    QCOMPARE(QCryptographicHash::hashLength(algorithm), output.size());
 }
 
 void tst_QCryptographicHash::move()
diff --git a/tests/auto/corelib/tools/qeasingcurve/tst_qeasingcurve.cpp b/tests/auto/corelib/tools/qeasingcurve/tst_qeasingcurve.cpp
index 4d1d846eb8..a64e3bfcb3 100644
--- a/tests/auto/corelib/tools/qeasingcurve/tst_qeasingcurve.cpp
+++ b/tests/auto/corelib/tools/qeasingcurve/tst_qeasingcurve.cpp
@@ -583,9 +583,9 @@ static inline void setupBezierSpline(QEasingCurve *easingCurve, const QString &s
         points.append(point);
     }
 
-    QVERIFY(points.count() % 3 == 0);
+    QVERIFY(points.size() % 3 == 0);
 
-    for (int i = 0; i < points.count() / 3; i++) {
+    for (int i = 0; i < points.size() / 3; i++) {
         QPointF c1 = points.at(i * 3);
         QPointF c2 = points.at(i * 3 + 1);
         QPointF p1 = points.at(i * 3 + 2);
diff --git a/tests/auto/corelib/tools/qhash/tst_qhash.cpp b/tests/auto/corelib/tools/qhash/tst_qhash.cpp
index bb73a267a5..cf0bc67761 100644
--- a/tests/auto/corelib/tools/qhash/tst_qhash.cpp
+++ b/tests/auto/corelib/tools/qhash/tst_qhash.cpp
@@ -1703,26 +1703,26 @@ void tst_QHash::qmultihash_specific()
     }
 
     QVERIFY(hash1.contains(9, 99));
-    QCOMPARE(hash1.count(), 45);
+    QCOMPARE(hash1.size(), 45);
     hash1.remove(9, 99);
     QVERIFY(!hash1.contains(9, 99));
-    QCOMPARE(hash1.count(), 44);
+    QCOMPARE(hash1.size(), 44);
 
     hash1.remove(9, 99);
     QVERIFY(!hash1.contains(9, 99));
-    QCOMPARE(hash1.count(), 44);
+    QCOMPARE(hash1.size(), 44);
 
     hash1.remove(1, 99);
-    QCOMPARE(hash1.count(), 44);
+    QCOMPARE(hash1.size(), 44);
 
     hash1.insert(1, 99);
     hash1.insert(1, 99);
 
-    QCOMPARE(hash1.count(), 46);
+    QCOMPARE(hash1.size(), 46);
     hash1.remove(1, 99);
-    QCOMPARE(hash1.count(), 44);
+    QCOMPARE(hash1.size(), 44);
     hash1.remove(1, 99);
-    QCOMPARE(hash1.count(), 44);
+    QCOMPARE(hash1.size(), 44);
 
     {
     QMultiHash<int, int>::const_iterator i = hash1.constFind(1, 11);
@@ -1768,10 +1768,10 @@ void tst_QHash::qmultihash_specific()
     }
 
     QCOMPARE(hash1.count(9), 8);
-    QCOMPARE(hash1.count(), 44);
+    QCOMPARE(hash1.size(), 44);
     hash1.remove(9);
     QCOMPARE(hash1.count(9), 0);
-    QCOMPARE(hash1.count(), 36);
+    QCOMPARE(hash1.size(), 36);
 
     {
     QMultiHash<int, int> map1;
@@ -1787,7 +1787,7 @@ void tst_QHash::qmultihash_specific()
     map2.insert(42, 1);
     map2.insert(10, 2);
     map2.insert(48, 3);
-    QCOMPARE(map1.count(), map2.count());
+    QCOMPARE(map1.size(), map2.size());
     QVERIFY(map1.remove(42,5));
     QVERIFY(map1 != map2);
     QVERIFY(map2.remove(42,5));
@@ -1796,7 +1796,7 @@ void tst_QHash::qmultihash_specific()
     QHash<int, int> hash;
     hash.insert(-1, -1);
     map2.unite(hash);
-    QCOMPARE(map2.count(), 6);
+    QCOMPARE(map2.size(), 6);
     QCOMPARE(map2[-1], -1);
     }
 }
@@ -2183,7 +2183,7 @@ void tst_QHash::twoArguments_qHash()
 void tst_QHash::initializerList()
 {
     QHash<int, QString> hash = {{1, "bar"}, {1, "hello"}, {2, "initializer_list"}};
-    QCOMPARE(hash.count(), 2);
+    QCOMPARE(hash.size(), 2);
     QCOMPARE(hash[1], QString("hello"));
     QCOMPARE(hash[2], QString("initializer_list"));
 
@@ -2193,9 +2193,9 @@ void tst_QHash::initializerList()
     // QCOMPARE(stdh[1], QString("bar"));
 
     QMultiHash<QString, int> multiHash{{"il", 1}, {"il", 2}, {"il", 3}};
-    QCOMPARE(multiHash.count(), 3);
+    QCOMPARE(multiHash.size(), 3);
     QList<int> values = multiHash.values("il");
-    QCOMPARE(values.count(), 3);
+    QCOMPARE(values.size(), 3);
 
     QHash<int, int> emptyHash{};
     QVERIFY(emptyHash.isEmpty());
@@ -2367,7 +2367,7 @@ void tst_QHash::insert_hash()
 
         hash.insert(hash2);
 
-        QCOMPARE(hash.count(), 5);
+        QCOMPARE(hash.size(), 5);
         for (int i = 0; i < 5; ++i)
             QCOMPARE(hash[i], i);
     }
@@ -2379,7 +2379,7 @@ void tst_QHash::insert_hash()
 
         hash.insert(hash2);
 
-        QCOMPARE(hash.count(), 1);
+        QCOMPARE(hash.size(), 1);
         QCOMPARE(hash[0], 5);
     }
     {
@@ -2389,7 +2389,7 @@ void tst_QHash::insert_hash()
 
         hash.insert(hash2);
 
-        QCOMPARE(hash.count(), 1);
+        QCOMPARE(hash.size(), 1);
         QCOMPARE(hash[0], 5);
         QCOMPARE(hash, hash2);
     }
@@ -2402,7 +2402,7 @@ void tst_QHash::insert_hash()
         // insert into ourself, nothing should happen
         hash.insert(hash);
 
-        QCOMPARE(hash.count(), 3);
+        QCOMPARE(hash.size(), 3);
         QCOMPARE(hash[0], 7);
         QCOMPARE(hash[2], 5);
         QCOMPARE(hash[7], 55);
@@ -2576,13 +2576,13 @@ void tst_QHash::countInEmptyHash()
 {
     {
         QHash<int, int> hash;
-        QCOMPARE(hash.count(), 0);
+        QCOMPARE(hash.size(), 0);
         QCOMPARE(hash.count(42), 0);
     }
 
     {
         QMultiHash<int, int> hash;
-        QCOMPARE(hash.count(), 0);
+        QCOMPARE(hash.size(), 0);
         QCOMPARE(hash.count(42), 0);
         QCOMPARE(hash.count(42, 1), 0);
     }
diff --git a/tests/auto/corelib/tools/qlist/tst_qlist.cpp b/tests/auto/corelib/tools/qlist/tst_qlist.cpp
index e797b76f69..482079b0fe 100644
--- a/tests/auto/corelib/tools/qlist/tst_qlist.cpp
+++ b/tests/auto/corelib/tools/qlist/tst_qlist.cpp
@@ -1078,20 +1078,20 @@ void tst_QList::count() const
     {
         // zero size
         QList<T> myvec;
-        QVERIFY(myvec.count() == 0);
+        QVERIFY(myvec.size() == 0);
         QVERIFY(!myvec.isDetached());
 
         // grow
         myvec.append(SimpleValue<T>::at(0));
-        QVERIFY(myvec.count() == 1);
+        QVERIFY(myvec.size() == 1);
         myvec.append(SimpleValue<T>::at(1));
-        QVERIFY(myvec.count() == 2);
+        QVERIFY(myvec.size() == 2);
 
         // shrink
         myvec.remove(0);
-        QVERIFY(myvec.count() == 1);
+        QVERIFY(myvec.size() == 1);
         myvec.remove(0);
-        QVERIFY(myvec.count() == 0);
+        QVERIFY(myvec.size() == 0);
     }
 
     // count of items
@@ -1905,11 +1905,11 @@ void tst_QList::move() const
     list << T_FOO << T_BAR << T_BAZ;
 
     // move an item
-    list.move(0, list.count() - 1);
+    list.move(0, list.size() - 1);
     QCOMPARE(list, QList<T>() << T_BAR << T_BAZ << T_FOO);
 
     // move it back
-    list.move(list.count() - 1, 0);
+    list.move(list.size() - 1, 0);
     QCOMPARE(list, QList<T>() << T_FOO << T_BAR << T_BAZ);
 
     // move an item in the middle
@@ -2673,24 +2673,24 @@ void tst_QList::size() const
     // zero size
     QList<T> myvec;
     QVERIFY(myvec.size() == 0);
-    QCOMPARE(myvec.length(), myvec.size());
+    QCOMPARE(myvec.size(), myvec.size());
     QVERIFY(!myvec.isDetached());
 
     // grow
     myvec.append(SimpleValue<T>::at(0));
     QVERIFY(myvec.size() == 1);
-    QCOMPARE(myvec.length(), myvec.size());
+    QCOMPARE(myvec.size(), myvec.size());
     myvec.append(SimpleValue<T>::at(1));
     QVERIFY(myvec.size() == 2);
-    QCOMPARE(myvec.length(), myvec.size());
+    QCOMPARE(myvec.size(), myvec.size());
 
     // shrink
     myvec.remove(0);
     QVERIFY(myvec.size() == 1);
-    QCOMPARE(myvec.length(), myvec.size());
+    QCOMPARE(myvec.size(), myvec.size());
     myvec.remove(0);
     QVERIFY(myvec.size() == 0);
-    QCOMPARE(myvec.length(), myvec.size());
+    QCOMPARE(myvec.size(), myvec.size());
 }
 
 // ::squeeze() is tested in ::capacity().
diff --git a/tests/auto/corelib/tools/qmap/tst_qmap.cpp b/tests/auto/corelib/tools/qmap/tst_qmap.cpp
index d4f886784d..098976b228 100644
--- a/tests/auto/corelib/tools/qmap/tst_qmap.cpp
+++ b/tests/auto/corelib/tools/qmap/tst_qmap.cpp
@@ -318,8 +318,8 @@ void tst_QMap::count()
     {
         QMultiMap<int, MyClass> map;
         QMultiMap<int, MyClass> map2(map);
-        QCOMPARE(map.count(), 0);
-        QCOMPARE(map2.count(), 0);
+        QCOMPARE(map.size(), 0);
+        QCOMPARE(map2.size(), 0);
         QCOMPARE(MyClass::count, 0);
         QCOMPARE(map.count(1), 0);
         QCOMPARE(map.size(), 0);
@@ -329,26 +329,26 @@ void tst_QMap::count()
 
         // detach
         map2.insert(0, MyClass("value0"));
-        QCOMPARE(map.count(), 0);
         QCOMPARE(map.size(), 0);
-        QCOMPARE(map2.count(), 1);
+        QCOMPARE(map.size(), 0);
+        QCOMPARE(map2.size(), 1);
         QCOMPARE(map2.size(), 1);
         QVERIFY(!map.isDetached());
         QCOMPARE(MyClass::count, 1);
 
         map2.insert(1, MyClass("value1"));
         map2.insert(2, MyClass("value2"));
-        QCOMPARE(map2.count(), 3);
+        QCOMPARE(map2.size(), 3);
         QCOMPARE(MyClass::count, 3);
 
         map2.insert(0, MyClass("value0_1"));
         map2.insert(0, MyClass("value0_2"));
-        QCOMPARE(map2.count(), 5);
+        QCOMPARE(map2.size(), 5);
         QCOMPARE(map2.count(0), 3);
         QCOMPARE(MyClass::count, 5);
 
         map2.clear();
-        QCOMPARE(map2.count(), 0);
+        QCOMPARE(map2.size(), 0);
         QCOMPARE(MyClass::count, 0);
 
     }
@@ -1589,26 +1589,26 @@ void tst_QMap::qmultimap_specific()
     }
 
     QVERIFY(map1.contains(9, 99));
-    QCOMPARE(map1.count(), 45);
+    QCOMPARE(map1.size(), 45);
     map1.remove(9, 99);
     QVERIFY(!map1.contains(9, 99));
-    QCOMPARE(map1.count(), 44);
+    QCOMPARE(map1.size(), 44);
 
     map1.remove(9, 99);
     QVERIFY(!map1.contains(9, 99));
-    QCOMPARE(map1.count(), 44);
+    QCOMPARE(map1.size(), 44);
 
     map1.remove(1, 99);
-    QCOMPARE(map1.count(), 44);
+    QCOMPARE(map1.size(), 44);
 
     map1.insert(1, 99);
     map1.insert(1, 99);
 
-    QCOMPARE(map1.count(), 46);
+    QCOMPARE(map1.size(), 46);
     map1.remove(1, 99);
-    QCOMPARE(map1.count(), 44);
+    QCOMPARE(map1.size(), 44);
     map1.remove(1, 99);
-    QCOMPARE(map1.count(), 44);
+    QCOMPARE(map1.size(), 44);
 
     {
     QMultiMap<int, int>::const_iterator i = map1.constFind(1, 11);
@@ -1667,7 +1667,7 @@ void tst_QMap::qmultimap_specific()
     map2.insert(42, 1);
     map2.insert(10, 2);
     map2.insert(48, 3);
-    QCOMPARE(map1.count(), map2.count());
+    QCOMPARE(map1.size(), map2.size());
     QVERIFY(map1.remove(42,5));
     QVERIFY(map2.remove(42,5));
     QVERIFY(map1 == map2);
@@ -1814,7 +1814,7 @@ void tst_QMap::insert()
     map.insert("cs/key1", 1);
     map.insert("cs/key2", 2);
     map.insert("cs/key1", 3);
-    QCOMPARE(map.count(), 2);
+    QCOMPARE(map.size(), 2);
 
     QMap<int, int> intMap;
     for (int i = 0; i < 1000; ++i) {
@@ -1893,7 +1893,7 @@ void testDetachWhenInsert()
         QCOMPARE(source, referenceSource);
         QCOMPARE(dest, referenceDestination);
 
-        QCOMPARE(destCopy.count(), 1); // unchanged
+        QCOMPARE(destCopy.size(), 1); // unchanged
     }
 
     // copy insertion of shared map
@@ -1917,7 +1917,7 @@ void testDetachWhenInsert()
         QCOMPARE(sourceCopy, referenceSource);
 
         QCOMPARE(dest, referenceDestination);
-        QCOMPARE(destCopy.count(), 1); // unchanged
+        QCOMPARE(destCopy.size(), 1); // unchanged
     }
 
     // move insertion of non-shared map
@@ -1937,7 +1937,7 @@ void testDetachWhenInsert()
             dest.unite(source); // QMultiMap
 
         QCOMPARE(dest, referenceDestination);
-        QCOMPARE(destCopy.count(), 1); // unchanged
+        QCOMPARE(destCopy.size(), 1); // unchanged
     }
 
     // move insertion of shared map
@@ -1960,7 +1960,7 @@ void testDetachWhenInsert()
         QCOMPARE(sourceCopy, referenceSource);
 
         QCOMPARE(dest, referenceDestination);
-        QCOMPARE(destCopy.count(), 1); // unchanged
+        QCOMPARE(destCopy.size(), 1); // unchanged
     }
 };
 
@@ -1991,7 +1991,7 @@ void tst_QMap::insertMap()
 
         map.insert(map2);
 
-        QCOMPARE(map.count(), 5);
+        QCOMPARE(map.size(), 5);
         for (int i = 0; i < 5; ++i)
             QCOMPARE(map[i], i);
     }
@@ -2006,7 +2006,7 @@ void tst_QMap::insertMap()
 
         map.insert(map2);
 
-        QCOMPARE(map.count(), 17);
+        QCOMPARE(map.size(), 17);
         for (int i = 0; i < 10; ++i) {
             // i * 3 == i except for i = 4, 8
             QCOMPARE(map[i * 3], (i && i % 4 == 0) ? i - (i / 4) : i);
@@ -2028,7 +2028,7 @@ void tst_QMap::insertMap()
         QMap<int, int> map2;
 
         map.insert(map2);
-        QCOMPARE(map.count(), 1);
+        QCOMPARE(map.size(), 1);
         QCOMPARE(map[1], 1);
     }
     {
@@ -2037,7 +2037,7 @@ void tst_QMap::insertMap()
         map2.insert(1, 1);
 
         map.insert(map2);
-        QCOMPARE(map.count(), 1);
+        QCOMPARE(map.size(), 1);
         QCOMPARE(map[1], 1);
 
         QMap<int, int> map3;
@@ -2053,7 +2053,7 @@ void tst_QMap::insertMap()
         // Test inserting into self, nothing should happen
         map.insert(map);
 
-        QCOMPARE(map.count(), 3);
+        QCOMPARE(map.size(), 3);
         for (int i = 0; i < 3; ++i)
             QCOMPARE(map[i], i);
     }
@@ -2071,7 +2071,7 @@ void tst_QMap::insertMap()
 
         map.insert(map2);
 
-        QCOMPARE(map.count(), 1);
+        QCOMPARE(map.size(), 1);
     }
 
     testDetachWhenInsert<QMap>();
@@ -2133,7 +2133,7 @@ void tst_QMap::checkMostLeftNode()
 void tst_QMap::initializerList()
 {
     QMap<int, QString> map = {{1, "bar"}, {1, "hello"}, {2, "initializer_list"}};
-    QCOMPARE(map.count(), 2);
+    QCOMPARE(map.size(), 2);
     QCOMPARE(map[1], QString("hello"));
     QCOMPARE(map[2], QString("initializer_list"));
 
@@ -2143,9 +2143,9 @@ void tst_QMap::initializerList()
     // QCOMPARE(stdm[1], QString("bar"));
 
     QMultiMap<QString, int> multiMap{{"il", 1}, {"il", 2}, {"il", 3}};
-    QCOMPARE(multiMap.count(), 3);
+    QCOMPARE(multiMap.size(), 3);
     QList<int> values = multiMap.values("il");
-    QCOMPARE(values.count(), 3);
+    QCOMPARE(values.size(), 3);
 
     QMap<int, int> emptyMap{};
     QVERIFY(emptyMap.isEmpty());
diff --git a/tests/auto/corelib/tools/qmessageauthenticationcode/tst_qmessageauthenticationcode.cpp b/tests/auto/corelib/tools/qmessageauthenticationcode/tst_qmessageauthenticationcode.cpp
index 08b7afae04..12fc2f8e43 100644
--- a/tests/auto/corelib/tools/qmessageauthenticationcode/tst_qmessageauthenticationcode.cpp
+++ b/tests/auto/corelib/tools/qmessageauthenticationcode/tst_qmessageauthenticationcode.cpp
@@ -122,7 +122,7 @@ void tst_QMessageAuthenticationCode::result_incremental()
     QFETCH(QByteArray, message);
     QFETCH(QByteArray, code);
 
-    int index = message.length() / 2;
+    int index = message.size() / 2;
     QByteArray leftPart(message.mid(0, index));
     QByteArray rightPart(message.mid(index));
 
diff --git a/tests/auto/corelib/tools/qset/tst_qset.cpp b/tests/auto/corelib/tools/qset/tst_qset.cpp
index bd88c19bd0..433568be63 100644
--- a/tests/auto/corelib/tools/qset/tst_qset.cpp
+++ b/tests/auto/corelib/tools/qset/tst_qset.cpp
@@ -8,7 +8,7 @@
 int toNumber(const QString &str)
 {
     int res = 0;
-    for (int i = 0; i < str.length(); ++i)
+    for (int i = 0; i < str.size(); ++i)
         res = (res * 10) + str[i].digitValue();
     return res;
 }
@@ -139,44 +139,44 @@ void tst_QSet::size()
     QSet<int> set;
     QVERIFY(set.size() == 0);
     QVERIFY(set.isEmpty());
-    QVERIFY(set.count() == set.size());
+    QVERIFY(set.size() == set.size());
     QVERIFY(set.isEmpty() == set.empty());
     QVERIFY(!set.isDetached());
 
     set.insert(1);
     QVERIFY(set.size() == 1);
     QVERIFY(!set.isEmpty());
-    QVERIFY(set.count() == set.size());
+    QVERIFY(set.size() == set.size());
     QVERIFY(set.isEmpty() == set.empty());
 
     set.insert(1);
     QVERIFY(set.size() == 1);
     QVERIFY(!set.isEmpty());
-    QVERIFY(set.count() == set.size());
+    QVERIFY(set.size() == set.size());
     QVERIFY(set.isEmpty() == set.empty());
 
     set.insert(2);
     QVERIFY(set.size() == 2);
     QVERIFY(!set.isEmpty());
-    QVERIFY(set.count() == set.size());
+    QVERIFY(set.size() == set.size());
     QVERIFY(set.isEmpty() == set.empty());
 
     set.remove(1);
     QVERIFY(set.size() == 1);
     QVERIFY(!set.isEmpty());
-    QVERIFY(set.count() == set.size());
+    QVERIFY(set.size() == set.size());
     QVERIFY(set.isEmpty() == set.empty());
 
     set.remove(1);
     QVERIFY(set.size() == 1);
     QVERIFY(!set.isEmpty());
-    QVERIFY(set.count() == set.size());
+    QVERIFY(set.size() == set.size());
     QVERIFY(set.isEmpty() == set.empty());
 
     set.remove(2);
     QVERIFY(set.size() == 0);
     QVERIFY(set.isEmpty());
-    QVERIFY(set.count() == set.size());
+    QVERIFY(set.size() == set.size());
     QVERIFY(set.isEmpty() == set.empty());
 }
 
@@ -1011,7 +1011,7 @@ void tst_QSet::makeSureTheComfortFunctionsCompile()
 void tst_QSet::initializerList()
 {
     QSet<int> set = {1, 1, 2, 3, 4, 5};
-    QCOMPARE(set.count(), 5);
+    QCOMPARE(set.size(), 5);
     QVERIFY(set.contains(1));
     QVERIFY(set.contains(2));
     QVERIFY(set.contains(3));
@@ -1020,7 +1020,7 @@ void tst_QSet::initializerList()
 
     // check _which_ of the equal elements gets inserted (in the QHash/QMap case, it's the last):
     const QSet<IdentityTracker> set2 = {{1, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
-    QCOMPARE(set2.count(), 5);
+    QCOMPARE(set2.size(), 5);
     const int dummy = -1;
     const IdentityTracker searchKey = {1, dummy};
     QCOMPARE(set2.find(searchKey)->id, 0);
diff --git a/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp b/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp
index 90609eb998..f455d7647e 100644
--- a/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp
+++ b/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp
@@ -2058,11 +2058,11 @@ void tst_QSharedPointer::threadStressTest()
         base.clear();
 
         // start threads
-        for (int i = 0; i < allThreads.count(); ++i)
+        for (int i = 0; i < allThreads.size(); ++i)
             if (allThreads[i]) allThreads[i]->start();
 
         // wait for them to finish
-        for (int i = 0; i < allThreads.count(); ++i)
+        for (int i = 0; i < allThreads.size(); ++i)
             if (allThreads[i]) allThreads[i]->wait();
         qDeleteAll(allThreads);
 
diff --git a/tests/auto/corelib/tools/qvarlengtharray/tst_qvarlengtharray.cpp b/tests/auto/corelib/tools/qvarlengtharray/tst_qvarlengtharray.cpp
index 508f709533..c21dfbfafb 100644
--- a/tests/auto/corelib/tools/qvarlengtharray/tst_qvarlengtharray.cpp
+++ b/tests/auto/corelib/tools/qvarlengtharray/tst_qvarlengtharray.cpp
@@ -936,8 +936,8 @@ void tst_QVarLengthArray::count()
     // tests size(), count() and length(), since they're the same thing
     {
         const QVarLengthArray<int> list;
-        QCOMPARE(list.length(), 0);
-        QCOMPARE(list.count(), 0);
+        QCOMPARE(list.size(), 0);
+        QCOMPARE(list.size(), 0);
         QCOMPARE(list.size(), 0);
         QVERIFY(list.isEmpty());
     }
@@ -945,8 +945,8 @@ void tst_QVarLengthArray::count()
     {
         QVarLengthArray<int> list;
         list.append(0);
-        QCOMPARE(list.length(), 1);
-        QCOMPARE(list.count(), 1);
+        QCOMPARE(list.size(), 1);
+        QCOMPARE(list.size(), 1);
         QCOMPARE(list.size(), 1);
         QVERIFY(!list.isEmpty());
     }
@@ -955,8 +955,8 @@ void tst_QVarLengthArray::count()
         QVarLengthArray<int> list;
         list.append(0);
         list.append(1);
-        QCOMPARE(list.length(), 2);
-        QCOMPARE(list.count(), 2);
+        QCOMPARE(list.size(), 2);
+        QCOMPARE(list.size(), 2);
         QCOMPARE(list.size(), 2);
         QVERIFY(!list.isEmpty());
     }
@@ -966,8 +966,8 @@ void tst_QVarLengthArray::count()
         list.append(0);
         list.append(0);
         list.append(0);
-        QCOMPARE(list.length(), 3);
-        QCOMPARE(list.count(), 3);
+        QCOMPARE(list.size(), 3);
+        QCOMPARE(list.size(), 3);
         QCOMPARE(list.size(), 3);
         QVERIFY(!list.isEmpty());
     }
@@ -978,23 +978,23 @@ void tst_QVarLengthArray::count()
         list.append(0);
         list.append(0);
         list.append(0);
-        QCOMPARE(list.length(), 3);
-        QCOMPARE(list.count(), 3);
+        QCOMPARE(list.size(), 3);
+        QCOMPARE(list.size(), 3);
         QCOMPARE(list.size(), 3);
         QVERIFY(!list.isEmpty());
         list.removeLast();
-        QCOMPARE(list.length(), 2);
-        QCOMPARE(list.count(), 2);
+        QCOMPARE(list.size(), 2);
+        QCOMPARE(list.size(), 2);
         QCOMPARE(list.size(), 2);
         QVERIFY(!list.isEmpty());
         list.removeLast();
-        QCOMPARE(list.length(), 1);
-        QCOMPARE(list.count(), 1);
+        QCOMPARE(list.size(), 1);
+        QCOMPARE(list.size(), 1);
         QCOMPARE(list.size(), 1);
         QVERIFY(!list.isEmpty());
         list.removeLast();
-        QCOMPARE(list.length(), 0);
-        QCOMPARE(list.count(), 0);
+        QCOMPARE(list.size(), 0);
+        QCOMPARE(list.size(), 0);
         QCOMPARE(list.size(), 0);
         QVERIFY(list.isEmpty());
     }
@@ -1033,16 +1033,16 @@ void tst_QVarLengthArray::first()
     QCOMPARE(list.first(), 27);
     list.append(1987);
     QCOMPARE(list.first(), 27);
-    QCOMPARE(list.length(), 3);
+    QCOMPARE(list.size(), 3);
 
     // remove some, make sure it stays sane
     list.removeLast();
     QCOMPARE(list.first(), 27);
-    QCOMPARE(list.length(), 2);
+    QCOMPARE(list.size(), 2);
 
     list.removeLast();
     QCOMPARE(list.first(), 27);
-    QCOMPARE(list.length(), 1);
+    QCOMPARE(list.size(), 1);
 }
 
 void tst_QVarLengthArray::last()
@@ -1055,16 +1055,16 @@ void tst_QVarLengthArray::last()
     QCOMPARE(list.last(), 4);
     list.append(1987);
     QCOMPARE(list.last(), 1987);
-    QCOMPARE(list.length(), 3);
+    QCOMPARE(list.size(), 3);
 
     // remove some, make sure it stays sane
     list.removeLast();
     QCOMPARE(list.last(), 4);
-    QCOMPARE(list.length(), 2);
+    QCOMPARE(list.size(), 2);
 
     list.removeLast();
     QCOMPARE(list.last(), 27);
-    QCOMPARE(list.length(), 1);
+    QCOMPARE(list.size(), 1);
 }
 
 void tst_QVarLengthArray::squeeze()