Use QList instead of QVector in corelib tests

Task-number: QTBUG-84469
Change-Id: Ic80fde5517aed363f17d0da55cadcc958c3c8895
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>

10 files changed, 198 insertions, 230 deletions

diff --git a/tests/auto/corelib/tools/collections/tst_collections.cpp b/tests/auto/corelib/tools/collections/tst_collections.cpp
index f7b6f478cf..61a0db26de 100644
--- a/tests/auto/corelib/tools/collections/tst_collections.cpp
+++ b/tests/auto/corelib/tools/collections/tst_collections.cpp
@@ -42,7 +42,7 @@ static QSet<int> *setX;
 static QStack<int> *stackX;
 static QVarLengthArray<int> *varLengthArrayX;
 static QVarLengthArray<int, 512> *varLengthArrayY;
-static QVector<int> *vectorX;
+static QList<int> *vectorX;
 
 void foo()
 {
@@ -78,7 +78,6 @@ void foo()
 #include "qstring.h"
 #include "qstringlist.h"
 #include "qvarlengtharray.h"
-#include "qvector.h"
 #include "qqueue.h"
 
 class tst_Collections : public QObject
@@ -470,7 +469,7 @@ void tst_Collections::list()
     }
 
     {
-        QVector<QString> vector(5);
+        QList<QString> vector(5);
         vector[0] = "99";
         vector[4] ="100";
         QList<QString> list = vector.toList();
@@ -726,7 +725,7 @@ void tst_Collections::list()
 
 void tst_Collections::vector()
 {
-    QVector<int> v1;
+    QList<int> v1;
     v1 << 1 << 2 << 3;
     QVector<int> v2;
     v2 << 4 << 5;
@@ -2495,13 +2494,12 @@ void testMapLikeStlIterators()
 
 void tst_Collections::constAndNonConstStlIterators()
 {
-    testListLikeStlIterators<QList<int> >();
-    testListLikeStlIterators<QStringList >();
-    testListLikeStlIterators<QVector<int> >();
-    testMapLikeStlIterators<QMap<QString, QString> >();
-    testMapLikeStlIterators<QMultiMap<QString, QString> >();
-    testMapLikeStlIterators<QHash<QString, QString> >();
-    testMapLikeStlIterators<QMultiHash<QString, QString> >();
+    testListLikeStlIterators<QList<int>>();
+    testListLikeStlIterators<QStringList>();
+    testMapLikeStlIterators<QMap<QString, QString>>();
+    testMapLikeStlIterators<QMultiMap<QString, QString>>();
+    testMapLikeStlIterators<QHash<QString, QString>>();
+    testMapLikeStlIterators<QMultiHash<QString, QString>>();
 }
 
 void tst_Collections::vector_stl_data()
@@ -2518,7 +2516,7 @@ void tst_Collections::vector_stl()
 {
     QFETCH(QStringList, elements);
 
-    QVector<QString> vector;
+    QList<QString> vector;
     for (int i = 0; i < elements.count(); ++i)
         vector << elements.at(i);
 
@@ -2534,9 +2532,9 @@ void tst_Collections::vector_stl()
         QCOMPARE(*it, vector[j]);
 
 #if QT_VERSION < QT_VERSION_CHECK(6,0,0)
-    QCOMPARE(QVector<QString>::fromStdVector(stdVector), vector);
+    QCOMPARE(QList<QString>::fromStdVector(stdVector), vector);
 #endif
-    QCOMPARE(QVector<QString>(stdVector.begin(), stdVector.end()), vector);
+    QCOMPARE(QList<QString>(stdVector.begin(), stdVector.end()), vector);
 }
 
 void tst_Collections::list_stl_data()
@@ -2789,10 +2787,6 @@ void tst_Collections::containerInstantiation()
         list.removeAll(value);
     }
 
-    //Instantiate QVector member functions.
-    typedef QVector<EqualsComparable> Vector;
-    instantiateRandomAccess<Vector, EqualsComparable>();
-
     //Instantiate QQueue member functions.
     typedef QQueue<EqualsComparable> Queue;
     instantiateRandomAccess<Queue, EqualsComparable>();
@@ -2883,7 +2877,6 @@ void testSetContainerTypedefs(Container container)
 */
 void tst_Collections::containerTypedefs()
 {
-    testContainerTypedefs(QVector<int>());
     testContainerTypedefs(QStack<int>());
     testContainerTypedefs(QList<int>());
     testContainerTypedefs(QQueue<int>());
@@ -3032,18 +3025,18 @@ void testAssociativeContainerAlignment()
 
 void tst_Collections::alignment()
 {
-    testVectorAlignment<QVector<Aligned4> >();
-    testVectorAlignment<QVector<AlignedBiggest> >();
-    testContiguousCacheAlignment<QContiguousCache<Aligned4> >();
-    testContiguousCacheAlignment<QContiguousCache<AlignedBiggest> >();
-    testAssociativeContainerAlignment<QMap<Aligned4, Aligned4> >();
-    testAssociativeContainerAlignment<QMap<Aligned4, AlignedBiggest> >();
-    testAssociativeContainerAlignment<QMap<AlignedBiggest, Aligned4> >();
-    testAssociativeContainerAlignment<QMap<AlignedBiggest, AlignedBiggest> >();
-    testAssociativeContainerAlignment<QHash<Aligned4, Aligned4> >();
-    testAssociativeContainerAlignment<QHash<Aligned4, AlignedBiggest> >();
-    testAssociativeContainerAlignment<QHash<AlignedBiggest, Aligned4> >();
-    testAssociativeContainerAlignment<QHash<AlignedBiggest, AlignedBiggest> >();
+    testVectorAlignment<QList<Aligned4>>();
+    testVectorAlignment<QList<AlignedBiggest>>();
+    testContiguousCacheAlignment<QContiguousCache<Aligned4>>();
+    testContiguousCacheAlignment<QContiguousCache<AlignedBiggest>>();
+    testAssociativeContainerAlignment<QMap<Aligned4, Aligned4>>();
+    testAssociativeContainerAlignment<QMap<Aligned4, AlignedBiggest>>();
+    testAssociativeContainerAlignment<QMap<AlignedBiggest, Aligned4>>();
+    testAssociativeContainerAlignment<QMap<AlignedBiggest, AlignedBiggest>>();
+    testAssociativeContainerAlignment<QHash<Aligned4, Aligned4>>();
+    testAssociativeContainerAlignment<QHash<Aligned4, AlignedBiggest>>();
+    testAssociativeContainerAlignment<QHash<AlignedBiggest, Aligned4>>();
+    testAssociativeContainerAlignment<QHash<AlignedBiggest, AlignedBiggest>>();
 }
 
 #ifndef QT_NO_TEMPLATE_TEMPLATE_PARAMETERS
@@ -3327,25 +3320,25 @@ using ExtList = QList<T>;
 
 void tst_Collections::insert_remove_loop()
 {
-    insert_remove_loop_impl<ExtList<int> >();
-    insert_remove_loop_impl<ExtList<QString> >();
-    insert_remove_loop_impl<QVector<int> >();
-    insert_remove_loop_impl<QVector<QString> >();
-    insert_remove_loop_impl<QVarLengthArray<int> >();
-    insert_remove_loop_impl<QVarLengthArray<QString> >();
-    insert_remove_loop_impl<QVarLengthArray<int, 10> >();
-    insert_remove_loop_impl<QVarLengthArray<QString, 10> >();
-    insert_remove_loop_impl<QVarLengthArray<int, 3> >();
-    insert_remove_loop_impl<QVarLengthArray<QString, 3> >();
-    insert_remove_loop_impl<QVarLengthArray<int, 15> >();
-    insert_remove_loop_impl<QVarLengthArray<QString, 15> >();
-
-    insert_remove_loop_impl<ExtList<std::string> >();
-    insert_remove_loop_impl<QVector<std::string> >();
-    insert_remove_loop_impl<QVarLengthArray<std::string> >();
-    insert_remove_loop_impl<QVarLengthArray<std::string, 10> >();
-    insert_remove_loop_impl<QVarLengthArray<std::string, 3> >();
-    insert_remove_loop_impl<QVarLengthArray<std::string, 15> >();
+    insert_remove_loop_impl<ExtList<int>>();
+    insert_remove_loop_impl<ExtList<QString>>();
+    insert_remove_loop_impl<QList<int>>();
+    insert_remove_loop_impl<QList<QString>>();
+    insert_remove_loop_impl<QVarLengthArray<int>>();
+    insert_remove_loop_impl<QVarLengthArray<QString>>();
+    insert_remove_loop_impl<QVarLengthArray<int, 10>>();
+    insert_remove_loop_impl<QVarLengthArray<QString, 10>>();
+    insert_remove_loop_impl<QVarLengthArray<int, 3>>();
+    insert_remove_loop_impl<QVarLengthArray<QString, 3>>();
+    insert_remove_loop_impl<QVarLengthArray<int, 15>>();
+    insert_remove_loop_impl<QVarLengthArray<QString, 15>>();
+
+    insert_remove_loop_impl<ExtList<std::string>>();
+    insert_remove_loop_impl<QList<std::string>>();
+    insert_remove_loop_impl<QVarLengthArray<std::string>>();
+    insert_remove_loop_impl<QVarLengthArray<std::string, 10>>();
+    insert_remove_loop_impl<QVarLengthArray<std::string, 3>>();
+    insert_remove_loop_impl<QVarLengthArray<std::string, 15>>();
 }
 
 
diff --git a/tests/auto/corelib/tools/containerapisymmetry/tst_containerapisymmetry.cpp b/tests/auto/corelib/tools/containerapisymmetry/tst_containerapisymmetry.cpp
index 558c15d441..a7fa5094c5 100644
--- a/tests/auto/corelib/tools/containerapisymmetry/tst_containerapisymmetry.cpp
+++ b/tests/auto/corelib/tools/containerapisymmetry/tst_containerapisymmetry.cpp
@@ -29,12 +29,11 @@
 #include <QtTest/QtTest>
 
 #include "qbytearray.h"
+#include "qdebug.h"
+#include "qhash.h"
 #include "qlist.h"
 #include "qstring.h"
 #include "qvarlengtharray.h"
-#include "qvector.h"
-#include "qhash.h"
-#include "qdebug.h"
 
 #include <algorithm>
 #include <functional>
@@ -269,19 +268,14 @@ private Q_SLOTS:
     void ranged_ctor_std_vector_Complex() { ranged_ctor_non_associative_impl<std::vector<Complex>>(); }
     void ranged_ctor_std_vector_duplicates_strategy() { non_associative_container_duplicates_strategy<std::vector>(); }
 
-    void ranged_ctor_QVector_int() { ranged_ctor_non_associative_impl<QVector<int>>(); }
-    void ranged_ctor_QVector_char() { ranged_ctor_non_associative_impl<QVector<char>>(); }
-    void ranged_ctor_QVector_QChar() { ranged_ctor_non_associative_impl<QVector<QChar>>(); }
-    void ranged_ctor_QVector_Movable() { ranged_ctor_non_associative_impl<QVector<Movable>>(); }
-    void ranged_ctor_QVector_Complex() { ranged_ctor_non_associative_impl<QVector<Complex>>(); }
-    void ranged_ctor_QVector_duplicates_strategy() { non_associative_container_duplicates_strategy<QVector>(); }
-
     void ranged_ctor_QVarLengthArray_int() { ranged_ctor_non_associative_impl<QVarLengthArray<int>>(); }
     void ranged_ctor_QVarLengthArray_Movable() { ranged_ctor_non_associative_impl<QVarLengthArray<Movable>>(); }
     void ranged_ctor_QVarLengthArray_Complex() { ranged_ctor_non_associative_impl<QVarLengthArray<Complex>>(); }
     void ranged_ctor_QVarLengthArray_duplicates_strategy() { non_associative_container_duplicates_strategy<VarLengthArray>(); } // note the VarLengthArray passed
 
     void ranged_ctor_QList_int() { ranged_ctor_non_associative_impl<QList<int>>(); }
+    void ranged_ctor_QList_char() { ranged_ctor_non_associative_impl<QList<char>>(); }
+    void ranged_ctor_QList_QChar() { ranged_ctor_non_associative_impl<QList<QChar>>(); }
     void ranged_ctor_QList_Movable() { ranged_ctor_non_associative_impl<QList<Movable>>(); }
     void ranged_ctor_QList_Complex() { ranged_ctor_non_associative_impl<QList<Complex>>(); }
     void ranged_ctor_QList_duplicates_strategy() { non_associative_container_duplicates_strategy<QList>(); }
@@ -474,7 +468,6 @@ private:
 
 private Q_SLOTS:
     void front_back_std_vector() { front_back_impl<std::vector<int>>(); }
-    void front_back_QVector() { front_back_impl<QVector<int>>(); }
     void front_back_QList() { front_back_impl<QList<qintptr>>(); }
     void front_back_QVarLengthArray() { front_back_impl<QVarLengthArray<int>>(); }
     void front_back_QString() { front_back_impl<QString>(); }
diff --git a/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp b/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp
index aac429043d..078351f388 100644
--- a/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp
+++ b/tests/auto/corelib/tools/qalgorithms/tst_qalgorithms.cpp
@@ -35,10 +35,10 @@
 #include <iterator>
 #include <algorithm>
 #include <qalgorithms.h>
-#include <QStringList>
-#include <QString>
+#include <QList>
 #include <QRandomGenerator>
-#include <QVector>
+#include <QString>
+#include <QStringList>
 
 #define Q_TEST_PERFORMANCE 0
 
@@ -137,9 +137,9 @@ QStringList dataSetTypes = QStringList() << "Random" << "Ascending"
                 << "Descending" << "Equal" << "Duplicates" << "Almost Sorted"  ;
 
 template <typename DataType>
-QVector<DataType> generateData(QString dataSetType, const int length)
+QList<DataType> generateData(QString dataSetType, const int length)
 {
-    QVector<DataType> container;
+    QList<DataType> container;
     if (dataSetType == "Random") {
         for (int i = 0; i < length; ++i)
             container.append(QRandomGenerator::global()->generate());
@@ -236,7 +236,7 @@ QList<ResultSet> testAlgorithm(Algorithm &algorithm,  QStringList dataSetTypes,
 {
     QList<ResultSet> results;
     foreach(QString dataSetType, dataSetTypes) {
-        QVector<DataType> container = generateData<DataType>(dataSetType, size);
+        QList<DataType> container = generateData<DataType>(dataSetType, size);
         results.append(testRun(container, algorithm, time));
         if (!isSorted(container))
             qWarning("%s: container is not sorted after test", Q_FUNC_INFO);
@@ -534,22 +534,6 @@ void tst_QAlgorithms::qBinaryFindOneEntry()
 
 void tst_QAlgorithms::sortAPItest()
 {
-    QVector<int> testVector = generateData<int>("Random", 101);
-    qSort(testVector);
-    QVERIFY(isSorted(testVector));
-    qSort(testVector.begin(), testVector.end());
-    QVERIFY(isSorted(testVector));
-    qSort(testVector.begin(), testVector.end(), qLess<int>());
-    QVERIFY(isSorted(testVector));
-
-    testVector = generateData<int>("Random", 71);
-    qStableSort(testVector);
-    QVERIFY(isSorted(testVector));
-    qStableSort(testVector.begin(), testVector.end());
-    QVERIFY(isSorted(testVector));
-    qStableSort(testVector.begin(), testVector.end(), qLess<int>());
-    QVERIFY(isSorted(testVector));
-
     QList<int> testList = generateData<int>("Random", 101).toList();
     qSort(testList);
     QVERIFY(isSorted(testList));
@@ -582,15 +566,14 @@ int Minor;
 
 ostream &operator<<(ostream &out, const StableSortTest& obj)  { out << obj.Major << "-" << obj.Minor; return out; }
 
-QVector<StableSortTest> createStableTestVector()
+QList<StableSortTest> createStableTestList()
 {
-    QVector<StableSortTest> stableTestVector;
-    for (int i=500; i>=0; --i) {
-        for (int j=0; j<10; ++j) {
-            stableTestVector.append(StableSortTest(i, j));
-        }
+    QList<StableSortTest> stableTestList;
+    for (int i = 500; i >= 0; --i) {
+        for (int j = 0; j < 10; ++j)
+            stableTestList.append(StableSortTest(i, j));
     }
-    return stableTestVector;
+    return stableTestList;
 }
 
 template <typename ContainerType, typename LessThan>
@@ -614,52 +597,52 @@ void tst_QAlgorithms::stableSortTest()
 {
     // Selftests:
     {
-        QVector<StableSortTest> stableTestVector = createStableTestVector();
-        qSort(stableTestVector.begin(), stableTestVector.end(), qLess<StableSortTest>());
-        QVERIFY(isSorted(stableTestVector, qLess<StableSortTest>()));
-        QVERIFY(!isStableSorted(stableTestVector, qLess<StableSortTest>()));
+        QList<StableSortTest> stableTestList = createStableTestList();
+        qSort(stableTestList.begin(), stableTestList.end(), qLess<StableSortTest>());
+        QVERIFY(isSorted(stableTestList, qLess<StableSortTest>()));
+        QVERIFY(!isStableSorted(stableTestList, qLess<StableSortTest>()));
     }
     {
-        QVector<StableSortTest> stableTestVector = createStableTestVector();
-        qSort(stableTestVector.begin(), stableTestVector.end(), qGreater<StableSortTest>());
-        QVERIFY(isSorted(stableTestVector, qGreater<StableSortTest>()));
-        QVERIFY(!isStableSorted(stableTestVector, qGreater<StableSortTest>()));
+        QList<StableSortTest> stableTestList = createStableTestList();
+        qSort(stableTestList.begin(), stableTestList.end(), qGreater<StableSortTest>());
+        QVERIFY(isSorted(stableTestList, qGreater<StableSortTest>()));
+        QVERIFY(!isStableSorted(stableTestList, qGreater<StableSortTest>()));
     }
     {
-        QVector<StableSortTest> stableTestVector = createStableTestVector();
-        qSort(stableTestVector.begin(), stableTestVector.end(), qGreater<StableSortTest>());
-        QVERIFY(!isSorted(stableTestVector, qLess<StableSortTest>()));
-        QVERIFY(!isStableSorted(stableTestVector, qGreater<StableSortTest>()));
+        QList<StableSortTest> stableTestList = createStableTestList();
+        qSort(stableTestList.begin(), stableTestList.end(), qGreater<StableSortTest>());
+        QVERIFY(!isSorted(stableTestList, qLess<StableSortTest>()));
+        QVERIFY(!isStableSorted(stableTestList, qGreater<StableSortTest>()));
     }
 
 
     // Stable sort with qLess
     {
-        QVector<StableSortTest> stableTestVector = createStableTestVector();
-        std::stable_sort(stableTestVector.begin(), stableTestVector.end(), qLess<StableSortTest>());
-        QVERIFY(isSorted(stableTestVector, qLess<StableSortTest>()));
-        QVERIFY(isStableSorted(stableTestVector, qLess<StableSortTest>()));
+        QList<StableSortTest> stableTestList = createStableTestList();
+        std::stable_sort(stableTestList.begin(), stableTestList.end(), qLess<StableSortTest>());
+        QVERIFY(isSorted(stableTestList, qLess<StableSortTest>()));
+        QVERIFY(isStableSorted(stableTestList, qLess<StableSortTest>()));
     }
     {
-        QVector<StableSortTest> stableTestVector = createStableTestVector();
-        qStableSort(stableTestVector.begin(), stableTestVector.end(), qLess<StableSortTest>());
-        QVERIFY(isSorted(stableTestVector, qLess<StableSortTest>()));
-        QVERIFY(isStableSorted(stableTestVector, qLess<StableSortTest>()));
+        QList<StableSortTest> stableTestList = createStableTestList();
+        qStableSort(stableTestList.begin(), stableTestList.end(), qLess<StableSortTest>());
+        QVERIFY(isSorted(stableTestList, qLess<StableSortTest>()));
+        QVERIFY(isStableSorted(stableTestList, qLess<StableSortTest>()));
     }
 
     // Stable sort with qGreater
     {
-        QVector<StableSortTest> stableTestVector = createStableTestVector();
-        std::stable_sort(stableTestVector.begin(), stableTestVector.end(), qGreater<StableSortTest>());
-        QVERIFY(isSorted(stableTestVector, qGreater<StableSortTest>()));
-        QVERIFY(isStableSorted(stableTestVector, qGreater<StableSortTest>()));
+        QList<StableSortTest> stableTestList = createStableTestList();
+        std::stable_sort(stableTestList.begin(), stableTestList.end(), qGreater<StableSortTest>());
+        QVERIFY(isSorted(stableTestList, qGreater<StableSortTest>()));
+        QVERIFY(isStableSorted(stableTestList, qGreater<StableSortTest>()));
     }
 
     {
-        QVector<StableSortTest> stableTestVector = createStableTestVector();
-        qStableSort(stableTestVector.begin(), stableTestVector.end(), qGreater<StableSortTest>());
-        QVERIFY(isSorted(stableTestVector, qGreater<StableSortTest>()));
-        QVERIFY(isStableSorted(stableTestVector, qGreater<StableSortTest>()));
+        QList<StableSortTest> stableTestList = createStableTestList();
+        qStableSort(stableTestList.begin(), stableTestList.end(), qGreater<StableSortTest>());
+        QVERIFY(isSorted(stableTestList, qGreater<StableSortTest>()));
+        QVERIFY(isStableSorted(stableTestList, qGreater<StableSortTest>()));
     }
 }
 
@@ -667,8 +650,8 @@ void tst_QAlgorithms::stableSortTest()
 void tst_QAlgorithms::stableSortCorrectnessTest_data()
 {
     const int dataSize = 1000;
-    QTest::addColumn<QVector<int> >("unsorted");
-    QTest::newRow("From documentation") << (QVector<int>() << 33 << 12 << 68 << 6 << 12);
+    QTest::addColumn<QList<int>>("unsorted");
+    QTest::newRow("From documentation") << (QList<int>() << 33 << 12 << 68 << 6 << 12);
     QTest::newRow("Equal") << (generateData<int>("Equal", dataSize));
     QTest::newRow("Ascending") << (generateData<int>("Ascending", dataSize));
     QTest::newRow("Descending") << (generateData<int>("Descending", dataSize));
@@ -679,9 +662,9 @@ void tst_QAlgorithms::stableSortCorrectnessTest_data()
 
 void tst_QAlgorithms::stableSortCorrectnessTest()
 {
-    QFETCH(QVector<int>, unsorted);
+    QFETCH(QList<int>, unsorted);
 
-    QVector<int> sorted = unsorted;
+    QList<int> sorted = unsorted;
     qStableSort(sorted.begin(), sorted.end());
 
     // Verify that sorted contains the same numbers as unsorted.
@@ -743,7 +726,7 @@ template <typename DataType>
 class QuickSortHelper
 {
 public:
-    void operator()(QVector<DataType> list)
+    void operator()(QList<DataType> list)
     {
         ::qSort(list);
     }
@@ -753,7 +736,7 @@ template <typename DataType>
 class StableSortHelper
 {
 public:
-    void operator()(QVector<DataType> list)
+    void operator()(QList<DataType> list)
     {
         ::qStableSort(list);
     }
@@ -763,7 +746,7 @@ template <typename DataType>
 class StlSortHelper
 {
 public:
-    void operator()(QVector<DataType> list)
+    void operator()(QList<DataType> list)
     {
         std::sort(list.begin(), list.end());
     }
@@ -773,7 +756,7 @@ template <typename DataType>
 class StlStableSortHelper
 {
 public:
-    void operator()(QVector<DataType> list)
+    void operator()(QList<DataType> list)
     {
         std::stable_sort(list.begin(), list.end());
     }
diff --git a/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp b/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp
index 9ebcda4cef..c7f20ec6a4 100644
--- a/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp
+++ b/tests/auto/corelib/tools/qarraydata/tst_qarraydata.cpp
@@ -417,7 +417,7 @@ struct Deallocator
 
     size_t objectSize;
     size_t alignment;
-    QVector<QArrayData *> headers;
+    QList<QArrayData *> headers;
 };
 
 Q_DECLARE_METATYPE(const QArrayData *)
@@ -652,7 +652,7 @@ void tst_QArrayData::gccBug43247()
 {
     // This test tries to verify QArrayData is not affected by GCC optimizer
     // bug #43247.
-    // Reported on GCC 4.4.3, Linux, affects QVector
+    // Reported on GCC 4.4.3, Linux, affects QList
 
     QTest::ignoreMessage(QtDebugMsg, "GCC Optimization bug #43247 not triggered (3)");
     QTest::ignoreMessage(QtDebugMsg, "GCC Optimization bug #43247 not triggered (4)");
@@ -661,7 +661,7 @@ void tst_QArrayData::gccBug43247()
     QTest::ignoreMessage(QtDebugMsg, "GCC Optimization bug #43247 not triggered (7)");
 
     SimpleVector<int> array(10, 0);
-    // QVector<int> vector(10, 0);
+    // QList<int> list(10, 0);
 
     for (int i = 0; i < 10; ++i) {
         if (i >= 3 && i < 8)
@@ -671,7 +671,7 @@ void tst_QArrayData::gccBug43247()
         // line lets the compiler assume i == 0, and the conditional above is
         // skipped.
         QVERIFY(array.at(i) == 0);
-        // QVERIFY(vector.at(i) == 0);
+        // QVERIFY(list.at(i) == 0);
     }
 }
 
@@ -1141,18 +1141,18 @@ void tst_QArrayData::literals()
     }
 
     {
-        QVector<char> v(Q_ARRAY_LITERAL(char, "ABCDEFGHIJ"));
-        QCOMPARE(v.size(), 11);
-        QCOMPARE(v.capacity(), 0);
+        QList<char> l(Q_ARRAY_LITERAL(char, "ABCDEFGHIJ"));
+        QCOMPARE(l.size(), 11);
+        QCOMPARE(l.capacity(), 0);
         for (int i = 0; i < 10; ++i)
-            QCOMPARE(v.at(i), char('A' + i));
+            QCOMPARE(l.at(i), char('A' + i));
 
-        (void)v.begin(); // "detach"
+        (void)l.begin(); // "detach"
 
-        QCOMPARE(v.size(), 11);
-        QVERIFY(v.capacity() >= v.size());
+        QCOMPARE(l.size(), 11);
+        QVERIFY(l.capacity() >= l.size());
         for (int i = 0; i < 10; ++i)
-            QCOMPARE(v[i], char('A' + i));
+            QCOMPARE(l[i], char('A' + i));
     }
 
     {
@@ -1176,18 +1176,18 @@ void tst_QArrayData::literals()
     }
 
     {
-        QVector<LiteralType> v(Q_ARRAY_LITERAL(LiteralType, LiteralType(0), LiteralType(1), LiteralType(2)));
-        QCOMPARE(v.size(), 3);
-        QCOMPARE(v.capacity(), 0);
+        QList<LiteralType> l(Q_ARRAY_LITERAL(LiteralType, LiteralType(0), LiteralType(1), LiteralType(2)));
+        QCOMPARE(l.size(), 3);
+        QCOMPARE(l.capacity(), 0);
         for (int i = 0; i < 3; ++i)
-            QCOMPARE(v.at(i).value, i);
+            QCOMPARE(l.at(i).value, i);
 
-        (void)v.begin(); // "detach"
+        (void)l.begin(); // "detach"
 
-        QCOMPARE(v.size(), 3);
-        QVERIFY(v.capacity() >= v.size());
+        QCOMPARE(l.size(), 3);
+        QVERIFY(l.capacity() >= l.size());
         for (int i = 0; i < 3; ++i)
-            QCOMPARE(v[i].value, i);
+            QCOMPARE(l[i].value, i);
     }
 }
 
diff --git a/tests/auto/corelib/tools/qeasingcurve/tst_qeasingcurve.cpp b/tests/auto/corelib/tools/qeasingcurve/tst_qeasingcurve.cpp
index 898ac86874..9b32d3a797 100644
--- a/tests/auto/corelib/tools/qeasingcurve/tst_qeasingcurve.cpp
+++ b/tests/auto/corelib/tools/qeasingcurve/tst_qeasingcurve.cpp
@@ -602,7 +602,7 @@ static inline void setupBezierSpline(QEasingCurve *easingCurve, const QString &s
 {
     QStringList pointStr = string.split(QLatin1Char(' '));
 
-    QVector<QPointF> points;
+    QList<QPointF> points;
     foreach (const QString &str, pointStr) {
         QStringList coordStr = str.split(QLatin1Char(','));
         QPointF point(coordStr.first().toDouble(), coordStr.last().toDouble());
diff --git a/tests/auto/corelib/tools/qflatmap/tst_qflatmap.cpp b/tests/auto/corelib/tools/qflatmap/tst_qflatmap.cpp
index a5ae6f5f44..dbde140d70 100644
--- a/tests/auto/corelib/tools/qflatmap/tst_qflatmap.cpp
+++ b/tests/auto/corelib/tools/qflatmap/tst_qflatmap.cpp
@@ -33,7 +33,6 @@
 #include <qstring.h>
 #include <qstringview.h>
 #include <qvarlengtharray.h>
-#include <qvector.h>
 
 #include <algorithm>
 #include <list>
diff --git a/tests/auto/corelib/tools/qlist/tst_qlist.cpp b/tests/auto/corelib/tools/qlist/tst_qlist.cpp
index fbd5cf6402..e2044288d2 100644
--- a/tests/auto/corelib/tools/qlist/tst_qlist.cpp
+++ b/tests/auto/corelib/tools/qlist/tst_qlist.cpp
@@ -2826,7 +2826,7 @@ void tst_QList::emplaceConsistentWithStdVectorImpl() const
     vecEq(qVec, stdVec);
 
     T t;
-    // while QVector is safe with regards to emplacing elements moved form itself, it's UB
+    // while QList is safe with regards to emplacing elements moved form itself, it's UB
     // for std::vector, so do the moving in two steps there.
     qVec.emplaceBack(std::move(qVec[0]));
     stdVec.emplace_back(std::move(t = std::move(stdVec[0])));
diff --git a/tests/auto/corelib/tools/qringbuffer/tst_qringbuffer.cpp b/tests/auto/corelib/tools/qringbuffer/tst_qringbuffer.cpp
index e355a7fcfb..10e6294b48 100644
--- a/tests/auto/corelib/tools/qringbuffer/tst_qringbuffer.cpp
+++ b/tests/auto/corelib/tools/qringbuffer/tst_qringbuffer.cpp
@@ -29,7 +29,7 @@
 #include <QtTest/QtTest>
 
 #include <private/qringbuffer_p.h>
-#include <qvector.h>
+#include <qlist.h>
 
 class tst_QRingBuffer : public QObject
 {
@@ -82,7 +82,7 @@ void tst_QRingBuffer::constructing()
 void tst_QRingBuffer::usingInVector()
 {
     QRingBuffer ringBuffer;
-    QVector<QRingBuffer> buffers;
+    QList<QRingBuffer> buffers;
 
     ringBuffer.reserve(5);
     buffers.append(ringBuffer);
diff --git a/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp b/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp
index cfc1f13cb2..ccbae61c06 100644
--- a/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp
+++ b/tests/auto/corelib/tools/qsharedpointer/tst_qsharedpointer.cpp
@@ -31,9 +31,9 @@
 #include "qsharedpointer.h"
 #include <QtTest/QtTest>
 #include <QtCore/QHash>
+#include <QtCore/QList>
 #include <QtCore/QMap>
 #include <QtCore/QThread>
-#include <QtCore/QVector>
 
 #include "externaltests.h"
 #include "forwarddeclared.h"
@@ -2114,7 +2114,7 @@ void tst_QSharedPointer::threadStressTest()
     memset(guard2, 0, sizeof guard2);
 
     for (int r = 0; r < 5; ++r) {
-        QVector<QThread*> allThreads(6 * qMax(strongThreadCount, weakThreadCount) + 3, 0);
+        QList<QThread*> allThreads(6 * qMax(strongThreadCount, weakThreadCount) + 3, 0);
         QSharedPointer<ThreadData> base = QSharedPointer<ThreadData>(new ThreadData(&counter));
         counter.storeRelaxed(0);
 
diff --git a/tests/auto/corelib/tools/qversionnumber/tst_qversionnumber.cpp b/tests/auto/corelib/tools/qversionnumber/tst_qversionnumber.cpp
index 928bd365fd..291fcca88c 100644
--- a/tests/auto/corelib/tools/qversionnumber/tst_qversionnumber.cpp
+++ b/tests/auto/corelib/tools/qversionnumber/tst_qversionnumber.cpp
@@ -89,56 +89,56 @@ private slots:
 
 void tst_QVersionNumber::singleInstanceData()
 {
-    QTest::addColumn<QVector<int> >("segments");
+    QTest::addColumn<QList<int>>("segments");
     QTest::addColumn<QVersionNumber>("expectedVersion");
     QTest::addColumn<QString>("expectedString");
     QTest::addColumn<QString>("constructionString");
     QTest::addColumn<int>("suffixIndex");
     QTest::addColumn<bool>("isNull");
 
-    //                                        segments                           expectedVersion                                                      expectedString                    constructionString                         suffixIndex   null
-    QTest::newRow("null")                  << QVector<int>()                  << QVersionNumber(QVector<int>())                                    << QString()                      << QString()                               << 0          << true;
-    QTest::newRow("text")                  << QVector<int>()                  << QVersionNumber(QVector<int>())                                    << QString()                      << QStringLiteral("text")                  << 0          << true;
-    QTest::newRow(" text")                 << QVector<int>()                  << QVersionNumber(QVector<int>())                                    << QString()                      << QStringLiteral(" text")                 << 0          << true;
-    QTest::newRow("Empty String")          << QVector<int>()                  << QVersionNumber(QVector<int>())                                    << QString()                      << QStringLiteral("Empty String")          << 0          << true;
-    QTest::newRow("-1.-2")                 << (QVector<int>())                << QVersionNumber()                                                  << QStringLiteral("")             << QStringLiteral("-1.-2")                 << 0          << true;
-    QTest::newRow("1.-2-3")                << (QVector<int>() << 1)           << QVersionNumber(QVector<int>() << 1)                               << QStringLiteral("1")            << QStringLiteral("1.-2-3")                << 1          << false;
-    QTest::newRow("1.2-3")                 << (QVector<int>() << 1 << 2)      << QVersionNumber(QVector<int>() << 1 << 2)                          << QStringLiteral("1.2")          << QStringLiteral("1.2-3")                 << 3          << false;
-    QTest::newRow("0")                     << (QVector<int>() << 0)           << QVersionNumber(QVector<int>() << 0)                               << QStringLiteral("0")            << QStringLiteral("0")                     << 1          << false;
-    QTest::newRow("0.1")                   << (QVector<int>() << 0 << 1)      << QVersionNumber(QVector<int>() << 0 << 1)                          << QStringLiteral("0.1")          << QStringLiteral("0.1")                   << 3          << false;
-    QTest::newRow("0.1.2")                 << (QVector<int>() << 0 << 1 << 2) << QVersionNumber(0, 1, 2)                                           << QStringLiteral("0.1.2")        << QStringLiteral("0.1.2")                 << 5          << false;
-    QTest::newRow("0.1.2alpha")            << (QVector<int>() << 0 << 1 << 2) << QVersionNumber(0, 1, 2)                                           << QStringLiteral("0.1.2")        << QStringLiteral("0.1.2alpha")            << 5          << false;
-    QTest::newRow("0.1.2-alpha")           << (QVector<int>() << 0 << 1 << 2) << QVersionNumber(0, 1, 2)                                           << QStringLiteral("0.1.2")        << QStringLiteral("0.1.2-alpha")           << 5          << false;
-    QTest::newRow("0.1.2.alpha")           << (QVector<int>() << 0 << 1 << 2) << QVersionNumber(0, 1, 2)                                           << QStringLiteral("0.1.2")        << QStringLiteral("0.1.2.alpha")           << 5          << false;
-    QTest::newRow("0.1.2.3alpha")          << (QVector<int>() << 0 << 1 << 2 << 3) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3)           << QStringLiteral("0.1.2.3")      << QStringLiteral("0.1.2.3alpha")          << 7          << false;
-    QTest::newRow("0.1.2.3.alpha")         << (QVector<int>() << 0 << 1 << 2 << 3) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3)           << QStringLiteral("0.1.2.3")      << QStringLiteral("0.1.2.3.alpha")         << 7          << false;
-    QTest::newRow("0.1.2.3.4.alpha")       << (QVector<int>() << 0 << 1 << 2 << 3 << 4) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3 << 4) << QStringLiteral("0.1.2.3.4")    << QStringLiteral("0.1.2.3.4.alpha")       << 9          << false;
-    QTest::newRow("0.1.2.3.4 alpha")       << (QVector<int>() << 0 << 1 << 2 << 3 << 4) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3 << 4) << QStringLiteral("0.1.2.3.4")    << QStringLiteral("0.1.2.3.4 alpha")       << 9          << false;
-    QTest::newRow("0.1.2.3.4 alp ha")      << (QVector<int>() << 0 << 1 << 2 << 3 << 4) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3 << 4) << QStringLiteral("0.1.2.3.4")    << QStringLiteral("0.1.2.3.4 alp ha")      << 9          << false;
-    QTest::newRow("0.1.2.3.4alp ha")       << (QVector<int>() << 0 << 1 << 2 << 3 << 4) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3 << 4) << QStringLiteral("0.1.2.3.4")    << QStringLiteral("0.1.2.3.4alp ha")       << 9          << false;
-    QTest::newRow("0.1.2.3.4alpha ")       << (QVector<int>() << 0 << 1 << 2 << 3 << 4) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3 << 4) << QStringLiteral("0.1.2.3.4")    << QStringLiteral("0.1.2.3.4alpha ")       << 9          << false;
-    QTest::newRow("0.1.2.3.4.5alpha ")     << (QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5) << QStringLiteral("0.1.2.3.4.5") << QStringLiteral("0.1.2.3.4.5alpha ") << 11    << false;
-    QTest::newRow("0.1.2.3.4.5.6alpha ")   << (QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6) << QStringLiteral("0.1.2.3.4.5.6") << QStringLiteral("0.1.2.3.4.5.6alpha ")       << 13          << false;
-    QTest::newRow("0.1.2.3.4.5.6.7alpha ")  << (QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7) << QStringLiteral("0.1.2.3.4.5.6.7") << QStringLiteral("0.1.2.3.4.5.6.7alpha ")       << 15          << false;
-    QTest::newRow("0.1.2.3.4.5.6.7.8alpha ")  << (QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8) << QStringLiteral("0.1.2.3.4.5.6.7.8")    << QStringLiteral("0.1.2.3.4.5.6.7.8alpha ")       << 17          << false;
-    QTest::newRow("0.1.2.3.4.5.6.7.8.alpha")  << (QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8) << QStringLiteral("0.1.2.3.4.5.6.7.8")    << QStringLiteral("0.1.2.3.4.5.6.7.8.alpha")       << 17          << false;
-    QTest::newRow("0.1.2.3.4.5.6.7.8 alpha")  << (QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8) << QStringLiteral("0.1.2.3.4.5.6.7.8")    << QStringLiteral("0.1.2.3.4.5.6.7.8 alpha")       << 17          << false;
-    QTest::newRow("0.1.2.3.4.5.6.7.8 alp ha") << (QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8) << QStringLiteral("0.1.2.3.4.5.6.7.8")    << QStringLiteral("0.1.2.3.4.5.6.7.8 alp ha")      << 17          << false;
-    QTest::newRow("0.1.2.3.4.5.6.7.8alp ha")  << (QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8) << QVersionNumber(QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8) << QStringLiteral("0.1.2.3.4.5.6.7.8")    << QStringLiteral("0.1.2.3.4.5.6.7.8alp ha")       << 17          << false;
-    QTest::newRow("10.09")                 << (QVector<int>() << 10 << 9)     << QVersionNumber(QVector<int>() << 10 << 9)                         << QStringLiteral("10.9")         << QStringLiteral("10.09")                 << 5          << false;
-    QTest::newRow("10.0x")                 << (QVector<int>() << 10 << 0)     << QVersionNumber(QVector<int>() << 10 << 0)                         << QStringLiteral("10.0")         << QStringLiteral("10.0x")                 << 4          << false;
-    QTest::newRow("10.0xTest")             << (QVector<int>() << 10 << 0)     << QVersionNumber(QVector<int>() << 10 << 0)                         << QStringLiteral("10.0")         << QStringLiteral("10.0xTest")             << 4          << false;
-    QTest::newRow("127.09")                << (QVector<int>() << 127 << 9)    << QVersionNumber(QVector<int>() << 127 << 9)                        << QStringLiteral("127.9")        << QStringLiteral("127.09")                << 6          << false;
-    QTest::newRow("127.0x")                << (QVector<int>() << 127 << 0)    << QVersionNumber(QVector<int>() << 127 << 0)                        << QStringLiteral("127.0")        << QStringLiteral("127.0x")                << 5          << false;
-    QTest::newRow("127.0xTest")            << (QVector<int>() << 127 << 0)    << QVersionNumber(QVector<int>() << 127 << 0)                        << QStringLiteral("127.0")        << QStringLiteral("127.0xTest")            << 5          << false;
-    QTest::newRow("128.09")                << (QVector<int>() << 128 << 9)    << QVersionNumber(QVector<int>() << 128 << 9)                        << QStringLiteral("128.9")        << QStringLiteral("128.09")                << 6          << false;
-    QTest::newRow("128.0x")                << (QVector<int>() << 128 << 0)    << QVersionNumber(QVector<int>() << 128 << 0)                        << QStringLiteral("128.0")        << QStringLiteral("128.0x")                << 5          << false;
-    QTest::newRow("128.0xTest")            << (QVector<int>() << 128 << 0)    << QVersionNumber(QVector<int>() << 128 << 0)                        << QStringLiteral("128.0")        << QStringLiteral("128.0xTest")            << 5          << false;
+    //                                        segments                                    expectedVersion                                             expectedString                         constructionString                            suffixIndex null
+    QTest::newRow("null")                     << QList<int>()                             << QVersionNumber()                                         << QString()                           << QString()                                  << 0        << true;
+    QTest::newRow("text")                     << QList<int>()                             << QVersionNumber()                                         << QString()                           << QStringLiteral("text")                     << 0        << true;
+    QTest::newRow(" text")                    << QList<int>()                             << QVersionNumber()                                         << QString()                           << QStringLiteral(" text")                    << 0        << true;
+    QTest::newRow("Empty String")             << QList<int>()                             << QVersionNumber()                                         << QString()                           << QStringLiteral("Empty String")             << 0        << true;
+    QTest::newRow("-1.-2")                    << QList<int>()                             << QVersionNumber()                                         << QStringLiteral("")                  << QStringLiteral("-1.-2")                    << 0        << true;
+    QTest::newRow("1.-2-3")                   << QList<int> { 1 }                         << QVersionNumber(QList<int> { 1 })                         << QStringLiteral("1")                 << QStringLiteral("1.-2-3")                   << 1        << false;
+    QTest::newRow("1.2-3")                    << QList<int> { 1, 2 }                      << QVersionNumber(QList<int> { 1, 2 })                      << QStringLiteral("1.2")               << QStringLiteral("1.2-3")                    << 3        << false;
+    QTest::newRow("0")                        << QList<int> { 0 }                         << QVersionNumber(QList<int> { 0 })                         << QStringLiteral("0")                 << QStringLiteral("0")                        << 1        << false;
+    QTest::newRow("0.1")                      << QList<int> { 0, 1 }                      << QVersionNumber(QList<int> { 0, 1 })                      << QStringLiteral("0.1")               << QStringLiteral("0.1")                      << 3        << false;
+    QTest::newRow("0.1.2")                    << QList<int> { 0, 1, 2 }                   << QVersionNumber(QList<int> { 0, 1, 2 })                   << QStringLiteral("0.1.2")             << QStringLiteral("0.1.2")                    << 5        << false;
+    QTest::newRow("0.1.2alpha")               << QList<int> { 0, 1, 2 }                   << QVersionNumber(QList<int> { 0, 1, 2 })                   << QStringLiteral("0.1.2")             << QStringLiteral("0.1.2alpha")               << 5        << false;
+    QTest::newRow("0.1.2-alpha")              << QList<int> { 0, 1, 2 }                   << QVersionNumber(QList<int> { 0, 1, 2 })                   << QStringLiteral("0.1.2")             << QStringLiteral("0.1.2-alpha")              << 5        << false;
+    QTest::newRow("0.1.2.alpha")              << QList<int> { 0, 1, 2 }                   << QVersionNumber(QList<int> { 0, 1, 2 })                   << QStringLiteral("0.1.2")             << QStringLiteral("0.1.2.alpha")              << 5        << false;
+    QTest::newRow("0.1.2.3alpha")             << QList<int> { 0, 1, 2, 3 }                << QVersionNumber(QList<int> { 0, 1, 2, 3 })                << QStringLiteral("0.1.2.3")           << QStringLiteral("0.1.2.3alpha")             << 7        << false;
+    QTest::newRow("0.1.2.3.alpha")            << QList<int> { 0, 1, 2, 3 }                << QVersionNumber(QList<int> { 0, 1, 2, 3 })                << QStringLiteral("0.1.2.3")           << QStringLiteral("0.1.2.3.alpha")            << 7        << false;
+    QTest::newRow("0.1.2.3.4.alpha")          << QList<int> { 0, 1, 2, 3, 4 }             << QVersionNumber(QList<int> { 0, 1, 2, 3, 4 })             << QStringLiteral("0.1.2.3.4")         << QStringLiteral("0.1.2.3.4.alpha")          << 9        << false;
+    QTest::newRow("0.1.2.3.4 alpha")          << QList<int> { 0, 1, 2, 3, 4 }             << QVersionNumber(QList<int> { 0, 1, 2, 3, 4 })             << QStringLiteral("0.1.2.3.4")         << QStringLiteral("0.1.2.3.4 alpha")          << 9        << false;
+    QTest::newRow("0.1.2.3.4 alp ha")         << QList<int> { 0, 1, 2, 3, 4 }             << QVersionNumber(QList<int> { 0, 1, 2, 3, 4 })             << QStringLiteral("0.1.2.3.4")         << QStringLiteral("0.1.2.3.4 alp ha")         << 9        << false;
+    QTest::newRow("0.1.2.3.4alp ha")          << QList<int> { 0, 1, 2, 3, 4 }             << QVersionNumber(QList<int> { 0, 1, 2, 3, 4 })             << QStringLiteral("0.1.2.3.4")         << QStringLiteral("0.1.2.3.4alp ha")          << 9        << false;
+    QTest::newRow("0.1.2.3.4alpha ")          << QList<int> { 0, 1, 2, 3, 4 }             << QVersionNumber(QList<int> { 0, 1, 2, 3, 4 })             << QStringLiteral("0.1.2.3.4")         << QStringLiteral("0.1.2.3.4alpha ")          << 9        << false;
+    QTest::newRow("0.1.2.3.4.5alpha ")        << QList<int> { 0, 1, 2, 3, 4, 5 }          << QVersionNumber(QList<int> { 0, 1, 2, 3, 4, 5 })          << QStringLiteral("0.1.2.3.4.5")       << QStringLiteral("0.1.2.3.4.5alpha ")        << 11       << false;
+    QTest::newRow("0.1.2.3.4.5.6alpha ")      << QList<int> { 0, 1, 2, 3, 4, 5, 6 }       << QVersionNumber(QList<int> { 0, 1, 2, 3, 4, 5, 6 })       << QStringLiteral("0.1.2.3.4.5.6")     << QStringLiteral("0.1.2.3.4.5.6alpha ")      << 13       << false;
+    QTest::newRow("0.1.2.3.4.5.6.7alpha ")    << QList<int> { 0, 1, 2, 3, 4, 5, 6, 7 }    << QVersionNumber(QList<int> { 0, 1, 2, 3, 4, 5, 6, 7 })    << QStringLiteral("0.1.2.3.4.5.6.7")   << QStringLiteral("0.1.2.3.4.5.6.7alpha ")    << 15       << false;
+    QTest::newRow("0.1.2.3.4.5.6.7.8alpha ")  << QList<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8 } << QVersionNumber(QList<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8 }) << QStringLiteral("0.1.2.3.4.5.6.7.8") << QStringLiteral("0.1.2.3.4.5.6.7.8alpha ")  << 17       << false;
+    QTest::newRow("0.1.2.3.4.5.6.7.8.alpha")  << QList<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8 } << QVersionNumber(QList<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8 }) << QStringLiteral("0.1.2.3.4.5.6.7.8") << QStringLiteral("0.1.2.3.4.5.6.7.8.alpha")  << 17       << false;
+    QTest::newRow("0.1.2.3.4.5.6.7.8 alpha")  << QList<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8 } << QVersionNumber(QList<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8 }) << QStringLiteral("0.1.2.3.4.5.6.7.8") << QStringLiteral("0.1.2.3.4.5.6.7.8 alpha")  << 17       << false;
+    QTest::newRow("0.1.2.3.4.5.6.7.8 alp ha") << QList<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8 } << QVersionNumber(QList<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8 }) << QStringLiteral("0.1.2.3.4.5.6.7.8") << QStringLiteral("0.1.2.3.4.5.6.7.8 alp ha") << 17       << false;
+    QTest::newRow("0.1.2.3.4.5.6.7.8alp ha")  << QList<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8 } << QVersionNumber(QList<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8 }) << QStringLiteral("0.1.2.3.4.5.6.7.8") << QStringLiteral("0.1.2.3.4.5.6.7.8alp ha")  << 17       << false;
+    QTest::newRow("10.09")                    << QList<int> { 10, 9 }                     << QVersionNumber(QList<int> { 10, 9 })                     << QStringLiteral("10.9")              << QStringLiteral("10.09")                    << 5        << false;
+    QTest::newRow("10.0x")                    << QList<int> { 10, 0 }                     << QVersionNumber(QList<int> { 10, 0 })                     << QStringLiteral("10.0")              << QStringLiteral("10.0x")                    << 4        << false;
+    QTest::newRow("10.0xTest")                << QList<int> { 10, 0 }                     << QVersionNumber(QList<int> { 10, 0 })                     << QStringLiteral("10.0")              << QStringLiteral("10.0xTest")                << 4        << false;
+    QTest::newRow("127.09")                   << QList<int> { 127, 9 }                    << QVersionNumber(QList<int> { 127, 9 })                    << QStringLiteral("127.9")             << QStringLiteral("127.09")                   << 6        << false;
+    QTest::newRow("127.0x")                   << QList<int> { 127, 0 }                    << QVersionNumber(QList<int> { 127, 0 })                    << QStringLiteral("127.0")             << QStringLiteral("127.0x")                   << 5        << false;
+    QTest::newRow("127.0xTest")               << QList<int> { 127, 0 }                    << QVersionNumber(QList<int> { 127, 0 })                    << QStringLiteral("127.0")             << QStringLiteral("127.0xTest")               << 5        << false;
+    QTest::newRow("128.09")                   << QList<int> { 128, 9 }                    << QVersionNumber(QList<int> { 128, 9 })                    << QStringLiteral("128.9")             << QStringLiteral("128.09")                   << 6        << false;
+    QTest::newRow("128.0x")                   << QList<int> { 128, 0 }                    << QVersionNumber(QList<int> { 128, 0 })                    << QStringLiteral("128.0")             << QStringLiteral("128.0x")                   << 5        << false;
+    QTest::newRow("128.0xTest")               << QList<int> { 128, 0 }                    << QVersionNumber(QList<int> { 128, 0 })                    << QStringLiteral("128.0")             << QStringLiteral("128.0xTest")               << 5        << false;
 }
 
 namespace UglyOperator {
 // ugh, but the alternative (operator <<) is even worse...
-static inline QVector<int> operator+(QVector<int> v, int i) { v.push_back(i); return v; }
+static inline QList<int> operator+(QList<int> v, int i) { v.push_back(i); return v; }
 }
 
 void tst_QVersionNumber::comparisonData()
@@ -200,7 +200,7 @@ void tst_QVersionNumber::comparisonData()
     QTest::newRow("0.-129, 0")          << QVersionNumber(0, -129)     << QVersionNumber(0)           << false << true  << true  << true  << false << false << -129  << false          << QVersionNumber(0);
     QTest::newRow("0, 0.-129")          << QVersionNumber(0)           << QVersionNumber(0, -129)     << false << true  << false << false << true  << true  <<  129  << true           << QVersionNumber(0);
 
-    const QVector<int> common = QVector<int>() << 0 << 1 << 2 << 3 << 4 << 5 << 6;
+    const QList<int> common = QList<int>({ 0, 1, 2, 3, 4, 5, 6 });
     using namespace UglyOperator;
     QTest::newRow("0.1.2.3.4.5.6.0.1.2, 0.1.2.3.4.5.6.0.1")    << QVersionNumber(common + 0 + 1 + 2) << QVersionNumber(common + 0 + 1)     << false << true  << false << false << true  << true  <<  2             << false          << QVersionNumber(common + 0 + 1);
     QTest::newRow("0.1.2.3.4.5.6.0.1, 0.1.2.3.4.5.6.0.1.2")    << QVersionNumber(common + 0 + 1)     << QVersionNumber(common + 0 + 1 + 2) << false << true  << true  << true  << false << false << -2             << true           << QVersionNumber(common + 0 + 1);
@@ -217,7 +217,7 @@ void tst_QVersionNumber::comparisonData()
 
 void tst_QVersionNumber::initTestCase()
 {
-    qRegisterMetaType<QVector<int> >();
+    qRegisterMetaType<QList<int>>();
 }
 
 void tst_QVersionNumber::constructorDefault()
@@ -227,7 +227,7 @@ void tst_QVersionNumber::constructorDefault()
     QCOMPARE(version.majorVersion(), 0);
     QCOMPARE(version.minorVersion(), 0);
     QCOMPARE(version.microVersion(), 0);
-    QCOMPARE(version.segments(), QVector<int>());
+    QCOMPARE(version.segments(), QList<int>());
 }
 
 void tst_QVersionNumber::constructorVersioned_data()
@@ -237,7 +237,7 @@ void tst_QVersionNumber::constructorVersioned_data()
 
 void tst_QVersionNumber::constructorVersioned()
 {
-    QFETCH(QVector<int>, segments);
+    QFETCH(QList<int>, segments);
     QFETCH(QVersionNumber, expectedVersion);
 
     QVersionNumber version(segments);
@@ -250,17 +250,17 @@ void tst_QVersionNumber::constructorVersioned()
 void tst_QVersionNumber::constructorExplicit()
 {
     QVersionNumber v1(1);
-    QVersionNumber v2(QVector<int>() << 1);
+    QVersionNumber v2(QList<int>({ 1 }));
 
     QCOMPARE(v1.segments(), v2.segments());
 
     QVersionNumber v3(1, 2);
-    QVersionNumber v4(QVector<int>() << 1 << 2);
+    QVersionNumber v4(QList<int>({ 1, 2 }));
 
     QCOMPARE(v3.segments(), v4.segments());
 
     QVersionNumber v5(1, 2, 3);
-    QVersionNumber v6(QVector<int>() << 1 << 2 << 3);
+    QVersionNumber v6(QList<int>({ 1, 2, 3 }));
 
     QCOMPARE(v5.segments(), v6.segments());
 
@@ -277,7 +277,7 @@ void tst_QVersionNumber::constructorCopy_data()
 
 void tst_QVersionNumber::constructorCopy()
 {
-    QFETCH(QVector<int>, segments);
+    QFETCH(QList<int>, segments);
     QFETCH(QVersionNumber, expectedVersion);
 
     QVersionNumber original(segments);
@@ -422,14 +422,14 @@ void tst_QVersionNumber::normalized_data()
     QTest::addColumn<QVersionNumber>("version");
     QTest::addColumn<QVersionNumber>("expected");
 
-    QTest::newRow("0")        << QVersionNumber(0) << QVersionNumber();
-    QTest::newRow("1")        << QVersionNumber(1) << QVersionNumber(1);
-    QTest::newRow("1.2")      << QVersionNumber(1, 2) << QVersionNumber(1, 2);
-    QTest::newRow("1.0")      << QVersionNumber(1, 0) << QVersionNumber(1);
-    QTest::newRow("1.0.0")      << QVersionNumber(1, 0, 0) << QVersionNumber(1);
-    QTest::newRow("1.0.1")      << QVersionNumber(1, 0, 1) << QVersionNumber(1, 0, 1);
-    QTest::newRow("1.0.1.0")      << QVersionNumber(QVector<int>() << 1 << 0 << 1 << 0) << QVersionNumber(1, 0, 1);
-    QTest::newRow("0.0.1.0")      << QVersionNumber(QVector<int>() << 0 << 0 << 1 << 0) << QVersionNumber(0, 0, 1);
+    QTest::newRow("0")       << QVersionNumber(0)       << QVersionNumber();
+    QTest::newRow("1")       << QVersionNumber(1)       << QVersionNumber(1);
+    QTest::newRow("1.2")     << QVersionNumber(1, 2)    << QVersionNumber(1, 2);
+    QTest::newRow("1.0")     << QVersionNumber(1, 0)    << QVersionNumber(1);
+    QTest::newRow("1.0.0")   << QVersionNumber(1, 0, 0) << QVersionNumber(1);
+    QTest::newRow("1.0.1")   << QVersionNumber(1, 0, 1) << QVersionNumber(1, 0, 1);
+    QTest::newRow("1.0.1.0") << QVersionNumber(QList<int>({ 1, 0, 1, 0 })) << QVersionNumber(1, 0, 1);
+    QTest::newRow("0.0.1.0") << QVersionNumber(QList<int>({ 0, 0, 1, 0 })) << QVersionNumber(0, 0, 1);
 }
 
 void tst_QVersionNumber::normalized()
@@ -446,13 +446,13 @@ void tst_QVersionNumber::isNormalized_data()
     QTest::addColumn<QVersionNumber>("version");
     QTest::addColumn<bool>("expected");
 
-    QTest::newRow("null")        << QVersionNumber() << true;
-    QTest::newRow("0")        << QVersionNumber(0) << false;
-    QTest::newRow("1")        << QVersionNumber(1) << true;
-    QTest::newRow("1.2")      << QVersionNumber(1, 2) << true;
-    QTest::newRow("1.0")      << QVersionNumber(1, 0) << false;
-    QTest::newRow("1.0.0")      << QVersionNumber(1, 0, 0) << false;
-    QTest::newRow("1.0.1")      << QVersionNumber(1, 0, 1) << true;
+    QTest::newRow("null")  << QVersionNumber() << true;
+    QTest::newRow("0")     << QVersionNumber(0) << false;
+    QTest::newRow("1")     << QVersionNumber(1) << true;
+    QTest::newRow("1.2")   << QVersionNumber(1, 2) << true;
+    QTest::newRow("1.0")   << QVersionNumber(1, 0) << false;
+    QTest::newRow("1.0.0") << QVersionNumber(1, 0, 0) << false;
+    QTest::newRow("1.0.1") << QVersionNumber(1, 0, 1) << true;
 }
 
 void tst_QVersionNumber::isNormalized()
@@ -470,7 +470,7 @@ void tst_QVersionNumber::assignment_data()
 
 void tst_QVersionNumber::assignment()
 {
-    QFETCH(QVector<int>, segments);
+    QFETCH(QList<int>, segments);
     QFETCH(QVersionNumber, expectedVersion);
 
     QVersionNumber original(segments);
@@ -492,17 +492,17 @@ void tst_QVersionNumber::fromString_data()
     const QString largerThanIntCanHoldString1 = "0." + QString::number(largerThanIntCanHold);
 
     QTest::newRow(qPrintable(largerThanIntCanHoldString0))
-            << QVector<int>()  << QVersionNumber()  << QString()           << largerThanIntCanHoldString0 << 0 << true;
+            << QList<int>()  << QVersionNumber()  << QString()           << largerThanIntCanHoldString0 << 0 << true;
     QTest::newRow(qPrintable(largerThanIntCanHoldString1))
-            << QVector<int>(0) << QVersionNumber(0) << QStringLiteral("0") << largerThanIntCanHoldString1 << 1 << true;
+            << QList<int>(0) << QVersionNumber(0) << QStringLiteral("0") << largerThanIntCanHoldString1 << 1 << true;
 
     const QString largerThanULongLongCanHoldString0 = QString::number(std::numeric_limits<qulonglong>::max()) + "0.0";      // 10x ULLONG_MAX
     const QString largerThanULongLongCanHoldString1 = "0." + QString::number(std::numeric_limits<qulonglong>::max()) + '0'; // 10x ULLONG_MAX
 
     QTest::newRow(qPrintable(largerThanULongLongCanHoldString0))
-            << QVector<int>()  << QVersionNumber()  << QString()           << largerThanULongLongCanHoldString0 << 0 << true;
+            << QList<int>()  << QVersionNumber()  << QString()           << largerThanULongLongCanHoldString0 << 0 << true;
     QTest::newRow(qPrintable(largerThanULongLongCanHoldString1))
-            << QVector<int>(0) << QVersionNumber(0) << QStringLiteral("0") << largerThanULongLongCanHoldString1 << 1 << true;
+            << QList<int>(0) << QVersionNumber(0) << QStringLiteral("0") << largerThanULongLongCanHoldString1 << 1 << true;
 }
 
 void tst_QVersionNumber::fromString()
@@ -529,10 +529,10 @@ void tst_QVersionNumber::toString_data()
 {
     singleInstanceData();
 
-    //                                        segments                      expectedVersion            expectedString      constructionString     suffixIndex   null
-    QTest::newRow("-1")                    << (QVector<int>() << -1)       << QVersionNumber(-1)      << QString("-1")    << QString()           << 0          << true;
-    QTest::newRow("-1.0")                  << (QVector<int>() << -1 << 0)  << QVersionNumber(-1, 0)   << QString("-1.0")  << QString()           << 0          << true;
-    QTest::newRow("1.-2")                  << (QVector<int>() << 1 << -2)  << QVersionNumber(1, -2)   << QString("1.-2")  << QString()           << 0          << true;
+    //                    segments                   expectedVersion          expectedString      constructionString suffixIndex null
+    QTest::newRow("-1")   << (QList<int>({ -1 }))    << QVersionNumber(-1)    << QString("-1")    << QString()       << 0        << true;
+    QTest::newRow("-1.0") << (QList<int>({ -1, 0 })) << QVersionNumber(-1, 0) << QString("-1.0")  << QString()       << 0        << true;
+    QTest::newRow("1.-2") << (QList<int>({ 1, -2 })) << QVersionNumber(1, -2) << QString("1.-2")  << QString()       << 0        << true;
 }
 
 void tst_QVersionNumber::toString()
@@ -550,7 +550,7 @@ void tst_QVersionNumber::isNull_data()
 
 void tst_QVersionNumber::isNull()
 {
-    QFETCH(QVector<int>, segments);
+    QFETCH(QList<int>, segments);
     QFETCH(bool, isNull);
 
     QVersionNumber version(segments);
@@ -565,7 +565,7 @@ void tst_QVersionNumber::serialize_data()
 
 void tst_QVersionNumber::serialize()
 {
-    QFETCH(QVector<int>, segments);
+    QFETCH(QList<int>, segments);
 
     QVersionNumber original(segments);
     QVersionNumber version;
@@ -601,9 +601,9 @@ void tst_QVersionNumber::moveSemantics()
         v2 = std::move(v1);
         QCOMPARE(v2, QVersionNumber(1, 2, 3));
     }
-    // QVersionNumber(QVector<int> &&)
+    // QVersionNumber(QList<int> &&)
     {
-        QVector<int> segments = QVector<int>() << 1 << 2 << 3;
+        QList<int> segments = QList<int>({ 1, 2, 3});
         QVersionNumber v1(segments);
         QVersionNumber v2(std::move(segments));
         QVERIFY(!v1.isNull());
@@ -628,7 +628,7 @@ void tst_QVersionNumber::moveSemantics()
     {
         QVersionNumber v(1, 2, 3);
         QVERIFY(!v.isNull());
-        QVector<int> segments;
+        QList<int> segments;
         segments = v.segments();
         QVERIFY(!v.isNull());
         QVERIFY(!segments.empty());